From ffd0afeb26e5202c7441363acd7e462d7b555225 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Thu, 1 May 2025 22:04:59 +0300 Subject: [PATCH 01/40] mv some things --- .github/workflows/distro-ci.yml | 6 +- .../workflows/run-tests-feature-branch.yml | 14 ++-- .github/workflows/testing.yml | 20 +++--- .gitignore | 10 +++ MODULE.bazel | 1 + WORKSPACE | 0 conandata.yml | 16 +++++ conanfile.py | 67 ++++++++++++------- {scripts => tools}/build.py | 0 {scripts => tools}/increment_minor.sh | 0 {scripts => tools}/increment_patch.sh | 0 11 files changed, 90 insertions(+), 44 deletions(-) create mode 100644 MODULE.bazel create mode 100644 WORKSPACE create mode 100644 conandata.yml rename {scripts => tools}/build.py (100%) rename {scripts => tools}/increment_minor.sh (100%) rename {scripts => tools}/increment_patch.sh (100%) diff --git a/.github/workflows/distro-ci.yml b/.github/workflows/distro-ci.yml index 0a938baf..968195ed 100644 --- a/.github/workflows/distro-ci.yml +++ b/.github/workflows/distro-ci.yml @@ -32,7 +32,7 @@ jobs: name: Alpine - tag: ubuntu name: Ubuntu - + steps: - run: | set -e @@ -43,8 +43,8 @@ jobs: git clone https://github.com/${{ github.event.pull_request.head.repo.full_name }}.git && cd HyperCPU git checkout ${{ github.event.pull_request.head.sha }} git submodule update --init --recursive - - python3 scripts/build.py -icb \ + + python3 tools/build.py -icb \ --config Release \ --config Debug \ --build-dir build \ diff --git a/.github/workflows/run-tests-feature-branch.yml b/.github/workflows/run-tests-feature-branch.yml index 07630e22..f11b9616 100644 --- a/.github/workflows/run-tests-feature-branch.yml +++ b/.github/workflows/run-tests-feature-branch.yml @@ -13,29 +13,29 @@ jobs: - name: Checkout code uses: actions/checkout@v4 with: - submodules: 'true' - + submodules: "true" + - name: Build and test with GCC on Release profile run: | - python3 scripts/build.py -icb \ + python3 tools/build.py -icb \ --config Release \ --build-dir build \ -D CMAKE_CXX_COMPILER:STRING=g++ \ -D CMAKE_C_COMPILER:STRING=gcc \ --profiles-detection cd build/Release && ctest -V && cd ../.. - python3 scripts/build.py -r --config Release --build-dir build - + python3 tools/build.py -r --config Release --build-dir build + - name: Build and test with LLVM on Release profile run: | - python3 scripts/build.py -icb \ + python3 tools/build.py -icb \ --config Release \ --build-dir build \ -D CMAKE_CXX_COMPILER:STRING=clang++-19 \ -D CMAKE_C_COMPILER:STRING=clang-19 \ --profiles-detection cd build/Release && ctest -V && cd ../.. - python3 scripts/build.py -r --config Release --build-dir build + python3 tools/build.py -r --config Release --build-dir build - name: Cleanup (Conan cache + leftovers in build) run: | diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index 90a44b1e..555ebc55 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -15,51 +15,51 @@ jobs: - name: Checkout code uses: actions/checkout@v4 with: - submodules: 'true' - + submodules: "true" + - name: Build and test with GCC on Debug profile run: | - python3 scripts/build.py -icb \ + python3 tools/build.py -icb \ --config Debug \ --build-dir build \ -D CMAKE_CXX_COMPILER:STRING=g++ \ -D CMAKE_C_COMPILER:STRING=gcc \ --profiles-detection cd build/Debug && ctest -V && cd ../.. - python3 scripts/build.py -r --config Debug --build-dir build + python3 tools/build.py -r --config Debug --build-dir build - name: Build and test with GCC on Release profile run: | - python3 scripts/build.py -icb \ + python3 tools/build.py -icb \ --config Release \ --build-dir build \ -D CMAKE_CXX_COMPILER:STRING=g++ \ -D CMAKE_C_COMPILER:STRING=gcc \ --profiles-detection cd build/Release && ctest -V && cd ../.. - python3 scripts/build.py -r --config Release --build-dir build + python3 tools/build.py -r --config Release --build-dir build - name: Build and test with LLVM on Debug profile run: | - python3 scripts/build.py -icb \ + python3 tools/build.py -icb \ --config Debug \ --build-dir build \ -D CMAKE_CXX_COMPILER:STRING=clang++-19 \ -D CMAKE_C_COMPILER:STRING=clang-19 \ --profiles-detection cd build/Debug && ctest -V && cd ../.. - python3 scripts/build.py -r --config Debug --build-dir build + python3 tools/build.py -r --config Debug --build-dir build - name: Build and test with LLVM on Release profile run: | - python3 scripts/build.py -icb \ + python3 tools/build.py -icb \ --config Release \ --build-dir build \ -D CMAKE_CXX_COMPILER:STRING=clang++-19 \ -D CMAKE_C_COMPILER:STRING=clang-19 \ --profiles-detection cd build/Release && ctest -V && cd ../.. - python3 scripts/build.py -r --config Release --build-dir build + python3 tools/build.py -r --config Release --build-dir build - name: Cleanup (Conan cache + leftovers in build) run: | diff --git a/.gitignore b/.gitignore index 87371c2c..a60a8090 100644 --- a/.gitignore +++ b/.gitignore @@ -91,3 +91,13 @@ CMakeUserPresets* # Distribution packages dist/* !dist/CMakeLists.txt + +# Bazel stuff +*.lock + +# Conan toolchain generated for Bazel +conan/ + +# Bazel builds with four directories, see for info: +# https://bazel.build/remote/output-directories +bazel-* diff --git a/MODULE.bazel b/MODULE.bazel new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/MODULE.bazel @@ -0,0 +1 @@ + diff --git a/WORKSPACE b/WORKSPACE new file mode 100644 index 00000000..e69de29b diff --git a/conandata.yml b/conandata.yml new file mode 100644 index 00000000..65d7326a --- /dev/null +++ b/conandata.yml @@ -0,0 +1,16 @@ +# HyperCPU works with multiple buildsystems, this +# switch affects which one will be used to defined project layout, +# toolchains etc. +buildsystem: "cmake" + +requirements: + gtest: "1.14.0" + benchmark: "1.9.1" + abseil: "20240116.1" + libbacktrace: "cci.20210118" + argparse: "3.2" + eternal: "1.0.1" + re2: "20230801" + fmt: "11.1.4" + libunwind: "1.8.1" + boost: "1.87.0" diff --git a/conanfile.py b/conanfile.py index 1fe452f0..5136a367 100644 --- a/conanfile.py +++ b/conanfile.py @@ -1,35 +1,54 @@ -from typing import Self, List -from functools import lru_cache +import enum + +from functools import cached_property, lru_cache +from typing import Dict, Any, Collection, Mapping, Callable, Optional, cast from conan import ConanFile from conan.tools.cmake import cmake_layout +from conan.tools.google import bazel_layout +from conan.errors import ConanInvalidConfiguration + + +class Buildsystem(enum.StrEnum): + CMAKE = 'cmake' + BAZEL = 'bazel' class HyperCPU(ConanFile): - generators: List[str] = ['CMakeToolchain', 'CMakeDeps'] - settings: List[str] = ['os', 'compiler', 'build_type', 'arch'] - - def __init__(self: Self, display_name: str = '') -> None: - self.name = 'HyperCPU' - - self.__requirements = { - 'gtest': '1.14.0', - 'benchmark': '1.9.1', - 'abseil': '20240116.1', - 'libbacktrace': 'cci.20210118', - 'argparse': '3.2', - 'eternal': '1.0.1', - 're2': '20230801', - 'fmt': '11.1.4', - 'libunwind': '1.8.1', - 'boost': '1.87.0' - } - super().__init__(display_name) + name: 'HyperCPU' + # generators = + settings = ['os', 'compiler', 'build_type', 'arch'] + + # conan data is fetched dynamically from + # conandata.yml + conan_data: Dict[str, Any] + + @cached_property + def generators(self) -> Collection[str]: + return cast(Collection[str], self.__resolve_buildsystem({ + Buildsystem.CMAKE: lambda _: ['CMakeToolchain', 'CMakeDeps'], + Buildsystem.BAZEL: lambda _: ['BazelToolchain', 'BazelDeps'] + })) @lru_cache - def requirements(self: Self) -> None: - for req, version in self.__requirements.items(): + def requirements(self) -> None: + for req, version in self.conan_data['requirements'].items(): self.requires(f'{req}/{version}') def layout(self): - cmake_layout(self) + self.__resolve_buildsystem({ + Buildsystem.CMAKE: lambda self: cmake_layout(self), + Buildsystem.BAZEL: lambda self: bazel_layout(self) + }) + + def __resolve_buildsystem( + self, + visitors: Mapping[Buildsystem, Callable[['HyperCPU'], Optional[Any]]] + ) -> Optional[Any]: + buildsystem = Buildsystem(self.conan_data['buildsystem']) + if buildsystem not in visitors: + raise ConanInvalidConfiguration( + f'buildsystem: {buildsystem} is not supported by visitors: ' + ', '.join(visitors) + ) + + return visitors[buildsystem](self) diff --git a/scripts/build.py b/tools/build.py similarity index 100% rename from scripts/build.py rename to tools/build.py diff --git a/scripts/increment_minor.sh b/tools/increment_minor.sh similarity index 100% rename from scripts/increment_minor.sh rename to tools/increment_minor.sh diff --git a/scripts/increment_patch.sh b/tools/increment_patch.sh similarity index 100% rename from scripts/increment_patch.sh rename to tools/increment_patch.sh From cfb4135d3e45dcfe52dd551713ce6958e2159306 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 2 May 2025 03:11:26 +0300 Subject: [PATCH 02/40] some templates --- BUILD.bazel | 11 +++ MODULE.bazel | 35 +++++++++ WORKSPACE | 0 conandata.yml | 2 +- conanfile.py | 2 +- src/Assembler/BUILD.bazel | 29 ++++++++ src/BUILD.bazel | 14 ++++ src/BacktraceProvider/BUILD.bazel | 24 +++++++ src/CMakeLists.txt | 19 ++--- src/Emulator/BUILD.bazel | 28 ++++++++ src/Logger/BUILD.bazel | 13 ++++ src/Pog/BUILD.bazel | 14 ++++ tools/bazel/BUILD.bazel | 8 +++ tools/bazel/pch.bzl | 116 ++++++++++++++++++++++++++++++ 14 files changed, 305 insertions(+), 10 deletions(-) create mode 100644 BUILD.bazel delete mode 100644 WORKSPACE create mode 100644 src/Assembler/BUILD.bazel create mode 100644 src/BUILD.bazel create mode 100644 src/BacktraceProvider/BUILD.bazel create mode 100644 src/Emulator/BUILD.bazel create mode 100644 src/Logger/BUILD.bazel create mode 100644 src/Pog/BUILD.bazel create mode 100644 tools/bazel/BUILD.bazel create mode 100644 tools/bazel/pch.bzl diff --git a/BUILD.bazel b/BUILD.bazel new file mode 100644 index 00000000..981f851c --- /dev/null +++ b/BUILD.bazel @@ -0,0 +1,11 @@ +'Top level build configuration, use for tooling only' + +load('@hedron_compile_commands//:refresh_compile_commands.bzl', 'refresh_compile_commands') + + +refresh_compile_commands( + name = 'refresh_compile_commands', + targets = { + '//src/...': '', + } +) diff --git a/MODULE.bazel b/MODULE.bazel index 8b137891..cc85306e 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -1 +1,36 @@ +'HyperCPU' +module( + name = 'hyper-cpu', + compatibility_level = 1 +) + +# We use conan for deps management +conan = use_extension('//conan:conan_deps_module_extension.bzl', 'conan_extension') + +use_repo( + conan, + 'abseil', + 'argparse', + 'benchmark', + 'boost', + 'eternal', + 'gtest', + 'libbacktrace', + 'libunwind', + 'bzip2', + 'fmt', + 're2', + 'xz_utils', + 'zlib' +) + +bazel_dep(name = 'rules_cc', version = '0.0.17') +bazel_dep(name = 'rules_foreign_cc', version = '0.11.1') + +bazel_dep(name = 'hedron_compile_commands', dev_dependency = True) +git_override( + module_name = 'hedron_compile_commands', + remote = 'https://github.com/hedronvision/bazel-compile-commands-extractor.git', + commit = '4f28899228fb3ad0126897876f147ca15026151e' +) diff --git a/WORKSPACE b/WORKSPACE deleted file mode 100644 index e69de29b..00000000 diff --git a/conandata.yml b/conandata.yml index 65d7326a..52479245 100644 --- a/conandata.yml +++ b/conandata.yml @@ -1,7 +1,7 @@ # HyperCPU works with multiple buildsystems, this # switch affects which one will be used to defined project layout, # toolchains etc. -buildsystem: "cmake" +buildsystem: "bazel" requirements: gtest: "1.14.0" diff --git a/conanfile.py b/conanfile.py index 5136a367..cad19131 100644 --- a/conanfile.py +++ b/conanfile.py @@ -1,5 +1,6 @@ import enum +from pathlib import Path from functools import cached_property, lru_cache from typing import Dict, Any, Collection, Mapping, Callable, Optional, cast @@ -16,7 +17,6 @@ class Buildsystem(enum.StrEnum): class HyperCPU(ConanFile): name: 'HyperCPU' - # generators = settings = ['os', 'compiler', 'build_type', 'arch'] # conan data is fetched dynamically from diff --git a/src/Assembler/BUILD.bazel b/src/Assembler/BUILD.bazel new file mode 100644 index 00000000..6e30674a --- /dev/null +++ b/src/Assembler/BUILD.bazel @@ -0,0 +1,29 @@ +load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') + + +cc_library( + name = 'assembler_core', + srcs = glob(['**/*.cpp']), + hdrs = glob(['**/*.hpp']), + includes = [ + '//src', + '//src/Assembler' + ], + deps = [ + '@fmt//:fmt', + '@argparse//:argparse', + '@eternal//:eternal', + '@re2//:re2', + '//src:pch', + '//src/Pog:pog' + ] +) + + +cc_binary( + name = 'hcasm', + srcs = glob(['**/*.cpp']), + deps = [ + ':assembler_core' + ] +) diff --git a/src/BUILD.bazel b/src/BUILD.bazel new file mode 100644 index 00000000..2c287eee --- /dev/null +++ b/src/BUILD.bazel @@ -0,0 +1,14 @@ +load('//tools/bazel:pch.bzl', 'precompiled_headers') + + +package( + default_visibility = [ + "//:__subpackages__", + ], +) + + +precompiled_headers( + name = 'pch', + main = 'pch.hpp' +) diff --git a/src/BacktraceProvider/BUILD.bazel b/src/BacktraceProvider/BUILD.bazel new file mode 100644 index 00000000..65bc4930 --- /dev/null +++ b/src/BacktraceProvider/BUILD.bazel @@ -0,0 +1,24 @@ +load('@rules_cc//cc:defs.bzl', 'cc_library') + + +cc_library( + name = 'backtrace_provider', + srcs = [ + 'BacktraceProvider.cpp' + ], + hdrs = [ + 'BacktraceProvider.hpp' + ], + includes = [ + '//src' + ], + deps = [ + '@fmt//:fmt', + '@argparse//:argparse', + '@eternal//:eternal', + '//src:pch', + '//src/Pog:pog', + '@libbacktrace//:libbacktrace', + '@libunwind//:libunwind' + ] +) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 798be99a..3fb1253e 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -2,21 +2,24 @@ # TODO: refactor all includes relevant to CMAKE_SOURCE_DIR, like #include add_library( - pch INTERFACE - pch.hpp + pch + INTERFACE + pch.hpp ) target_precompile_headers(pch INTERFACE pch.hpp) add_library( - pog INTERFACE - Pog/Pog.hpp + pog + INTERFACE + Pog/Pog.hpp ) target_precompile_headers(pog INTERFACE Pog/Pog.hpp) + target_include_directories( - pog - INTERFACE - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_CURRENT_SOURCE_DIR}/Pog + pog + INTERFACE + ${CMAKE_SOURCE_DIR}/src + ${CMAKE_CURRENT_SOURCE_DIR}/Pog ) add_subdirectory(Emulator) diff --git a/src/Emulator/BUILD.bazel b/src/Emulator/BUILD.bazel new file mode 100644 index 00000000..de086bc2 --- /dev/null +++ b/src/Emulator/BUILD.bazel @@ -0,0 +1,28 @@ +load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') + + +cc_library( + name = 'emulator_core', + srcs = glob(['**/*.cpp']), + hdrs = glob(['**/*.hpp']), + includes = [ + '//src', + '//src/Emulator' + ], + deps = [ + '@fmt//:fmt', + '@argparse//:argparse', + '@eternal//:eternal', + '//src:pch', + '//src/Pog:pog' + ] +) + + +cc_binary( + name = 'hcemul', + srcs = glob(['**/*.cpp']), + deps = [ + ':emulator_core' + ] +) diff --git a/src/Logger/BUILD.bazel b/src/Logger/BUILD.bazel new file mode 100644 index 00000000..49f6551c --- /dev/null +++ b/src/Logger/BUILD.bazel @@ -0,0 +1,13 @@ +load('@rules_cc//cc:defs.bzl', 'cc_library') + + +cc_library( + name = 'logger', + hdrs = [ + 'Colors.hpp', + 'Logger.hpp' + ], + includes = [ + '//src', + ] +) diff --git a/src/Pog/BUILD.bazel b/src/Pog/BUILD.bazel new file mode 100644 index 00000000..8b8629af --- /dev/null +++ b/src/Pog/BUILD.bazel @@ -0,0 +1,14 @@ +load('//tools/bazel:pch.bzl', 'precompiled_headers') + + +package( + default_visibility = [ + "//:__subpackages__", + ], +) + + +precompiled_headers( + name = 'pog', + main = 'Pog.hpp' +) diff --git a/tools/bazel/BUILD.bazel b/tools/bazel/BUILD.bazel new file mode 100644 index 00000000..ce91b6d7 --- /dev/null +++ b/tools/bazel/BUILD.bazel @@ -0,0 +1,8 @@ +'Common macros, rules etc. used by HyperCPU' + + +package( + default_visibility = [ + "//:__subpackages__", + ], +) diff --git a/tools/bazel/pch.bzl b/tools/bazel/pch.bzl new file mode 100644 index 00000000..316bcad7 --- /dev/null +++ b/tools/bazel/pch.bzl @@ -0,0 +1,116 @@ +'Custom target to support precompiled headers. Notice, this is relevant to end-consumer project, like ours' +# Inspired by: https://github.com/erenon/rules_pch + +load('@rules_cc//cc:action_names.bzl', 'CPP_COMPILE_ACTION_NAME') +load('@bazel_tools//tools/cpp:toolchain_utils.bzl', 'find_cpp_toolchain') + + +def _global_flags(ctx, cc_toolchain): + feature_configuration = cc_common.configure_features( + ctx = ctx, + cc_toolchain = cc_toolchain, + ) + compile_variables = cc_common.create_compile_variables( + feature_configuration = feature_configuration, + cc_toolchain = cc_toolchain, + user_compile_flags = ctx.fragments.cpp.cxxopts + ctx.fragments.cpp.copts, + ) + tc_flags = cc_common.get_memory_inefficient_command_line( + feature_configuration = feature_configuration, + action_name = CPP_COMPILE_ACTION_NAME, + variables = compile_variables, + ) + + if cc_toolchain.needs_pic_for_dynamic_libraries(feature_configuration=feature_configuration): + return tc_flags + ['-fPIC'] + + return tc_flags + + +def _precompiled_headers_impl(ctx): + files = ctx.attr.main.files.to_list() + if len(files) != 1: + fail('expected a single aggregated header to compile, got: {}'.format(files)) + main_file = files[0] + + args = ctx.actions.args() + + # add args specified by the toolchain and on the command line + cc_toolchain = find_cpp_toolchain(ctx) + args.add_all(_global_flags(ctx, cc_toolchain)) + + # collect headers, include paths and defines of dependencies + headers = [] + for dep in ctx.attr.deps: + if not CcInfo in dep: + fail('dep arguments must provide CcInfo (e.g: cc_library)') + + # collect exported header files + compilation_context = dep[CcInfo].compilation_context + headers.append(compilation_context.headers) + + # add defines + for define in compilation_context.defines.to_list(): + args.add('-D' + define) + + # add include dirs + for i in compilation_context.includes.to_list(): + args.add('-I' + i) + + args.add_all(compilation_context.quote_includes.to_list(), before_each = '-iquote') + args.add_all(compilation_context.system_includes.to_list(), before_each = '-isystem') + + inputs = depset(direct=[main_file], transitive=headers+[cc_toolchain.all_files]) + + # add args specified for this rule + args.add_all(ctx.attr.copts) + + # force compilation of header + args.add('-xc++-header') + args.add(main_file.path) + + # specify output + output = ctx.actions.declare_file('{}.pch'.format(main_file.basename)) + args.add('-o', output.path) + + # Unless -MD is specified while creating the precompiled file, + # the .d file of the user of the precompiled file will not + # show the precompiled file: therefore bazel will not rebuild + # the user if the pch file changes. + args.add('-MD') + args.add('-MF', "/dev/null") + + ctx.actions.run( + inputs = inputs, + outputs = [output], + executable = cc_toolchain.compiler_executable, + arguments = [args], + mnemonic = 'PrecompileHdrs', + progress_message = 'Pre-compiling header: {}'.format(main_file.basename), + ) + + # create a CcInfo output that cc_binary rules can depend on + compilation_context = cc_common.create_compilation_context( + headers = depset(direct=[output, main_file]), + includes = depset(direct=[output.dirname]), + ) + main_cc_info = CcInfo(compilation_context = compilation_context, linking_context = None) + cc_info = cc_common.merge_cc_infos( + direct_cc_infos = [main_cc_info], + cc_infos = [dep[CcInfo] for dep in ctx.attr.deps if CcInfo in dep], + ) + + return [cc_info] + + +precompiled_headers = rule( + implementation = _precompiled_headers_impl, + attrs = { + 'main': attr.label(allow_files=True, mandatory=True), + 'deps': attr.label_list(), + 'copts': attr.string_list(), + '_cc_toolchain': attr.label(default = Label('@bazel_tools//tools/cpp:current_cc_toolchain')), + }, + toolchains = ['@bazel_tools//tools/cpp:toolchain_type'], + fragments = ['cpp'], +) From 5ca6d3fa213a266072e27a806bb43d8a1dae92fc Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sat, 3 May 2025 03:23:47 +0300 Subject: [PATCH 03/40] moving and renaming things --- MODULE.bazel | 3 +- conandata.yml | 1 + dist/HPool | 2 +- src/Assembler/BUILD.bazel | 23 +++-- src/Assembler/Core/BinaryTransformer.cpp | 16 +-- src/Assembler/Core/BinaryTransformer.hpp | 2 +- src/Assembler/Core/Compiler.cpp | 28 +++--- src/Assembler/Core/Compiler.hpp | 2 +- src/Assembler/Core/ModeNameAssoc.hpp | 4 +- src/Assembler/Core/OpcodeNameAssoc.hpp | 2 +- src/Assembler/Core/Parsers.cpp | 62 ++++++------ src/Assembler/Core/RegNameAssoc.hpp | 4 +- src/Assembler/Core/StatementCompilers.cpp | 6 +- src/Assembler/Core/Tokenizers.cpp | 4 +- src/Assembler/Main/Main.cpp | 11 +-- src/Assembler/Utils/Extension.hpp | 2 +- src/BacktraceProvider/BUILD.bazel | 8 +- src/BacktraceProvider/BacktraceProvider.cpp | 6 +- src/BacktraceProvider/BacktraceProvider.hpp | 2 +- src/CMakeLists.txt | 4 +- src/Common/BUILD.bazel | 11 +++ src/Common/Defs.hpp | 8 ++ .../LanguageSpec/AllowedFlags.hpp} | 7 +- src/Common/LanguageSpec/Flags.hpp | 15 +++ src/Common/LanguageSpec/Opcodes.hpp | 90 +++++++++++++++++ src/Common/LanguageSpec/Registers.hpp | 70 +++++++++++++ src/Common/NotImplemented.hpp | 12 +++ src/Emulator/BUILD.bazel | 55 ++++++----- src/Emulator/Core/CPU/ALU.hpp | 2 +- src/Emulator/Core/CPU/Assert.hpp | 2 +- src/Emulator/Core/CPU/CPU.cpp | 70 ++++++------- src/Emulator/Core/CPU/CPU.hpp | 10 +- src/Emulator/Core/CPU/Decoders/StdDecoder.cpp | 4 +- src/Emulator/Core/CPU/Decoders/StdDecoder.hpp | 13 ++- src/Emulator/Core/CPU/IO/Simple.cpp | 4 +- src/Emulator/Core/CPU/IO/Simple.hpp | 6 +- .../Core/CPU/Instructions/AllowedFlags.hpp | 10 -- src/Emulator/Core/CPU/Instructions/Flags.hpp | 30 ------ .../Core/CPU/Instructions/Opcodes.hpp | 98 ------------------- .../Core/CPU/Instructions/Registers.hpp | 71 -------------- .../Core/CPU/InstructionsImpl/ADC.cpp | 8 +- .../Core/CPU/InstructionsImpl/ADD.cpp | 10 +- .../Core/CPU/InstructionsImpl/AND.cpp | 8 +- .../Core/CPU/InstructionsImpl/ANDN.cpp | 10 +- .../Core/CPU/InstructionsImpl/BSWAP.cpp | 2 +- .../Core/CPU/InstructionsImpl/CALL.cpp | 2 +- .../Core/CPU/InstructionsImpl/CALLE.cpp | 4 +- .../Core/CPU/InstructionsImpl/CALLGR.cpp | 4 +- .../Core/CPU/InstructionsImpl/CALLL.cpp | 4 +- .../Core/CPU/InstructionsImpl/CCRF.cpp | 2 +- .../Core/CPU/InstructionsImpl/CMP.cpp | 40 +++++--- .../Core/CPU/InstructionsImpl/COVF.cpp | 2 +- .../Core/CPU/InstructionsImpl/CUDF.cpp | 2 +- .../Core/CPU/InstructionsImpl/DEC.cpp | 2 +- .../Core/CPU/InstructionsImpl/DIV.cpp | 4 +- .../Core/CPU/InstructionsImpl/HALT.cpp | 2 +- .../Core/CPU/InstructionsImpl/HID.cpp | 2 +- .../Core/CPU/InstructionsImpl/INC.cpp | 2 +- .../Core/CPU/InstructionsImpl/INTR.cpp | 2 +- .../Core/CPU/InstructionsImpl/JME.cpp | 5 +- .../Core/CPU/InstructionsImpl/JMGR.cpp | 2 +- .../Core/CPU/InstructionsImpl/JML.cpp | 2 +- .../Core/CPU/InstructionsImpl/JMP.cpp | 2 +- .../Core/CPU/InstructionsImpl/LOIVT.cpp | 2 +- .../Core/CPU/InstructionsImpl/MOV.cpp | 24 ++--- .../Core/CPU/InstructionsImpl/MUL.cpp | 8 +- src/Emulator/Core/CPU/InstructionsImpl/OR.cpp | 8 +- .../Core/CPU/InstructionsImpl/POP.cpp | 2 +- .../Core/CPU/InstructionsImpl/PUSH.cpp | 2 +- .../Core/CPU/InstructionsImpl/READ.cpp | 2 +- .../Core/CPU/InstructionsImpl/SHFL.cpp | 8 +- .../Core/CPU/InstructionsImpl/SHFR.cpp | 8 +- .../Core/CPU/InstructionsImpl/SUB.cpp | 8 +- .../Core/CPU/InstructionsImpl/WRITE.cpp | 2 +- .../Core/CPU/Interrupts/InterruptHandler.cpp | 6 +- .../CPU/Interrupts/ReservedInterrupts.hpp | 4 +- src/Emulator/Core/CPU/OperandsEvaluation.cpp | 8 +- src/Emulator/Core/CPU/Stack.cpp | 4 +- .../MemoryController/IMemoryController.hpp | 2 +- .../MemoryController/MemoryControllerST.hpp | 2 +- src/Emulator/Main/ExceptionHandling.cpp | 4 +- src/Emulator/Main/ExceptionHandling.hpp | 2 +- src/Emulator/Main/Main.cpp | 6 +- src/Emulator/Main/Main.hpp | 4 +- src/Emulator/Misc/byteswap.hpp | 2 +- src/Exit.hpp | 11 --- src/Logger/BUILD.bazel | 13 --- src/Logger/Colors.hpp | 8 -- src/Logger/Logger.hpp | 78 --------------- src/NotImplemented.hpp | 12 --- src/{ => PCH}/BUILD.bazel | 6 +- src/{pch.hpp => PCH/CStd.hpp} | 8 +- src/Pog/BUILD.bazel | 17 +++- .../AssemblerCore/AssemblerFail.cpp | 2 +- .../AssemblerCore/FullAssembler.cpp | 6 +- .../AssemblerCore/TwoOperandsSuccess.cpp | 2 +- .../Integration/EmulatorCore/CPU/CPU_POP.cpp | 4 +- .../Integration/EmulatorCore/CPU/CPU_PUSH.cpp | 4 +- .../Integration/EmulatorCore/CPU/CPU_READ.cpp | 2 +- .../EmulatorCore/CPU/CPU_WRITE.cpp | 2 +- .../EmulatorCore/Decoding/ADCInstr/R_IMM.cpp | 12 +-- .../EmulatorCore/Decoding/ADCInstr/R_M.cpp | 14 +-- .../EmulatorCore/Decoding/ADCInstr/R_R.cpp | 12 +-- .../EmulatorCore/Decoding/ADCInstr/R_RM.cpp | 12 +-- .../Decoding/ADCInstr/Unsupported.cpp | 42 ++++---- .../EmulatorCore/Decoding/ADDInstr/R_IMM.cpp | 12 +-- .../EmulatorCore/Decoding/ADDInstr/R_M.cpp | 14 +-- .../EmulatorCore/Decoding/ADDInstr/R_R.cpp | 12 +-- .../EmulatorCore/Decoding/ADDInstr/R_RM.cpp | 12 +-- .../Decoding/ADDInstr/Unsupported.cpp | 44 ++++----- .../EmulatorCore/Decoding/ANDInstr/R_IMM.cpp | 12 +-- .../EmulatorCore/Decoding/ANDInstr/R_M.cpp | 12 +-- .../EmulatorCore/Decoding/ANDInstr/R_R.cpp | 12 +-- .../EmulatorCore/Decoding/ANDInstr/R_RM.cpp | 12 +-- .../Decoding/ANDInstr/Unsupported.cpp | 44 ++++----- .../EmulatorCore/Decoding/ANDNInstr/R_IMM.cpp | 12 +-- .../EmulatorCore/Decoding/ANDNInstr/R_M.cpp | 12 +-- .../EmulatorCore/Decoding/ANDNInstr/R_R.cpp | 12 +-- .../EmulatorCore/Decoding/ANDNInstr/R_RM.cpp | 12 +-- .../Decoding/ANDNInstr/Unsupported.cpp | 44 ++++----- .../EmulatorCore/Decoding/BSWAPInstr/R.cpp | 12 +-- .../Decoding/BSWAPInstr/Unsupported.cpp | 74 +++++++------- .../Decoding/CALLEInstr/test_decoder_imm.cpp | 6 +- .../Decoding/CALLEInstr/test_decoder_r.cpp | 6 +- .../CALLEInstr/test_decoder_unsupported.cpp | 78 +++++++-------- .../Decoding/CALLGRInstr/test_decoder_imm.cpp | 6 +- .../Decoding/CALLGRInstr/test_decoder_r.cpp | 7 +- .../CALLGRInstr/test_decoder_unsupported.cpp | 78 +++++++-------- .../Decoding/CALLInstr/test_decoder_imm.cpp | 7 +- .../Decoding/CALLInstr/test_decoder_r.cpp | 6 +- .../CALLInstr/test_decoder_unsupported.cpp | 78 +++++++-------- .../Decoding/CALLLInstr/test_decoder_imm.cpp | 6 +- .../Decoding/CALLLInstr/test_decoder_r.cpp | 6 +- .../CALLLInstr/test_decoder_unsupported.cpp | 78 +++++++-------- .../Decoding/CCRFInstr/test_decoder_none.cpp | 6 +- .../CCRFInstr/test_decoder_unsupported.cpp | 86 ++++++++-------- .../EmulatorCore/Decoding/CMPInstr/M_R.cpp | 12 +-- .../EmulatorCore/Decoding/CMPInstr/RM_IMM.cpp | 12 +-- .../EmulatorCore/Decoding/CMPInstr/RM_M.cpp | 14 +-- .../EmulatorCore/Decoding/CMPInstr/RM_R.cpp | 14 +-- .../EmulatorCore/Decoding/CMPInstr/R_IMM.cpp | 10 +- .../EmulatorCore/Decoding/CMPInstr/R_M.cpp | 12 +-- .../EmulatorCore/Decoding/CMPInstr/R_R.cpp | 12 +-- .../EmulatorCore/Decoding/CMPInstr/R_RM.cpp | 12 +-- .../Decoding/CMPInstr/Unsupported.cpp | 12 +-- .../Decoding/COVFInstr/test_decoder_none.cpp | 7 +- .../COVFInstr/test_decoder_unsupported.cpp | 84 ++++++++-------- .../EmulatorCore/Decoding/CUDFInstr/None.cpp | 6 +- .../Decoding/CUDFInstr/Unsupported.cpp | 86 ++++++++-------- .../EmulatorCore/Decoding/DECInstr/R.cpp | 12 +-- .../Decoding/DECInstr/Unsupported.cpp | 74 +++++++------- .../EmulatorCore/Decoding/DIVInstr/R.cpp | 10 +- .../Decoding/DIVInstr/Unsupported.cpp | 76 +++++++------- .../Decoding/Features/AddressAddition.cpp | 10 +- .../EmulatorCore/Decoding/HALTInstr/None.cpp | 6 +- .../Decoding/HALTInstr/Unsupported.cpp | 84 ++++++++-------- .../EmulatorCore/Decoding/HIDInstr/None.cpp | 6 +- .../Decoding/HIDInstr/Unsupported.cpp | 84 ++++++++-------- .../EmulatorCore/Decoding/INCInstr/R.cpp | 12 +-- .../Decoding/INCInstr/Unsupported.cpp | 74 +++++++------- .../Decoding/JMEInstr/test_decoder_imm.cpp | 6 +- .../Decoding/JMEInstr/test_decoder_r.cpp | 6 +- .../JMEInstr/test_decoder_unsupported.cpp | 78 +++++++-------- .../Decoding/JMGRInstr/test_decoder_imm.cpp | 6 +- .../Decoding/JMGRInstr/test_decoder_r.cpp | 6 +- .../JMGRInstr/test_decoder_unsupported.cpp | 78 +++++++-------- .../Decoding/JMLInstr/test_decoder_imm.cpp | 6 +- .../Decoding/JMLInstr/test_decoder_r.cpp | 6 +- .../JMLInstr/test_decoder_unsupported.cpp | 78 +++++++-------- .../Decoding/JMPInstr/test_decoder_imm.cpp | 6 +- .../Decoding/JMPInstr/test_decoder_r.cpp | 6 +- .../JMPInstr/test_decoder_unsupported.cpp | 78 +++++++-------- .../EmulatorCore/Decoding/MOVInstr/M_R.cpp | 12 +-- .../EmulatorCore/Decoding/MOVInstr/RM_IMM.cpp | 12 +-- .../EmulatorCore/Decoding/MOVInstr/RM_M.cpp | 12 +-- .../EmulatorCore/Decoding/MOVInstr/RM_R.cpp | 12 +-- .../EmulatorCore/Decoding/MOVInstr/R_IMM.cpp | 10 +- .../EmulatorCore/Decoding/MOVInstr/R_M.cpp | 12 +-- .../EmulatorCore/Decoding/MOVInstr/R_R.cpp | 12 +-- .../EmulatorCore/Decoding/MOVInstr/R_RM.cpp | 12 +-- .../Decoding/MOVInstr/Unsupported.cpp | 12 +-- .../EmulatorCore/Decoding/MULInstr/R_IMM.cpp | 14 +-- .../EmulatorCore/Decoding/MULInstr/R_M.cpp | 12 +-- .../EmulatorCore/Decoding/MULInstr/R_R.cpp | 12 +-- .../EmulatorCore/Decoding/MULInstr/R_RM.cpp | 14 +-- .../Decoding/MULInstr/Unsupported.cpp | 46 ++++----- .../EmulatorCore/Decoding/ORInstr/R_IMM.cpp | 14 +-- .../EmulatorCore/Decoding/ORInstr/R_M.cpp | 12 +-- .../EmulatorCore/Decoding/ORInstr/R_R.cpp | 12 +-- .../EmulatorCore/Decoding/ORInstr/R_RM.cpp | 12 +-- .../Decoding/ORInstr/Unsupported.cpp | 44 ++++----- .../EmulatorCore/Decoding/SHFLInstr/R_IMM.cpp | 12 +-- .../EmulatorCore/Decoding/SHFLInstr/R_R.cpp | 12 +-- .../Decoding/SHFLInstr/Unsupported.cpp | 52 +++++----- .../EmulatorCore/Decoding/SHFRInstr/R_IMM.cpp | 12 +-- .../EmulatorCore/Decoding/SHFRInstr/R_R.cpp | 12 +-- .../Decoding/SHFRInstr/Unsupported.cpp | 54 +++++----- .../EmulatorCore/Decoding/SUBInstr/R_IMM.cpp | 12 +-- .../EmulatorCore/Decoding/SUBInstr/R_M.cpp | 12 +-- .../EmulatorCore/Decoding/SUBInstr/R_R.cpp | 12 +-- .../EmulatorCore/Decoding/SUBInstr/R_RM.cpp | 12 +-- .../Decoding/SUBInstr/Unsupported.cpp | 44 ++++----- .../EmulatorCore/MemoryControllers/ST.cpp | 4 +- tests/main.cpp | 2 +- 204 files changed, 1846 insertions(+), 1911 deletions(-) create mode 100644 src/Common/BUILD.bazel create mode 100644 src/Common/Defs.hpp rename src/{Emulator/Core/CPU/Instructions/AllowedFlags.cpp => Common/LanguageSpec/AllowedFlags.hpp} (95%) create mode 100644 src/Common/LanguageSpec/Flags.hpp create mode 100644 src/Common/LanguageSpec/Opcodes.hpp create mode 100644 src/Common/LanguageSpec/Registers.hpp create mode 100644 src/Common/NotImplemented.hpp delete mode 100644 src/Emulator/Core/CPU/Instructions/AllowedFlags.hpp delete mode 100644 src/Emulator/Core/CPU/Instructions/Flags.hpp delete mode 100644 src/Emulator/Core/CPU/Instructions/Opcodes.hpp delete mode 100644 src/Emulator/Core/CPU/Instructions/Registers.hpp delete mode 100644 src/Exit.hpp delete mode 100644 src/Logger/BUILD.bazel delete mode 100644 src/Logger/Colors.hpp delete mode 100644 src/Logger/Logger.hpp delete mode 100644 src/NotImplemented.hpp rename src/{ => PCH}/BUILD.bazel (77%) rename src/{pch.hpp => PCH/CStd.hpp} (77%) diff --git a/MODULE.bazel b/MODULE.bazel index cc85306e..b9a0a632 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -22,7 +22,8 @@ use_repo( 'fmt', 're2', 'xz_utils', - 'zlib' + 'zlib', + 'plog' ) bazel_dep(name = 'rules_cc', version = '0.0.17') diff --git a/conandata.yml b/conandata.yml index 52479245..559b003a 100644 --- a/conandata.yml +++ b/conandata.yml @@ -14,3 +14,4 @@ requirements: fmt: "11.1.4" libunwind: "1.8.1" boost: "1.87.0" + plog: "1.1.10" diff --git a/dist/HPool b/dist/HPool index 6b165437..352cdd4e 160000 --- a/dist/HPool +++ b/dist/HPool @@ -1 +1 @@ -Subproject commit 6b1654378a084f4e7cc7324670543df86d03b7fa +Subproject commit 352cdd4e5eb2bfb091bd4970386387b6d6f027b1 diff --git a/src/Assembler/BUILD.bazel b/src/Assembler/BUILD.bazel index 6e30674a..2e373e61 100644 --- a/src/Assembler/BUILD.bazel +++ b/src/Assembler/BUILD.bazel @@ -1,29 +1,34 @@ load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') +package( + default_visibility = [ + "//:__subpackages__", + ], +) + + cc_library( name = 'assembler_core', - srcs = glob(['**/*.cpp']), - hdrs = glob(['**/*.hpp']), - includes = [ - '//src', - '//src/Assembler' - ], + srcs = glob(['**/*.cpp'], exclude = ['Main']), + hdrs = glob(['**/*.hpp'], exclude = ['Main']), deps = [ '@fmt//:fmt', '@argparse//:argparse', '@eternal//:eternal', '@re2//:re2', '//src:pch', - '//src/Pog:pog' + '//src/Pog:pog', + '//src:include_proxy' ] ) cc_binary( name = 'hcasm', - srcs = glob(['**/*.cpp']), + srcs = glob(['Main/**/*.cpp']), deps = [ - ':assembler_core' + ':assembler_core', + '//src:include_proxy' ] ) diff --git a/src/Assembler/Core/BinaryTransformer.cpp b/src/Assembler/Core/BinaryTransformer.cpp index 81e9656b..4bfc1b71 100644 --- a/src/Assembler/Core/BinaryTransformer.cpp +++ b/src/Assembler/Core/BinaryTransformer.cpp @@ -1,12 +1,12 @@ #include -#include +#include "pch.hpp" -#include -#include -#include -#include -#include -#include +#include "Emulator/Core/CPU/Instructions/Opcodes.hpp" +#include "Emulator/Core/CPU/Instructions/Flags.hpp" +#include "Assembler/Core/BinaryTransformer.hpp" +#include "Assembler/Core/Compiler.hpp" +#include "Logger/Logger.hpp" +#include "Exit.hpp" HyperCPU::OperandTypes HCAsm::BinaryTransformer::DetermineOperandTypes(Operand& op1, Operand& op2) { @@ -81,7 +81,7 @@ void HCAsm::BinaryTransformer::EncodeInstruction(HCAsm::Instruction& instr) { // Do nothing - bit 0 means first operand } } - + // Handle case when one of operands is a label - we should mock the immediate 64 bit value switch (instr.op1.type) { case HCAsm::OperandType::label: diff --git a/src/Assembler/Core/BinaryTransformer.hpp b/src/Assembler/Core/BinaryTransformer.hpp index 3cbe1c81..f287c225 100644 --- a/src/Assembler/Core/BinaryTransformer.hpp +++ b/src/Assembler/Core/BinaryTransformer.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" #include #include diff --git a/src/Assembler/Core/Compiler.cpp b/src/Assembler/Core/Compiler.cpp index 3df0b693..484fdd92 100644 --- a/src/Assembler/Core/Compiler.cpp +++ b/src/Assembler/Core/Compiler.cpp @@ -1,9 +1,9 @@ #include -#include +#include "pch.hpp" +#include #include #include -#include #include #include #include @@ -138,7 +138,7 @@ HCAsm::HCAsmCompiler::HCAsmCompiler(LogLevel lvl) : pool(32) { } -HCAsm::BinaryResult HCAsm::HCAsmCompiler::Compile(std::string& contents, std::uint32_t& code_size) { +HCAsm::BinaryResult HCAsm::HCAsmCompiler::Compile(std::string& contents, std::uint32_t& code_size) { files.push(std::move(contents)); logger.Log(LogLevel::DEBUG, "Stage 1 compiling - transforming to IR"); @@ -354,7 +354,7 @@ HCAsm::BinaryResult HCAsm::HCAsmCompiler::TransformToBinary(HCAsm::CompilerState for (auto& args : ir.pending_resolves) { auto& instr = ir.ir[args.idx]; - auto* op = args.op ? &std::get(instr).op2 : &std::get(instr).op1; + auto* op = args.op ? &std::get(instr).op2 : &std::get(instr).op1; if (ir.labels.contains(*std::get>(op->variant))) { op->type = OperandType::uint; @@ -377,23 +377,23 @@ HCAsm::BinaryResult HCAsm::HCAsmCompiler::TransformToBinary(HCAsm::CompilerState BinaryTransformer transformer(binary, &ir); for (auto& instr : ir.ir) { - VisitVariant(instr, + VisitVariant(instr, [&transformer](Instruction& instruction) mutable -> void { transformer.EncodeInstruction(instruction); }, [&binary, &ir, this](RawValue& raw) mutable -> void { switch (raw.mode) { case Mode::b8_str: - binary.push(*std::get>(raw.value.variant)); + binary.push(*std::get>(raw.value.variant)); break; - case Mode::b8: - binary.push(static_cast(std::get(raw.value.variant))); + case Mode::b8: + binary.push(static_cast(std::get(raw.value.variant))); break; - case Mode::b16: - binary.push(static_cast(std::get(raw.value.variant))); + case Mode::b16: + binary.push(static_cast(std::get(raw.value.variant))); break; - case Mode::b32: - binary.push(static_cast(std::get(raw.value.variant))); + case Mode::b32: + binary.push(static_cast(std::get(raw.value.variant))); break; case Mode::b64_label: if (!ir.labels.contains(*std::get>(raw.value.variant))) { @@ -401,7 +401,7 @@ HCAsm::BinaryResult HCAsm::HCAsmCompiler::TransformToBinary(HCAsm::CompilerState } binary.push(static_cast(ir.labels.at(*std::get>(raw.value.variant)))); break; - case Mode::b64: + case Mode::b64: binary.push(static_cast(std::get(raw.value.variant))); break; default: ABORT(); @@ -460,3 +460,5 @@ void HCAsm::WriteResultFile(HyperCPU::FileType type, HCAsm::BinaryResult& result output.write(reinterpret_cast(result.binary), code_size); } +de_size); +} diff --git a/src/Assembler/Core/Compiler.hpp b/src/Assembler/Core/Compiler.hpp index 1886a8ee..65f213fb 100644 --- a/src/Assembler/Core/Compiler.hpp +++ b/src/Assembler/Core/Compiler.hpp @@ -1,7 +1,7 @@ #pragma once #include -#include +#include "pch.hpp" #include #include diff --git a/src/Assembler/Core/ModeNameAssoc.hpp b/src/Assembler/Core/ModeNameAssoc.hpp index 6ae6d56d..41b59fca 100644 --- a/src/Assembler/Core/ModeNameAssoc.hpp +++ b/src/Assembler/Core/ModeNameAssoc.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" #include @@ -11,4 +11,4 @@ constexpr inline const auto mode_assoc = mapbox::eternal::hash_map +#include "pch.hpp" #include diff --git a/src/Assembler/Core/Parsers.cpp b/src/Assembler/Core/Parsers.cpp index b2f8f144..9303189c 100644 --- a/src/Assembler/Core/Parsers.cpp +++ b/src/Assembler/Core/Parsers.cpp @@ -1,5 +1,5 @@ #include -#include +#include "pch.hpp" #include #include @@ -27,7 +27,7 @@ Value HCAsm::ParseOperand2(pog::Parser& parser, std::vectorpool.allocate(std::move(args[1])) } } @@ -38,7 +38,7 @@ Value HCAsm::ParseOperand2(pog::Parser& parser, std::vectorlabels.contains(reg), - .tokens = { + .tokens = { parser.get_compiler_state()->pool.allocate(std::move(args[1])) }, .variant = { std::make_shared(reg) } @@ -52,13 +52,13 @@ Value HCAsm::ParseOperand3(pog::Parser& parser, std::vector(args[1].value.val))); } else if (std::get(args[3].value.val) > 255) [[unlikely]] { ThrowError( - args[3], - parser, + args[3], + parser, fmt::format("out of bounds integer provided: {} > 255", std::get(args[3].value.val))); } @@ -81,13 +81,13 @@ Value HCAsm::ParseOperand4(pog::Parser& parser, std::vector(args[1].value.val) != "ptr") { ThrowError( - args[1], - parser, + args[1], + parser, fmt::format("unknown keyword \"{}\" specified, \"ptr\" expected", std::get(args[1].value.val))); } @@ -109,18 +109,18 @@ Value HCAsm::ParseOperand5(pog::Parser& parser, std::vector(args[3].value.val))); } else if (!mode_assoc.contains(Mode.c_str())) [[unlikely]] { ThrowError( - args[0], - parser, + args[0], + parser, fmt::format("unknown data size specified: \"{}\"", Mode)); } else if (std::get(args[1].value.val) != "ptr") [[unlikely]] { ThrowError( - args[1], - parser, + args[1], + parser, fmt::format("unknown keyword \"{}\" specified, \"ptr\" expected", std::get(args[1].value.val))); } @@ -142,23 +142,23 @@ Value HCAsm::ParseOperand6(pog::Parser& parser, std::vector(args[3].value.val))); } else if (!mode_assoc.contains(Mode.c_str())) { ThrowError( - args[0], - parser, + args[0], + parser, fmt::format("unknown data size specified: \"{}\"", Mode)); } else if (std::get(args[1].value.val) != "ptr") { ThrowError( - args[1], - parser, + args[1], + parser, fmt::format("unknown keyword \"{}\" specified, \"ptr\" expected", std::get(args[1].value.val))); } else if (std::get(args[5].value.val) > 255) [[unlikely]] { ThrowError( - args[5], - parser, + args[5], + parser, fmt::format("out of bounds integer provided: {} > 255", std::get(args[5].value.val))); } @@ -236,8 +236,8 @@ Value HCAsm::ParseOperand10(pog::Parser& parser, std::vector& parser, std::vector& parser, std::vector +#include "pch.hpp" #include @@ -48,4 +48,4 @@ constexpr inline const auto registers_assoc = mapbox::eternal::hash_map -#include +#include "pch.hpp" #include #include @@ -101,7 +101,7 @@ Value HCAsm::CompileLabel(pog::Parser& parser, std::vector& parser, std::vector>&& args) { // Label cant be register or instruction name auto& name = std::get(args[1].value.val); - + if (opcode_assoc.contains(name.c_str()) || registers_assoc.contains(name.c_str())) { ThrowError(args[0], parser, "reserved identifier cannot be used as a label"); } @@ -134,7 +134,7 @@ Value HCAsm::CompileRawValueb8_str([[maybe_unused]] pog::Parser& parser, .variant = std::make_shared(std::move(std::get(args[1].value.val))) } }); - + return {}; } diff --git a/src/Assembler/Core/Tokenizers.cpp b/src/Assembler/Core/Tokenizers.cpp index 024f1a18..fd19f74e 100644 --- a/src/Assembler/Core/Tokenizers.cpp +++ b/src/Assembler/Core/Tokenizers.cpp @@ -1,12 +1,12 @@ #include -#include +#include "pch.hpp" #include using HCAsm::Value; [[gnu::visibility("hidden")]] -std::uint64_t BinaryStrToUint64(std::string_view& binary_str) { +std::uint64_t BinaryStrToUint64(std::string_view& binary_str) { binary_str.remove_prefix(2); if (binary_str.length() > 64) { throw std::invalid_argument("Binary string is too long to fit in a uint64_t"); diff --git a/src/Assembler/Main/Main.cpp b/src/Assembler/Main/Main.cpp index 320960b8..91525c45 100644 --- a/src/Assembler/Main/Main.cpp +++ b/src/Assembler/Main/Main.cpp @@ -1,5 +1,5 @@ #include -#include +#include "pch.hpp" #include #include @@ -62,19 +62,19 @@ int main(int argc, char** argv) { result += ".o"; } } - + if (program["-c"] == true) { HyperCPU::PrintUnsupported("Compilation to object files is not implemented!"); } HCAsm::HCAsmCompiler compiler{ loglevel_assoc.at(program.get("-v").c_str()) }; - + // Verify that files are available if (!std::filesystem::is_regular_file(source)) { HCAsm::logger.Log(HyperCPU::LogLevel::ERROR, "Source file \"{}\" is not a regular file!", source); EXIT(1); } - + std::ifstream src(source); std::ofstream dst(result, std::ios::binary | std::ios::ate); if (!src.is_open()) { @@ -90,7 +90,7 @@ int main(int argc, char** argv) { } src.close(); src.open(source); - + std::string contents( (std::istreambuf_iterator(src)), std::istreambuf_iterator() @@ -110,4 +110,3 @@ std::string HCAsm::CreateObjectFilename(std::string str) { } return str; } - diff --git a/src/Assembler/Utils/Extension.hpp b/src/Assembler/Utils/Extension.hpp index 89885b5c..76c295bb 100644 --- a/src/Assembler/Utils/Extension.hpp +++ b/src/Assembler/Utils/Extension.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" namespace HCAsm { std::string CreateObjectFilename(std::string str); diff --git a/src/BacktraceProvider/BUILD.bazel b/src/BacktraceProvider/BUILD.bazel index 65bc4930..9f197f01 100644 --- a/src/BacktraceProvider/BUILD.bazel +++ b/src/BacktraceProvider/BUILD.bazel @@ -9,16 +9,14 @@ cc_library( hdrs = [ 'BacktraceProvider.hpp' ], - includes = [ - '//src' - ], deps = [ '@fmt//:fmt', '@argparse//:argparse', '@eternal//:eternal', - '//src:pch', '//src/Pog:pog', + '//src:pch', '@libbacktrace//:libbacktrace', - '@libunwind//:libunwind' + '@libunwind//:libunwind', + '//src:include_proxy' ] ) diff --git a/src/BacktraceProvider/BacktraceProvider.cpp b/src/BacktraceProvider/BacktraceProvider.cpp index da889253..6c1e545a 100644 --- a/src/BacktraceProvider/BacktraceProvider.cpp +++ b/src/BacktraceProvider/BacktraceProvider.cpp @@ -1,7 +1,7 @@ #ifdef HCPU_ENABLE_LIBUNWIND #define UNW_LOCAL_ONLY -#include +#include "pch.hpp" #include #include @@ -65,14 +65,14 @@ extern "C" { if (unw_get_reg(&global_bt_controller.cursor, UNW_REG_SP, &sp)) { fmt::println("{}[!] Unwinding stack failed: couldn't get SP!{}", B_RED, RESET); - std::exit(1); + std::exit(1); } fmt::println("{}frame #{} (PC: {:#x}, SP: {:#x}){}", B_YELLOW, global_bt_controller.iteration, pc, sp, RESET); fmt::println("{}{}:{}, function: {}{}", B_YELLOW, filename, lineno, func_name, RESET); unw_step(&global_bt_controller.cursor); - + ++global_bt_controller.iteration; return 0; } diff --git a/src/BacktraceProvider/BacktraceProvider.hpp b/src/BacktraceProvider/BacktraceProvider.hpp index d9a7f371..eff12a7b 100644 --- a/src/BacktraceProvider/BacktraceProvider.hpp +++ b/src/BacktraceProvider/BacktraceProvider.hpp @@ -1,5 +1,5 @@ #ifdef HCPU_ENABLE_LIBUNWIND -#include +#include "pch.hpp" #include #include diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 3fb1253e..b3c64431 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -4,9 +4,9 @@ add_library( pch INTERFACE - pch.hpp + "pch.hpp" ) -target_precompile_headers(pch INTERFACE pch.hpp) +target_precompile_headers(pch INTERFACE "pch.hpp") add_library( pog diff --git a/src/Common/BUILD.bazel b/src/Common/BUILD.bazel new file mode 100644 index 00000000..b17b6584 --- /dev/null +++ b/src/Common/BUILD.bazel @@ -0,0 +1,11 @@ +load('@rules_cc//cc:defs.bzl', 'cc_library') + + +cc_library( + name = 'hcpu_common', + srcs = glob(['**/*.cpp'], allow_empty = True), + hdrs = glob(['**/*.hpp']), + deps = [ + '@plog//:plog' + ] +) diff --git a/src/Common/Defs.hpp b/src/Common/Defs.hpp new file mode 100644 index 00000000..a01c8992 --- /dev/null +++ b/src/Common/Defs.hpp @@ -0,0 +1,8 @@ +#pragma once + + +#if defined(__GNUC__) || defined(__clang__) + #define HCPU_ALWAYS_INLINE inline __attribute__((always_inline)) +#else + #define HCPU_ALWAYS_INLINE inline +#endif diff --git a/src/Emulator/Core/CPU/Instructions/AllowedFlags.cpp b/src/Common/LanguageSpec/AllowedFlags.hpp similarity index 95% rename from src/Emulator/Core/CPU/Instructions/AllowedFlags.cpp rename to src/Common/LanguageSpec/AllowedFlags.hpp index d7b9050d..c4d69795 100644 --- a/src/Emulator/Core/CPU/Instructions/AllowedFlags.cpp +++ b/src/Common/LanguageSpec/AllowedFlags.hpp @@ -1,10 +1,11 @@ -#include +#pragma once -#include +#include "src/PCH/CStd.hpp" namespace HyperCPU { - const std::uint8_t allowed_op_modes[128][12] = { + inline static constexpr std::uint8_t SUPPORT_ALL = 0b00011011; + inline static const std::uint8_t AllowedOpModes[128][12] = { {}, // NULL {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ADC {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ADD diff --git a/src/Common/LanguageSpec/Flags.hpp b/src/Common/LanguageSpec/Flags.hpp new file mode 100644 index 00000000..1483f471 --- /dev/null +++ b/src/Common/LanguageSpec/Flags.hpp @@ -0,0 +1,15 @@ +#pragma once + +#include "src/PCH/CStd.hpp" + + +namespace HyperCPU { + enum class Mode { + b8 = 0, b16, b32, b64 + }; + + enum class OperandTypes { + R_R = 0, R_RM, R_M, R_IMM, RM_R, RM_M, RM_IMM, + M_R, R, M, IMM, NONE + }; +} diff --git a/src/Common/LanguageSpec/Opcodes.hpp b/src/Common/LanguageSpec/Opcodes.hpp new file mode 100644 index 00000000..8a02fd82 --- /dev/null +++ b/src/Common/LanguageSpec/Opcodes.hpp @@ -0,0 +1,90 @@ +#pragma once + +#include "src/PCH/CStd.hpp" + + +namespace HyperCPU { + enum class Opcode : std::uint16_t { + ADC = 0x0001, + ADD = 0x0002, + AND = 0x0003, + ANDN = 0x0004, + BSWAP = 0x0005, + CALL = 0x0006, + CCRF = 0x0007, + COVF = 0x0008, + CUDF = 0x0009, + HID = 0x000A, + INC = 0x000B, + DEC = 0x000C, + DIV = 0x000D, + MUL = 0x000E, + SUB = 0x000F, + SHFR = 0x0010, + SHFL = 0x0011, + OR = 0x0012, + HALT = 0x0013, + LOIVT = 0x0014, + INTR = 0x0015, + RET = 0x0016, + IRET = 0x0017, + READ = 0x0018, + WRITE = 0x0019, + JMP = 0x001A, + PUSH = 0x001B, + POP = 0x001C, + CALLE = 0x001D, + CALLGR= 0x001E, + CALLL = 0x001F, + JME = 0x0020, + JMGR = 0x0021, + JML = 0x0022, + CMP = 0x0023, + MOV = 0x007F, + _CONT = 0x6934 + }; + + namespace Validator { + static constexpr inline bool IsValidOpcode(std::uint16_t op) { + Opcode code = static_cast(op); + switch (code) { + case Opcode::ADC: + case Opcode::ADD: + case Opcode::AND: + case Opcode::ANDN: + case Opcode::BSWAP: + case Opcode::CALL: + case Opcode::CCRF: + case Opcode::COVF: + case Opcode::CUDF: + case Opcode::HID: + case Opcode::INC: + case Opcode::DEC: + case Opcode::DIV: + case Opcode::MUL: + case Opcode::SUB: + case Opcode::SHFR: + case Opcode::SHFL: + case Opcode::OR: + case Opcode::LOIVT: + case Opcode::INTR: + case Opcode::READ: + case Opcode::WRITE: + case Opcode::JMP: + case Opcode::IRET: + case Opcode::PUSH: + case Opcode::POP: + case Opcode::CALLE: + case Opcode::CALLGR: + case Opcode::CALLL: + case Opcode::JME: + case Opcode::JMGR: + case Opcode::JML: + case Opcode::CMP: + return true; + default: + return false; + } + } + } +} diff --git a/src/Common/LanguageSpec/Registers.hpp b/src/Common/LanguageSpec/Registers.hpp new file mode 100644 index 00000000..37287a0a --- /dev/null +++ b/src/Common/LanguageSpec/Registers.hpp @@ -0,0 +1,70 @@ +#pragma once + +#include "src/PCH/CStd.hpp" + + +namespace HyperCPU { + + enum class Reg : std::uint8_t { + X0 = 0, X1, X2, X3, X4, X5, X6, X7, + XH0, XH1, XH2, XH3, XH4, XH5, XH6, XH7, + XL0, XL1, XL2, XL3, XL4, XL5, XL6, XL7, + XLL0, XLL1, XLL2, XLL3, + XLLH0, XLLH1, XLLH2, XLLH3, + XLLL0, XLLL1, XLLL2, XLLL3, + XBP, XSP, XIP, + XGDP, XIVT + }; + + namespace Validator { + static constexpr inline bool IsValidRegister(std::uint8_t reg) { + Reg r = static_cast(reg); + switch (r) { + case Reg::X0: + case Reg::X1: + case Reg::X2: + case Reg::X3: + case Reg::X4: + case Reg::X5: + case Reg::X6: + case Reg::X7: + case Reg::XH0: + case Reg::XH1: + case Reg::XH2: + case Reg::XH3: + case Reg::XH4: + case Reg::XH5: + case Reg::XH6: + case Reg::XH7: + case Reg::XL0: + case Reg::XL1: + case Reg::XL2: + case Reg::XL3: + case Reg::XL4: + case Reg::XL5: + case Reg::XL6: + case Reg::XL7: + case Reg::XLL0: + case Reg::XLL1: + case Reg::XLL2: + case Reg::XLL3: + case Reg::XLLH0: + case Reg::XLLH1: + case Reg::XLLH2: + case Reg::XLLH3: + case Reg::XLLL0: + case Reg::XLLL1: + case Reg::XLLL2: + case Reg::XLLL3: + case Reg::XBP: + case Reg::XSP: + case Reg::XIP: + case Reg::XGDP: + case Reg::XIVT: + return true; + default: + return false; + } + } + } +} diff --git a/src/Common/NotImplemented.hpp b/src/Common/NotImplemented.hpp new file mode 100644 index 00000000..240ce44b --- /dev/null +++ b/src/Common/NotImplemented.hpp @@ -0,0 +1,12 @@ +#pragma once + +#include + +#include "src/PCH/CStd.hpp" +#include "src/Common/Defs.hpp" + +namespace HyperCPU { + HCPU_ALWAYS_INLINE static void PrintUnsupported(std::string_view msg) { + // ... + } +} diff --git a/src/Emulator/BUILD.bazel b/src/Emulator/BUILD.bazel index de086bc2..9eb742d1 100644 --- a/src/Emulator/BUILD.bazel +++ b/src/Emulator/BUILD.bazel @@ -1,28 +1,35 @@ -load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') +# load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') -cc_library( - name = 'emulator_core', - srcs = glob(['**/*.cpp']), - hdrs = glob(['**/*.hpp']), - includes = [ - '//src', - '//src/Emulator' - ], - deps = [ - '@fmt//:fmt', - '@argparse//:argparse', - '@eternal//:eternal', - '//src:pch', - '//src/Pog:pog' - ] -) +# cc_library( +# name = 'emulator_core', +# srcs = glob(['**/*.cpp']), +# hdrs = glob(['**/*.hpp']), +# copts = [ +# '-Isrc/', +# '-Isrc/Assembler/', +# '-Isrc/Emulator/' +# ], +# deps = [ +# '@fmt//:fmt', +# '@argparse//:argparse', +# '@eternal//:eternal', +# '//src/Assembler:assembler_core', +# '//src:pch', +# '//src/Pog:pog', +# '//src/Logger:logger', +# '//src:include_proxy' +# ] +# ) -cc_binary( - name = 'hcemul', - srcs = glob(['**/*.cpp']), - deps = [ - ':emulator_core' - ] -) +# cc_binary( +# name = 'hcemul', +# srcs = glob(['**/*.cpp']), +# deps = [ +# ':emulator_core', +# '//src:pch', +# '//src/Pog:pog', +# '//src:include_proxy' +# ] +# ) diff --git a/src/Emulator/Core/CPU/ALU.hpp b/src/Emulator/Core/CPU/ALU.hpp index 43a10c90..f21dcc81 100644 --- a/src/Emulator/Core/CPU/ALU.hpp +++ b/src/Emulator/Core/CPU/ALU.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" #define _MICROOP [[gnu::always_inline]] static constexpr inline diff --git a/src/Emulator/Core/CPU/Assert.hpp b/src/Emulator/Core/CPU/Assert.hpp index b023891a..a06f42c6 100644 --- a/src/Emulator/Core/CPU/Assert.hpp +++ b/src/Emulator/Core/CPU/Assert.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" #define h_assert(expr, statement) if (!(expr)) { statement; } diff --git a/src/Emulator/Core/CPU/CPU.cpp b/src/Emulator/Core/CPU/CPU.cpp index db773b45..921c7504 100644 --- a/src/Emulator/Core/CPU/CPU.cpp +++ b/src/Emulator/Core/CPU/CPU.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -69,82 +69,82 @@ HyperCPU::CPU::CPU(std::uint16_t core_count, std::uint64_t mem_size, char* binar ovf = false; udf = false; zrf = false; - + // TODO: Use std::bind instead of lambdas opcode_handler_assoc[static_cast(HyperCPU::Opcode::HALT)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecHALT(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::ADD)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::ADD)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecADD(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::ADC)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::ADC)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecADC(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::AND)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::AND)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecAND(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::ANDN)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::ANDN)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecANDN(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::BSWAP)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::BSWAP)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecBSWAP(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALL)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALL)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCALL(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::CCRF)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::CCRF)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCCRF(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::COVF)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::COVF)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCOVF(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::CUDF)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::CUDF)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCUDF(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::INC)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::INC)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecINC(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::DEC)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::DEC)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecDEC(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::HID)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::HID)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecHID(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::MUL)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::MUL)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecMUL(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::OR)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::OR)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecOR(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::SUB)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::SUB)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecSUB(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::SHFL)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::SHFL)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecSHFL(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::SHFR)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::SHFR)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecSHFR(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::DIV)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::DIV)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecDIV(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::LOIVT)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::LOIVT)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecLOIVT(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::INTR)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::INTR)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecINTR(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::MOV)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::MOV)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecMOV(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::READ)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::READ)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecREAD(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::WRITE)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::WRITE)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecWRITE(instr, op1, op2); }; opcode_handler_assoc[static_cast(HyperCPU::Opcode::JMP)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecJMP(instr, op1, op2); }; opcode_handler_assoc[static_cast(HyperCPU::Opcode::PUSH)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecPUSH(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::POP)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::POP)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecPOP(instr, op1, op2); }; opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALLE)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCALLE(instr, op1, op2); }; opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALLGR)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCALLGR(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALLL)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALLL)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCALLL(instr, op1, op2); }; opcode_handler_assoc[static_cast(HyperCPU::Opcode::JME)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecJME(instr, op1, op2); }; opcode_handler_assoc[static_cast(HyperCPU::Opcode::JMGR)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecJMGR(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::JML)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::JML)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecJML(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::CMP)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::CMP)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCMP(instr, op1, op2); }; read_io_handlers[0] = io_ctl->GetGetchar(); write_io_handlers[0] = io_ctl->GetPutchar(); - + m_decoder = std::make_unique(mem_controller, xip, this); if (binary) { std::memcpy(mem_controller->get_ptr(), binary, binary_size); @@ -162,7 +162,7 @@ void HyperCPU::CPU::DecodingThread() { while (!halted) { if (skip_decoding_cycle) { skip_decoding_cycle = false; - + // Wait for executor thread to execute instruction current = buffer_used.load(std::memory_order_acquire); while (current) { @@ -196,7 +196,7 @@ void HyperCPU::CPU::DecodingThread() { default: break; } - + if (interrupt_active.load(std::memory_order_acquire)) { skip_decoding_cycle = false; continue; @@ -212,7 +212,7 @@ void HyperCPU::CPU::DecodingThread() { buffer_used.store(true, std::memory_order_release); buffer_used.notify_one(); - } + } } void HyperCPU::CPU::ExecutingThread() { @@ -257,7 +257,7 @@ void HyperCPU::CPU::Run() { buffer = m_decoder->FetchAndDecode(); - switch (buffer.m_opcode) { + switch (buffer.m_opcode) { case _CONT: continue; case IRET: @@ -269,7 +269,7 @@ void HyperCPU::CPU::Run() { std::pair operands = GetOperands(buffer.m_op_types, buffer.m_opcode_mode, buffer.m_op1, buffer.m_op2); opcode_handler_assoc[static_cast(buffer.m_opcode)](buffer, operands.first, operands.second); - } + } } bool HyperCPU::CPU::CanExecuteInterrupts() { diff --git a/src/Emulator/Core/CPU/CPU.hpp b/src/Emulator/Core/CPU/CPU.hpp index b39538e0..c524cbed 100644 --- a/src/Emulator/Core/CPU/CPU.hpp +++ b/src/Emulator/Core/CPU/CPU.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" #include #include @@ -18,7 +18,7 @@ namespace HyperCPU { class CPU { private: friend class Decoder; - friend class MemoryControllerST; + friend class MemoryControllerST; using opcode_handler = std::function; using read_operation_handler = std::function; @@ -78,7 +78,7 @@ namespace HyperCPU { std::optional pending_interrupt; void DecodingThread(); void ExecutingThread(); - + // All instructions DECLARE_INSTR(ADD); DECLARE_INSTR(ADC); @@ -119,7 +119,7 @@ namespace HyperCPU { std::array read_io_handlers; std::array write_io_handlers; std::unique_ptr io_ctl; - + public: CPU(std::uint16_t core_count, std::uint64_t mem_size, char* binary = nullptr, std::uint64_t binary_size = 0); @@ -128,7 +128,7 @@ namespace HyperCPU { bool CanExecuteInterrupts(); void SetEntryPoint(std::uint32_t entry_point); const HyperCPU::Logger& GetLogger() const noexcept; - + ~CPU(); }; } diff --git a/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp b/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp index 85ffe863..d246cbf2 100644 --- a/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp +++ b/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -155,7 +155,7 @@ HyperCPU::IInstruction HyperCPU::Decoder::FetchAndDecode() { case M: instruction.m_op1 = OperandContainer{mem_controller->Fetch64(*xip)}; break; - + case IMM: switch (instruction.m_opcode_mode) { case b8: { diff --git a/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp b/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp index 8d8c8deb..ae278e88 100644 --- a/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp +++ b/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" #include #include @@ -24,7 +24,7 @@ namespace HyperCPU { explicit OperandContainer(std::uint64_t value) : value(value) { } template explicit OperandContainer(T* ptr) : value(HyperCPU::bit_cast(ptr)) { } // Supposed to be executed from GetRegister() - + operator std::uint8_t() const noexcept { return HyperCPU::bit_cast(value); } operator std::uint16_t() const noexcept { return HyperCPU::bit_cast(value); } operator std::uint32_t() const noexcept { return HyperCPU::bit_cast(value); } @@ -33,7 +33,7 @@ namespace HyperCPU { std::uint64_t& ref() noexcept { return value; } - + template operator T*() const noexcept { return HyperCPU::bit_cast(value); @@ -77,7 +77,7 @@ namespace HyperCPU { public: explicit Decoder() = default; // For testing purposes - causes UB if used incorrectly - explicit Decoder(IMemoryController* mc, std::uint64_t* counter, class CPU* cpu) + explicit Decoder(IMemoryController* mc, std::uint64_t* counter, class CPU* cpu) : mem_controller(mc) , xip(counter) , cpu(cpu) @@ -88,4 +88,7 @@ namespace HyperCPU { ~Decoder() = default; }; -} \ No newline at end of file +} +; + }; +} diff --git a/src/Emulator/Core/CPU/IO/Simple.cpp b/src/Emulator/Core/CPU/IO/Simple.cpp index 44b9f918..061aee05 100644 --- a/src/Emulator/Core/CPU/IO/Simple.cpp +++ b/src/Emulator/Core/CPU/IO/Simple.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -71,6 +71,6 @@ void HyperCPU::SimpleIOImpl::DisablePrinting() { void HyperCPU::SimpleIOImpl::EnablePrinting() { newt.c_lflag |= ECHO; - newt.c_lflag |= ECHONL; + newt.c_lflag |= ECHONL; tcsetattr(STDIN_FILENO, TCSANOW, &newt); } diff --git a/src/Emulator/Core/CPU/IO/Simple.hpp b/src/Emulator/Core/CPU/IO/Simple.hpp index 78cc4e57..483ba678 100644 --- a/src/Emulator/Core/CPU/IO/Simple.hpp +++ b/src/Emulator/Core/CPU/IO/Simple.hpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -6,7 +6,7 @@ namespace HyperCPU { class SimpleIOImpl { public: SimpleIOImpl(); - + std::function GetPutchar(); std::function GetGetchar(); @@ -21,7 +21,7 @@ namespace HyperCPU { EnablePrinting = 0x10, DisablePrinting = 0x11, }; - + void Putchar(std::uint8_t); std::uint8_t Getchar(); diff --git a/src/Emulator/Core/CPU/Instructions/AllowedFlags.hpp b/src/Emulator/Core/CPU/Instructions/AllowedFlags.hpp deleted file mode 100644 index 91bf3e93..00000000 --- a/src/Emulator/Core/CPU/Instructions/AllowedFlags.hpp +++ /dev/null @@ -1,10 +0,0 @@ -#pragma once - -#include - - -namespace HyperCPU { - static constexpr std::uint8_t SUPPORT_ALL = 0b00011011; - - extern const std::uint8_t allowed_op_modes[128][12]; -} diff --git a/src/Emulator/Core/CPU/Instructions/Flags.hpp b/src/Emulator/Core/CPU/Instructions/Flags.hpp deleted file mode 100644 index e9527d48..00000000 --- a/src/Emulator/Core/CPU/Instructions/Flags.hpp +++ /dev/null @@ -1,30 +0,0 @@ -#pragma once - -#include - - -namespace HyperCPU { - enum Mode : std::uint_fast8_t { - b8 = 0b00, - b16 = 0b01, - b32 = 0b10, - b64 = 0b11 - }; - - enum OperandTypes : std::uint_fast8_t { - R_R = 0b0000, - R_RM = 0b0001, - R_M = 0b0010, - R_IMM = 0b0011, - RM_R = 0b0100, - RM_M = 0b0101, - RM_IMM = 0b0110, - M_R = 0b0111, - R = 0b1000, - M = 0b1001, - IMM = 0b1010, - NONE = 0b1011 - }; - - static constexpr std::uint_fast8_t MAX_OPERAND_TYPE = NONE; -} diff --git a/src/Emulator/Core/CPU/Instructions/Opcodes.hpp b/src/Emulator/Core/CPU/Instructions/Opcodes.hpp deleted file mode 100644 index 935defbc..00000000 --- a/src/Emulator/Core/CPU/Instructions/Opcodes.hpp +++ /dev/null @@ -1,98 +0,0 @@ -#pragma once - -#include - - -#define OPCODE_CASE(opcode) case static_cast(opcode): -#define OPCODE_DEFAULT_CASE() default: return false; - -namespace HyperCPU { - - enum Opcode : std::uint16_t { - ADC = 0x0001, - ADD = 0x0002, - AND = 0x0003, - ANDN = 0x0004, - BSWAP = 0x0005, - CALL = 0x0006, - CCRF = 0x0007, - COVF = 0x0008, - CUDF = 0x0009, - HID = 0x000A, - INC = 0x000B, - DEC = 0x000C, - DIV = 0x000D, - MUL = 0x000E, - SUB = 0x000F, - SHFR = 0x0010, - SHFL = 0x0011, - OR = 0x0012, - HALT = 0x0013, - LOIVT = 0x0014, - INTR = 0x0015, - RET = 0x0016, - IRET = 0x0017, - READ = 0x0018, - WRITE = 0x0019, - JMP = 0x001A, - PUSH = 0x001B, - POP = 0x001C, - CALLE = 0x001D, - CALLGR= 0x001E, - CALLL = 0x001F, - JME = 0x0020, - JMGR = 0x0021, - JML = 0x0022, - CMP = 0x0023, - MOV = 0x007F, - _CONT = 0x6934 - }; - - namespace Validator { - static constexpr inline bool IsValidOpcode(std::uint16_t op) { - switch (op) { - OPCODE_CASE(ADC) - OPCODE_CASE(ADD) - OPCODE_CASE(AND) - OPCODE_CASE(ANDN) - OPCODE_CASE(BSWAP) - OPCODE_CASE(CALL) - OPCODE_CASE(CCRF) - OPCODE_CASE(COVF) - OPCODE_CASE(CUDF) - OPCODE_CASE(HID) - OPCODE_CASE(INC) - OPCODE_CASE(DEC) - OPCODE_CASE(DIV) - OPCODE_CASE(MUL) - OPCODE_CASE(SUB) - OPCODE_CASE(SHFR) - OPCODE_CASE(SHFL) - OPCODE_CASE(OR) - OPCODE_CASE(HALT) - OPCODE_CASE(MOV) - OPCODE_CASE(LOIVT) - OPCODE_CASE(INTR) - OPCODE_CASE(READ) - OPCODE_CASE(WRITE) - OPCODE_CASE(JMP) - OPCODE_CASE(IRET) - OPCODE_CASE(PUSH) - OPCODE_CASE(POP) - OPCODE_CASE(CALLE) - OPCODE_CASE(CALLGR) - OPCODE_CASE(CALLL) - OPCODE_CASE(JME) - OPCODE_CASE(JMGR) - OPCODE_CASE(JML) - OPCODE_CASE(CMP) - return true; - OPCODE_DEFAULT_CASE() - } - } - } - -} - -#undef OPCODE_CASE -#undef OPCODE_DEFAULT_CASE diff --git a/src/Emulator/Core/CPU/Instructions/Registers.hpp b/src/Emulator/Core/CPU/Instructions/Registers.hpp deleted file mode 100644 index 99c021aa..00000000 --- a/src/Emulator/Core/CPU/Instructions/Registers.hpp +++ /dev/null @@ -1,71 +0,0 @@ -#pragma once - -#include - - -#define REGISTER_CASE(reg) case static_cast(reg): -#define REGISTER_DEFAULT_CASE() default: return false; - -namespace HyperCPU { - - enum Registers : std::uint_fast8_t { - X0 = 0, X1, X2, X3, X4, X5, X6, X7, - XH0, XH1, XH2, XH3, XH4, XH5, XH6, XH7, - XL0, XL1, XL2, XL3, XL4, XL5, XL6, XL7, - XLL0, XLL1, XLL2, XLL3, - XLLH0, XLLH1, XLLH2, XLLH3, - XLLL0, XLLL1, XLLL2, XLLL3, - XBP, XSP, XIP, - XGDP, XIVT - }; - - namespace Validator { - static constexpr inline bool IsValidRegister(std::uint8_t reg) { - switch (reg) { - REGISTER_CASE(X0) - REGISTER_CASE(X1) - REGISTER_CASE(X2) - REGISTER_CASE(X3) - REGISTER_CASE(X4) - REGISTER_CASE(X5) - REGISTER_CASE(X6) - REGISTER_CASE(X7) - REGISTER_CASE(XH0) - REGISTER_CASE(XH1) - REGISTER_CASE(XH2) - REGISTER_CASE(XH3) - REGISTER_CASE(XH4) - REGISTER_CASE(XH5) - REGISTER_CASE(XH6) - REGISTER_CASE(XH7) - REGISTER_CASE(XL0) - REGISTER_CASE(XL1) - REGISTER_CASE(XL2) - REGISTER_CASE(XL3) - REGISTER_CASE(XL4) - REGISTER_CASE(XL5) - REGISTER_CASE(XL6) - REGISTER_CASE(XL7) - REGISTER_CASE(XLL0) - REGISTER_CASE(XLL1) - REGISTER_CASE(XLL2) - REGISTER_CASE(XLL3) - REGISTER_CASE(XLLH0) - REGISTER_CASE(XLLH1) - REGISTER_CASE(XLLH2) - REGISTER_CASE(XLLH3) - REGISTER_CASE(XLLL0) - REGISTER_CASE(XLLL1) - REGISTER_CASE(XLLL2) - REGISTER_CASE(XLLL3) - REGISTER_CASE(XBP) - REGISTER_CASE(XSP) - REGISTER_CASE(XIP) - REGISTER_CASE(XGDP) - REGISTER_CASE(XIVT) - return true; - REGISTER_DEFAULT_CASE() - } - } - } -} diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp index 3ff6a94f..3dc41f43 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -127,7 +127,7 @@ void HyperCPU::CPU::ExecADC(const IInstruction& instr, OperandContainer op1, Ope if (crf) ++op1.deref(); break; } - + case b16: { std::uint16_t val = HyperCPU::bit_cast(op2); ovf = AdditionWillOverflow(op1.deref(), val); @@ -135,7 +135,7 @@ void HyperCPU::CPU::ExecADC(const IInstruction& instr, OperandContainer op1, Ope if (crf) ++op1.deref(); break; } - + case b32: { std::uint32_t val = HyperCPU::bit_cast(op2); ovf = AdditionWillOverflow(op1.deref(), val); @@ -143,7 +143,7 @@ void HyperCPU::CPU::ExecADC(const IInstruction& instr, OperandContainer op1, Ope if (crf) ++op1.deref(); break; } - + case b64: { std::uint64_t val = HyperCPU::bit_cast(op2); ovf = AdditionWillOverflow(op1.deref(), val); diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp index df52d676..645277c3 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -112,21 +112,21 @@ void HyperCPU::CPU::ExecADD(const IInstruction& instr, OperandContainer op1, Ope op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); break; } - + case b16: { std::uint16_t val = HyperCPU::bit_cast(op2); ovf = AdditionWillOverflow(op1.deref(), val); op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); break; } - + case b32: { std::uint32_t val = HyperCPU::bit_cast(op2); ovf = AdditionWillOverflow(op1.deref(), val); op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); break; } - + case b64: { std::uint64_t val = HyperCPU::bit_cast(op2); ovf = AdditionWillOverflow(op1.deref(), val); @@ -136,7 +136,7 @@ void HyperCPU::CPU::ExecADD(const IInstruction& instr, OperandContainer op1, Ope } break; } - + default: break; } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp b/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp index 2ed7d08b..bdcd75fe 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -100,19 +100,19 @@ void HyperCPU::CPU::ExecAND(const IInstruction& instr, OperandContainer op1, Ope op1.deref() = __hcpu_and(op1.deref(), val); break; } - + case b16: { std::uint16_t val = HyperCPU::bit_cast(op2); op1.deref() = __hcpu_and(op1.deref(), val); break; } - + case b32: { std::uint32_t val = HyperCPU::bit_cast(op2); op1.deref() = __hcpu_and(op1.deref(), val); break; } - + case b64: { std::uint64_t val = HyperCPU::bit_cast(op2); op1.deref() = __hcpu_and(op1.deref(), val); diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp index a04dea5f..19b42d52 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -17,7 +17,7 @@ void HyperCPU::CPU::ExecANDN(const IInstruction& instr, OperandContainer op1, Op dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); break; } - + case b16: { auto& dst = op1.deref(); dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); @@ -117,21 +117,21 @@ void HyperCPU::CPU::ExecANDN(const IInstruction& instr, OperandContainer op1, Op dst = __hcpu_and(__hcpu_not(dst), val); break; } - + case b16: { std::uint16_t val = HyperCPU::bit_cast(op2); auto& dst = op1.deref(); dst = __hcpu_and(__hcpu_not(dst), val); break; } - + case b32: { std::uint32_t val = HyperCPU::bit_cast(op2); auto& dst = op1.deref(); dst = __hcpu_and(__hcpu_not(dst), val); break; } - + case b64: { std::uint64_t val = HyperCPU::bit_cast(op2); auto& dst = op1.deref(); diff --git a/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp index c8931954..b90d09f7 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp index 7751e572..4e9f304b 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp index c70a1dc7..1523d6fc 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -15,7 +15,7 @@ void HyperCPU::CPU::ExecCALLE(const IInstruction& instr, OperandContainer op1, O if (!(zrf && !crf)) { return; } - + switch (instr.m_op_types) { // Placeholders case R: StackPush64(*xip); diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp index 08e0aeac..57cc42aa 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -15,7 +15,7 @@ void HyperCPU::CPU::ExecCALLGR(const IInstruction& instr, OperandContainer op1, if (!(!zrf && !crf)) { return; } - + switch (instr.m_op_types) { // Placeholders case R: StackPush64(*xip); diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp index 49414d2e..dfbec7ec 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -15,7 +15,7 @@ void HyperCPU::CPU::ExecCALLL(const IInstruction& instr, OperandContainer op1, O if (!(!zrf && crf)) { return; } - + switch (instr.m_op_types) { // Placeholders case R: StackPush64(*xip); diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp index 7415e6f9..bb8addc4 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp index dccafe94..12bf334d 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -65,11 +65,11 @@ void HyperCPU::CPU::ExecCMP(const IInstruction& instr, OperandContainer op1, Ope case b16: res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); break; - + case b32: res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); break; - + case b64: res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); break; @@ -82,15 +82,15 @@ void HyperCPU::CPU::ExecCMP(const IInstruction& instr, OperandContainer op1, Ope case b8: res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); break; - + case b16: res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); break; - + case b32: res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); break; - + case b64: res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); break; @@ -107,7 +107,7 @@ void HyperCPU::CPU::ExecCMP(const IInstruction& instr, OperandContainer op1, Ope case b8: res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr1), mem_controller->Read8(ptr2)); break; - + case b16: res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr1), mem_controller->Read16(ptr2)); break; @@ -115,7 +115,7 @@ void HyperCPU::CPU::ExecCMP(const IInstruction& instr, OperandContainer op1, Ope case b32: res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr1), mem_controller->Read32(ptr2)); break; - + case b64: res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr1), mem_controller->Read64(ptr2)); break; @@ -131,7 +131,7 @@ void HyperCPU::CPU::ExecCMP(const IInstruction& instr, OperandContainer op1, Ope res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; - case b16: + case b16: res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; @@ -153,15 +153,15 @@ void HyperCPU::CPU::ExecCMP(const IInstruction& instr, OperandContainer op1, Ope case b8: res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast(op2)); break; - + case b16: res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast(op2)); break; - + case b32: res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast(op2)); break; - + case b64: res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast(op2)); break; @@ -174,18 +174,18 @@ void HyperCPU::CPU::ExecCMP(const IInstruction& instr, OperandContainer op1, Ope switch (instr.m_opcode_mode) { case b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; case b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; case b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; - case b64: + case b64: res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; } @@ -210,4 +210,12 @@ void HyperCPU::CPU::ExecCMP(const IInstruction& instr, OperandContainer op1, Ope crf = 0; break; } +} + crf = 0; + break; + case 1: + zrf = 0; + crf = 0; + break; + } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp b/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp index 41e6787f..606f8a64 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp index 2f4b1cc5..589f0f51 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp b/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp index 4561af36..525a87ef 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp b/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp index 4b76b4ab..35135a75 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -23,7 +23,7 @@ void HyperCPU::CPU::ExecDIV(const IInstruction& instr, OperandContainer op1, Ope dst = __hcpu_div(dst, static_cast(*x2)); break; } - + case b16: { auto& dst = op1.deref(); *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); diff --git a/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp b/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp index beb5ae16..b73f1753 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp b/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp index 4fd64f49..82648b1e 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp b/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp index 1c5c7298..fb8905f2 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp index 71cb764e..4c09b21f 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp index fec958f7..85a066f2 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -15,7 +15,7 @@ void HyperCPU::CPU::ExecJME(const IInstruction& instr, OperandContainer op1, Ope if (!(zrf && !crf)) { return; } - + switch (instr.m_op_types) { // Placeholders case R: *xip = op1.deref(); @@ -30,3 +30,4 @@ void HyperCPU::CPU::ExecJME(const IInstruction& instr, OperandContainer op1, Ope } #pragma GCC diagnostic pop +p diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp index 6878635c..d3e16548 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp index 4e7419c5..f71346ff 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp index d70137bd..85aaf82a 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp b/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp index 4e5a35c0..6c11e264 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp b/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp index 6a094886..80eba416 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -63,11 +63,11 @@ void HyperCPU::CPU::ExecMOV(const IInstruction& instr, OperandContainer op1, Ope case b16: *static_cast(op1) = mem_controller->Read16(ptr); break; - + case b32: *static_cast(op1) = mem_controller->Read32(ptr); break; - + case b64: *static_cast(op1) = mem_controller->Read64(ptr); break; @@ -80,15 +80,15 @@ void HyperCPU::CPU::ExecMOV(const IInstruction& instr, OperandContainer op1, Ope case b8: std::memcpy(op1, &op2.ref(), 1); break; - + case b16: std::memcpy(op1, &op2.ref(), 2); break; - + case b32: std::memcpy(op1, &op2.ref(), 4); break; - + case b64: std::memcpy(op1, &op2.ref(), 8); break; @@ -102,10 +102,10 @@ void HyperCPU::CPU::ExecMOV(const IInstruction& instr, OperandContainer op1, Ope ptr2 = op2; switch (instr.m_opcode_mode) { - case b8: + case b8: mem_controller->Load8(ptr1, mem_controller->Read8(ptr2)); break; - + case b16: mem_controller->Load16(ptr1, mem_controller->Read16(ptr2)); break; @@ -113,7 +113,7 @@ void HyperCPU::CPU::ExecMOV(const IInstruction& instr, OperandContainer op1, Ope case b32: mem_controller->Load32(ptr1, mem_controller->Read32(ptr2)); break; - + case b64: mem_controller->Load64(ptr1, mem_controller->Read64(ptr2)); break; @@ -155,15 +155,15 @@ void HyperCPU::CPU::ExecMOV(const IInstruction& instr, OperandContainer op1, Ope case b8: mem_controller->Load8(ptr1, HyperCPU::bit_cast(op2)); break; - + case b16: mem_controller->Load16(ptr1, HyperCPU::bit_cast(op2)); break; - + case b32: mem_controller->Load32(ptr1, HyperCPU::bit_cast(op2)); break; - + case b64: mem_controller->Load64(ptr1, HyperCPU::bit_cast(op2)); break; diff --git a/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp index ac710823..8dccc83a 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -116,21 +116,21 @@ void HyperCPU::CPU::ExecMUL(const IInstruction& instr, OperandContainer op1, Ope op1.deref() = __hcpu_mul(op1.deref(), val); break; } - + case b16: { std::uint16_t val = HyperCPU::bit_cast(op2); ovf = multiplication_will_overflow(op1.deref(), val); op1.deref() = __hcpu_mul(op1.deref(), val); break; } - + case b32: { std::uint32_t val = HyperCPU::bit_cast(op2); ovf = multiplication_will_overflow(op1.deref(), val); op1.deref() = __hcpu_mul(op1.deref(), val); break; } - + case b64: { std::uint64_t val = HyperCPU::bit_cast(op2); ovf = multiplication_will_overflow(op1.deref(), val); diff --git a/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp index 460d87f3..5eb7ae8c 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -100,19 +100,19 @@ void HyperCPU::CPU::ExecOR(const IInstruction& instr, OperandContainer op1, Oper op1.deref() = __hcpu_or(op1.deref(), val); break; } - + case b16: { std::uint16_t val = HyperCPU::bit_cast(op2); op1.deref() = __hcpu_or(op1.deref(), val); break; } - + case b32: { std::uint32_t val = HyperCPU::bit_cast(op2); op1.deref() = __hcpu_or(op1.deref(), val); break; } - + case b64: { std::uint64_t val = HyperCPU::bit_cast(op2); op1.deref() = __hcpu_or(op1.deref(), val); diff --git a/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp index ae74fb70..788f4e49 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp b/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp index b2fcd438..f6914651 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp b/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp index 7de544ac..2dcb236f 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp index 6969e596..cfcbc6f6 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -35,19 +35,19 @@ void HyperCPU::CPU::ExecSHFL(const IInstruction& instr, OperandContainer op1, Op op1.deref() <<= val; break; } - + case b16: { std::uint16_t val = HyperCPU::bit_cast(op2); op1.deref() <<= val; break; } - + case b32: { std::uint32_t val = HyperCPU::bit_cast(op2); op1.deref() <<= val; break; } - + case b64: { std::uint64_t val = HyperCPU::bit_cast(op2); op1.deref() <<= val; diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp index c97183ac..d6417a3a 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -36,19 +36,19 @@ void HyperCPU::CPU::ExecSHFR(const IInstruction& instr, OperandContainer op1, Op op1.deref() >>= val; break; } - + case b16: { std::uint16_t val = HyperCPU::bit_cast(op2); op1.deref() >>= val; break; } - + case b32: { std::uint32_t val = HyperCPU::bit_cast(op2); op1.deref() >>= val; break; } - + case b64: { std::uint64_t val = HyperCPU::bit_cast(op2); op1.deref() >>= val; diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp index f3a8f8e1..5edc7633 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -114,21 +114,21 @@ void HyperCPU::CPU::ExecSUB(const IInstruction& instr, OperandContainer op1, Ope op1.deref() = __hcpu_sub(op1.deref(), val); break; } - + case b16: { std::uint16_t val = HyperCPU::bit_cast(op2); udf = SubtractionWillUnderflow(op1.deref(), val); op1.deref() = __hcpu_sub(op1.deref(), val); break; } - + case b32: { std::uint32_t val = HyperCPU::bit_cast(op2); udf = SubtractionWillUnderflow(op1.deref(), val); op1.deref() = __hcpu_sub(op1.deref(), val); break; } - + case b64: { std::uint64_t val = HyperCPU::bit_cast(op2); udf = SubtractionWillUnderflow(op1.deref(), val); diff --git a/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp b/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp index ae38520e..ed7317df 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include diff --git a/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp b/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp index da072fb3..c5d732f5 100644 --- a/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp +++ b/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -12,7 +12,7 @@ void HyperCPU::CPU::TriggerInterrupt(HyperCPU::cpu_exceptions exception) { logger.Log(LogLevel::ERROR, "Interrupt was triggered, but failed to execute handler! XIP: {}", *xip); ABORT(); } - + pending_interrupt = std::make_optional(mem_controller->Read64((*xivt) + (8 * static_cast(exception)))); /* @@ -28,7 +28,7 @@ void HyperCPU::CPU::TriggerInterrupt(HyperCPU::cpu_exceptions exception) { void HyperCPU::CPU::RunInterruptSubroutine() { while (1) { if (halted) return; - + HyperCPU::IInstruction instr = m_decoder->FetchAndDecode(); if (instr.m_opcode == Opcode::IRET) { return; diff --git a/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp b/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp index e1b48bfb..74d5d8d0 100644 --- a/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp +++ b/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" namespace HyperCPU { @@ -10,4 +10,4 @@ namespace HyperCPU { ZRDIV, SEGF }; -} \ No newline at end of file +} diff --git a/src/Emulator/Core/CPU/OperandsEvaluation.cpp b/src/Emulator/Core/CPU/OperandsEvaluation.cpp index 03e6e8af..06194aa3 100644 --- a/src/Emulator/Core/CPU/OperandsEvaluation.cpp +++ b/src/Emulator/Core/CPU/OperandsEvaluation.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -72,7 +72,7 @@ std::pair HyperCPU::CPU: op_2 = GetRegister(op2); return std::make_pair(op_1, op_2); } - + case RM_M: case R_M: return std::make_pair(GetRegister(op1), op2); @@ -106,10 +106,10 @@ std::pair HyperCPU::CPU: case M_R: return std::make_pair(op1, GetRegister(op2)); - + case R: return std::make_pair(GetRegister(op1), nullptr); - + case IMM: case M: return std::make_pair(op1, nullptr); diff --git a/src/Emulator/Core/CPU/Stack.cpp b/src/Emulator/Core/CPU/Stack.cpp index 739a6932..b0ad83a0 100644 --- a/src/Emulator/Core/CPU/Stack.cpp +++ b/src/Emulator/Core/CPU/Stack.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -62,4 +62,4 @@ std::uint64_t HyperCPU::CPU::StackPop64() noexcept { std::uint64_t val = mem_controller->Read64(*xsp); *xsp += 8; return val; -} \ No newline at end of file +} diff --git a/src/Emulator/Core/MemoryController/IMemoryController.hpp b/src/Emulator/Core/MemoryController/IMemoryController.hpp index 22b36a34..9c16e8a7 100644 --- a/src/Emulator/Core/MemoryController/IMemoryController.hpp +++ b/src/Emulator/Core/MemoryController/IMemoryController.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" #define mem_ctlr_assert(expr) \ diff --git a/src/Emulator/Core/MemoryController/MemoryControllerST.hpp b/src/Emulator/Core/MemoryController/MemoryControllerST.hpp index 5beeb57c..3e433038 100644 --- a/src/Emulator/Core/MemoryController/MemoryControllerST.hpp +++ b/src/Emulator/Core/MemoryController/MemoryControllerST.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" #include #include diff --git a/src/Emulator/Main/ExceptionHandling.cpp b/src/Emulator/Main/ExceptionHandling.cpp index 83308482..0536df50 100644 --- a/src/Emulator/Main/ExceptionHandling.cpp +++ b/src/Emulator/Main/ExceptionHandling.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include
#include @@ -10,4 +10,4 @@ [[noreturn]] void HyperCPU::ThrowError(CPU* cpu, std::string message) { cpu->GetLogger().Log(HyperCPU::LogLevel::ERROR, message); EXIT(1); -} \ No newline at end of file +} diff --git a/src/Emulator/Main/ExceptionHandling.hpp b/src/Emulator/Main/ExceptionHandling.hpp index 48968374..80a61df1 100644 --- a/src/Emulator/Main/ExceptionHandling.hpp +++ b/src/Emulator/Main/ExceptionHandling.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" namespace HyperCPU { diff --git a/src/Emulator/Main/Main.cpp b/src/Emulator/Main/Main.cpp index 7271cf04..cd4ddfc1 100644 --- a/src/Emulator/Main/Main.cpp +++ b/src/Emulator/Main/Main.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include #include @@ -51,11 +51,11 @@ int main(int argc, char** argv) { } std::ifstream file(source); - + std::int64_t binarysize = std::filesystem::file_size(source) - sizeof(HyperCPU::GenericHeader); HyperCPU::GenericHeader header = ParseHeader(file); - + // Validate header contents if (header.magic != HyperCPU::magic) { logger.Log(HyperCPU::LogLevel::ERROR, "Invalid magic!"); diff --git a/src/Emulator/Main/Main.hpp b/src/Emulator/Main/Main.hpp index 3eef498e..f83f9fc4 100644 --- a/src/Emulator/Main/Main.hpp +++ b/src/Emulator/Main/Main.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" namespace HyperCPU { @@ -18,7 +18,7 @@ namespace HyperCPU { Object = 0x01, Binary = 0x02 }; - + using Magic = std::uint64_t; static inline constexpr Magic magic = 0xb7a6457636cf6c3a; diff --git a/src/Emulator/Misc/byteswap.hpp b/src/Emulator/Misc/byteswap.hpp index a6582a0b..9e58d3a2 100644 --- a/src/Emulator/Misc/byteswap.hpp +++ b/src/Emulator/Misc/byteswap.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "pch.hpp" #include diff --git a/src/Exit.hpp b/src/Exit.hpp deleted file mode 100644 index 6bc260b8..00000000 --- a/src/Exit.hpp +++ /dev/null @@ -1,11 +0,0 @@ -#pragma once - -#ifdef __HCPU_DEBUG -# define UNREACHABLE() std::abort() -# define EXIT(code) std::abort() -#else -# define UNREACHABLE() __builtin_unreachable() -# define EXIT(code) std::exit(code) -#endif - -#define ABORT() std::abort() \ No newline at end of file diff --git a/src/Logger/BUILD.bazel b/src/Logger/BUILD.bazel deleted file mode 100644 index 49f6551c..00000000 --- a/src/Logger/BUILD.bazel +++ /dev/null @@ -1,13 +0,0 @@ -load('@rules_cc//cc:defs.bzl', 'cc_library') - - -cc_library( - name = 'logger', - hdrs = [ - 'Colors.hpp', - 'Logger.hpp' - ], - includes = [ - '//src', - ] -) diff --git a/src/Logger/Colors.hpp b/src/Logger/Colors.hpp deleted file mode 100644 index 3d75e0a9..00000000 --- a/src/Logger/Colors.hpp +++ /dev/null @@ -1,8 +0,0 @@ -#pragma once - -static constexpr char RESET[] = "\e[0m"; -static constexpr char B_RED[] = "\e[1;31m"; -static constexpr char B_GREEN[] = "\e[1;32m"; -static constexpr char B_YELLOW[] = "\e[1;33m"; -static constexpr char RED[] = "\e[0;31m"; -static constexpr char YELLOW[] = "\e[0;33m"; \ No newline at end of file diff --git a/src/Logger/Logger.hpp b/src/Logger/Logger.hpp deleted file mode 100644 index 6a5d0cac..00000000 --- a/src/Logger/Logger.hpp +++ /dev/null @@ -1,78 +0,0 @@ -#pragma once - -#include - -#include -#include -#include - - -namespace HyperCPU { - enum class LogLevel : std::uint_fast8_t { DEBUG = 0, INFO = 1, WARNING = 2, ERROR = 3 }; - - class Logger { - private: - LogLevel _loglevel; - - constexpr char DefineMsgChar(HyperCPU::LogLevel lvl) const noexcept { - switch (lvl) { - case HyperCPU::LogLevel::DEBUG: - return '-'; - case HyperCPU::LogLevel::INFO: - return '*'; - case HyperCPU::LogLevel::WARNING: - return '='; - case HyperCPU::LogLevel::ERROR: - return '!'; - default: - UNREACHABLE(); - } - } - - constexpr const char* DefineBoldColor(HyperCPU::LogLevel lvl) const noexcept { - switch (lvl) { - case HyperCPU::LogLevel::DEBUG: - case HyperCPU::LogLevel::INFO: - return RESET; - case HyperCPU::LogLevel::WARNING: - return B_YELLOW; - case HyperCPU::LogLevel::ERROR: - return B_RED; - default: - UNREACHABLE(); - } - } - - constexpr const char* DefineColor(HyperCPU::LogLevel lvl) const noexcept { - switch (lvl) { - case HyperCPU::LogLevel::DEBUG: - case HyperCPU::LogLevel::INFO: - return RESET; - case HyperCPU::LogLevel::WARNING: - return YELLOW; - case HyperCPU::LogLevel::ERROR: - return RED; - default: - UNREACHABLE(); - } - } - - public: - Logger(LogLevel default_loglevel) : _loglevel(default_loglevel) { - } - - template - void Log(LogLevel lvl, std::string_view fmt, Args&&... args) const noexcept { - if (static_cast(lvl) < static_cast(_loglevel)) { - return; - } - - auto ch = DefineMsgChar(lvl); - auto bold_col = DefineBoldColor(lvl); - auto col = DefineColor(lvl); - - print("{}[{}]{} {}", bold_col, ch, RESET, col); - print("{}{}\n", fmt::vformat(fmt, fmt::make_format_args(std::forward(args)...)), RESET); - } - }; -} // namespace HyperCPU diff --git a/src/NotImplemented.hpp b/src/NotImplemented.hpp deleted file mode 100644 index 8d59d7d5..00000000 --- a/src/NotImplemented.hpp +++ /dev/null @@ -1,12 +0,0 @@ -#pragma once - -#include -#include - -namespace HyperCPU { - [[gnu::always_inline]] - static inline void PrintUnsupported(std::string msg) { - std::cerr << msg << '\n'; - EXIT(1); - } -} diff --git a/src/BUILD.bazel b/src/PCH/BUILD.bazel similarity index 77% rename from src/BUILD.bazel rename to src/PCH/BUILD.bazel index 2c287eee..555530d6 100644 --- a/src/BUILD.bazel +++ b/src/PCH/BUILD.bazel @@ -1,14 +1,12 @@ load('//tools/bazel:pch.bzl', 'precompiled_headers') - package( default_visibility = [ "//:__subpackages__", ], ) - precompiled_headers( - name = 'pch', - main = 'pch.hpp' + name = 'pch_cstd', + main = 'CStd.hpp' ) diff --git a/src/pch.hpp b/src/PCH/CStd.hpp similarity index 77% rename from src/pch.hpp rename to src/PCH/CStd.hpp index 07388a4e..479e713e 100644 --- a/src/pch.hpp +++ b/src/PCH/CStd.hpp @@ -1,7 +1,7 @@ /* - * Precompiled headers - * ! Only add headers that will not be modified ! + * Precompiled headers that belong to standard library */ + #include #include #include @@ -13,11 +13,8 @@ #include #include #include -#include #include #include -#include -#include #include #include #include @@ -35,4 +32,3 @@ #include #include #include -#include diff --git a/src/Pog/BUILD.bazel b/src/Pog/BUILD.bazel index 8b8629af..f9cb3c94 100644 --- a/src/Pog/BUILD.bazel +++ b/src/Pog/BUILD.bazel @@ -1,3 +1,4 @@ +load('@rules_cc//cc:defs.bzl', 'cc_library') load('//tools/bazel:pch.bzl', 'precompiled_headers') @@ -8,7 +9,21 @@ package( ) +cc_library( + name = 'pog_core', + hdrs = glob(['**/*.hpp'], exclude = ['Pog.hpp']), + include_prefix = 'src', + includes = [ + # should remove in the future, all includes must be relative to src/ + '.' + ] +) + + precompiled_headers( name = 'pog', - main = 'Pog.hpp' + main = 'Pog.hpp', + deps = [ + ':pog_core' + ] ) diff --git a/tests/Integration/AssemblerCore/AssemblerFail.cpp b/tests/Integration/AssemblerCore/AssemblerFail.cpp index 729337be..665ff840 100644 --- a/tests/Integration/AssemblerCore/AssemblerFail.cpp +++ b/tests/Integration/AssemblerCore/AssemblerFail.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include diff --git a/tests/Integration/AssemblerCore/FullAssembler.cpp b/tests/Integration/AssemblerCore/FullAssembler.cpp index 5d8c3a45..5bc8b438 100644 --- a/tests/Integration/AssemblerCore/FullAssembler.cpp +++ b/tests/Integration/AssemblerCore/FullAssembler.cpp @@ -1,13 +1,13 @@ #include #include "Main/Main.hpp" #include "Misc/bit_cast.hpp" -#include +#include "pch.hpp" TEST_F(FULL_ASSEMBLER, MULTUPLE_INSTRUCTIONS) { std::string data = "_start:\n\tmov x0, 0u1;\n\tmov x1, 0u2;\n\tadd x0, x1;"; std::uint32_t code_size; auto binary = compiler.Compile(data, code_size); - + { std::ofstream file("test", std::ios::binary); @@ -49,7 +49,7 @@ TEST_F(FULL_ASSEMBLER, IRET) { std::string data = "mov xbp, 0u512; mov xsp, xbp; push b64 hlt; iret; hlt: halt;"; std::uint32_t code_size; auto binary = compiler.Compile(data, code_size); - + { std::ofstream file("test", std::ios::binary); diff --git a/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp b/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp index 90a0768b..e56b64c8 100644 --- a/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp +++ b/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include TEST_F(TWO_OPERANDS_SUCCESS, OPERANDS_R_R_b8) { diff --git a/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp b/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp index c3f0e279..8e3d612a 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp @@ -1,7 +1,7 @@ #include "Core/CPU/Instructions/Registers.hpp" #include #include -#include +#include "pch.hpp" #include // TODO: fix include order @@ -73,4 +73,4 @@ TEST_F(CPU_TEST, INSTR_POP_R_b64) { cpu.Run(); ASSERT_EQ(*cpu.x0, QWORD_DATA1); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp b/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp index a53a5849..9ed83142 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp @@ -1,7 +1,7 @@ #include "Core/CPU/Instructions/Registers.hpp" #include #include -#include +#include "pch.hpp" #include // TODO: fix include order @@ -125,4 +125,4 @@ TEST_F(CPU_TEST, INSTR_PUSH_IMM_b64) { cpu.Run(); ASSERT_EQ(HyperCPU::bit_cast_from(cpu.mem_controller->get_ptr() + *cpu.xsp), QWORD_DATA1); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_READ.cpp b/tests/Integration/EmulatorCore/CPU/CPU_READ.cpp index 3b37ab86..92159fb7 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_READ.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_READ.cpp @@ -1,6 +1,6 @@ #include "Core/CPU/Instructions/Flags.hpp" #include -#include +#include "pch.hpp" TEST_F(CPU_TEST, INSTR_READ) { cpu.read_io_handlers[1] = []() -> std::uint8_t { diff --git a/tests/Integration/EmulatorCore/CPU/CPU_WRITE.cpp b/tests/Integration/EmulatorCore/CPU/CPU_WRITE.cpp index a22b25d9..b7a4ba2a 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_WRITE.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_WRITE.cpp @@ -1,7 +1,7 @@ #include "Core/CPU/Instructions/Registers.hpp" #include #include -#include +#include "pch.hpp" TEST_F(CPU_TEST, INSTR_WRITE) { std::uint8_t t = 0; diff --git a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_IMM.cpp index 93367eef..594257b0 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_IMM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B64) { memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(data, 0x5555555555555555); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_M.cpp index 63292394..9aa6cf87 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_M.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,6 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_M_B64) { memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} +PTR); +} diff --git a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_R.cpp index fea4eb62..35c069af 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -57,7 +57,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -80,7 +80,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -92,4 +92,4 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_RM.cpp index 2969d0d9..68cf50af 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_RM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -36,7 +36,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -59,7 +59,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,4 +94,4 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_RM_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp index 7842368c..004754c6 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -31,7 +31,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -44,7 +44,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -57,7 +57,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -70,7 +70,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -83,7 +83,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -96,7 +96,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -109,7 +109,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -122,7 +122,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -135,7 +135,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -148,7 +148,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -161,7 +161,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -174,7 +174,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -187,7 +187,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -200,7 +200,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -213,7 +213,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -226,7 +226,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -239,7 +239,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -252,7 +252,7 @@ TEST_F(DECODER_TEST, ADC_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -265,6 +265,6 @@ TEST_F(DECODER_TEST, ADC_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_IMM.cpp index 5181066f..b9201495 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_IMM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B64) { memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(data, 0x5555555555555555); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_M.cpp index 8769ee31..3901965f 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_M.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,6 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_M_B64) { memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} +PTR); +} diff --git a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_R.cpp index 1f1be59f..9d89bf4a 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -57,7 +57,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -80,7 +80,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -92,4 +92,4 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_RM.cpp index 929f8fee..79b348ed 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_RM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -36,7 +36,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -59,7 +59,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,4 +94,4 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_RM_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp index 0134f74c..0d6990f9 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -19,7 +19,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -32,7 +32,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -45,7 +45,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -58,7 +58,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -71,7 +71,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -84,7 +84,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -97,7 +97,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -110,7 +110,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -123,7 +123,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -136,7 +136,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -149,7 +149,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -162,7 +162,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -175,7 +175,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -188,7 +188,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -201,7 +201,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -214,7 +214,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -227,7 +227,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -240,7 +240,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -253,7 +253,7 @@ TEST_F(DECODER_TEST, ADD_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -266,6 +266,6 @@ TEST_F(DECODER_TEST, ADD_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_IMM.cpp index d0d0348d..4330dc86 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_IMM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B64) { memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(data, 0x5555555555555555); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_M.cpp index c971500c..e8c9249f 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_M.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, AND_INSTR_R_M_B64) { memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_R.cpp index eab05738..4c4d1c5b 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -57,7 +57,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -80,7 +80,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -92,4 +92,4 @@ TEST_F(DECODER_TEST, AND_INSTR_R_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_RM.cpp index 1d8668d0..cd125b20 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_RM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -36,7 +36,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -59,7 +59,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,4 +94,4 @@ TEST_F(DECODER_TEST, AND_INSTR_R_RM_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp index e700978b..73f3e375 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -19,7 +19,7 @@ TEST_F(DECODER_TEST, AND_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -32,7 +32,7 @@ TEST_F(DECODER_TEST, AND_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -45,7 +45,7 @@ TEST_F(DECODER_TEST, AND_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -58,7 +58,7 @@ TEST_F(DECODER_TEST, AND_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -71,7 +71,7 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -84,7 +84,7 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -97,7 +97,7 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -110,7 +110,7 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -123,7 +123,7 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -136,7 +136,7 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -149,7 +149,7 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -162,7 +162,7 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -175,7 +175,7 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -188,7 +188,7 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -201,7 +201,7 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -214,7 +214,7 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -227,7 +227,7 @@ TEST_F(DECODER_TEST, AND_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -240,7 +240,7 @@ TEST_F(DECODER_TEST, AND_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -253,7 +253,7 @@ TEST_F(DECODER_TEST, AND_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -266,6 +266,6 @@ TEST_F(DECODER_TEST, AND_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_IMM.cpp index b106d04d..f4f347cd 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_IMM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B64) { memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(data, 0x5555555555555555); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_M.cpp index 76946b51..ceb70f0e 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_M.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B64) { memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_R.cpp index 22fbd0d7..b53f6303 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -57,7 +57,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -80,7 +80,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -92,4 +92,4 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_RM.cpp index ca0f266b..5fc836c8 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_RM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -36,7 +36,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -59,7 +59,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,4 +94,4 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_RM_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp index e1abbb8a..e13c883e 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -19,7 +19,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -32,7 +32,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -45,7 +45,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -58,7 +58,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -71,7 +71,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -84,7 +84,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -97,7 +97,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -110,7 +110,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -123,7 +123,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -136,7 +136,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -149,7 +149,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -162,7 +162,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -175,7 +175,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -188,7 +188,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -201,7 +201,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -214,7 +214,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -227,7 +227,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -240,7 +240,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -253,7 +253,7 @@ TEST_F(DECODER_TEST, ANDN_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -266,6 +266,6 @@ TEST_F(DECODER_TEST, ANDN_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/R.cpp b/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/R.cpp index f7d7f1ac..d541e58b 100644 --- a/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -55,7 +55,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -76,7 +76,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -86,4 +86,4 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_B64) { memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp index d72adcd8..0edc8c44 100644 --- a/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,6 +459,6 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_imm.cpp index 8783bb4c..a011d785 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_imm.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_IMM) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +20,4 @@ TEST_F(DECODER_TEST, CALLE_INSTR_IMM) { memcpy(&mem_ptr, &instr.m_op1, sizeof(std::uint64_t)); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_r.cpp index e7951311..b43d0f04 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_r.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,10 +13,10 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CALLE); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp index 402dcec6..2bd23ccb 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, CALLE_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,6 +485,6 @@ TEST_F(DECODER_TEST, CALLE_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_imm.cpp index 65bcd9f4..9994cbce 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_imm.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_IMM) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +20,4 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_IMM) { memcpy(&mem_ptr, &instr.m_op1, sizeof(std::uint64_t)); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_r.cpp index 008b5d90..0d1c84e8 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_r.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,10 +13,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CALLGR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); -} \ No newline at end of file +} +} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp index 979b0765..f77d2f13 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,6 +485,6 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_imm.cpp index f77dc42b..42a5d5e8 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_imm.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_IMM) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +20,5 @@ TEST_F(DECODER_TEST, CALL_INSTR_IMM) { memcpy(&mem_ptr, &instr.m_op1, sizeof(std::uint64_t)); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} +} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_r.cpp index a7e0d0bf..26a5e26a 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_r.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,10 +13,10 @@ TEST_F(DECODER_TEST, CALL_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CALL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp index 67009369..adca0567 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, CALL_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,6 +485,6 @@ TEST_F(DECODER_TEST, CALL_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_imm.cpp index 067e8987..0e84a303 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_imm.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_IMM) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +20,4 @@ TEST_F(DECODER_TEST, CALLL_INSTR_IMM) { memcpy(&mem_ptr, &instr.m_op1, sizeof(std::uint64_t)); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_r.cpp index f92c59b3..cf406431 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_r.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,10 +13,10 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CALLL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp index be12d0f6..13ea24ef 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, CALLL_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,6 +485,6 @@ TEST_F(DECODER_TEST, CALLL_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_none.cpp b/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_none.cpp index 0683c5f1..726d51ff 100644 --- a/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_none.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_none.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -9,9 +9,9 @@ TEST_F(DECODER_TEST, CCRF_INSTR_NONE) { counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CCRF); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::NONE); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp index 181a25e9..6ada6df0 100644 --- a/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,7 +485,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_M_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -498,7 +498,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_M_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -511,7 +511,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_M_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -524,7 +524,7 @@ TEST_F(DECODER_TEST, CCRF_INSTR_M_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -538,6 +538,8 @@ TEST_F(DECODER_TEST, CCRF_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } +XIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); +} diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/M_R.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/M_R.cpp index 52982253..0af2e858 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/M_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/M_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, CMP_INSTR_M_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(mem_ptr, MEM_PTR); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_IMM.cpp index 40291f86..b06e382d 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_IMM.cpp @@ -1,5 +1,5 @@ #include "Core/CPU/Instructions/Opcodes.hpp" -#include +#include "pch.hpp" #include @@ -14,7 +14,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -38,7 +38,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -62,7 +62,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -86,7 +86,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -99,4 +99,4 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B64) { memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(data, 0x5555555555555555); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_M.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_M.cpp index ab27064d..ec247ba1 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_M.cpp @@ -1,5 +1,5 @@ #include "Core/CPU/Instructions/Opcodes.hpp" -#include +#include "pch.hpp" #include @@ -14,7 +14,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -38,7 +38,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -62,7 +62,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -86,7 +86,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -99,4 +99,6 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B64) { memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} +PTR); +} diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_R.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_R.cpp index 41cf2225..c450d68f 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_R.cpp @@ -1,5 +1,5 @@ #include "Core/CPU/Instructions/Opcodes.hpp" -#include +#include "pch.hpp" #include @@ -14,7 +14,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -60,7 +60,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -83,7 +83,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -95,4 +95,6 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} +:X7); +} diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_IMM.cpp index 05df334d..8f1baf41 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_IMM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_M.cpp index ee676fd6..3bdacd84 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_M.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_M_B64) { memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_R.cpp index 12562412..ac6cfbcc 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_R.cpp @@ -1,5 +1,5 @@ #include "Core/CPU/Instructions/Opcodes.hpp" -#include +#include "pch.hpp" #include @@ -12,7 +12,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -35,7 +35,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -58,7 +58,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -81,7 +81,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -93,4 +93,4 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_RM.cpp index bfac9b4a..e81929ef 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_RM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -36,7 +36,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -59,7 +59,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,4 +94,4 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_RM_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp index 69f76cb6..d5f86f54 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp @@ -1,5 +1,5 @@ #include "Core/CPU/Instructions/Opcodes.hpp" -#include +#include "pch.hpp" #include @@ -20,7 +20,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -33,7 +33,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -46,7 +46,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -59,6 +59,6 @@ TEST_F(DECODER_TEST, CMP_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_none.cpp b/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_none.cpp index 0309d7dd..98c79f98 100644 --- a/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_none.cpp +++ b/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_none.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -9,9 +9,10 @@ TEST_F(DECODER_TEST, COVF_INSTR_NONE) { counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::COVF); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::NONE); -} \ No newline at end of file +} +} diff --git a/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp index 5e8f4471..06f23f58 100644 --- a/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,7 +485,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_M_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -498,7 +498,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_M_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -511,7 +511,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_M_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -524,7 +524,7 @@ TEST_F(DECODER_TEST, COVF_INSTR_M_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -538,6 +538,6 @@ TEST_F(DECODER_TEST, COVF_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } diff --git a/tests/Modular/EmulatorCore/Decoding/CUDFInstr/None.cpp b/tests/Modular/EmulatorCore/Decoding/CUDFInstr/None.cpp index 617fa98f..b34b3533 100644 --- a/tests/Modular/EmulatorCore/Decoding/CUDFInstr/None.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CUDFInstr/None.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -9,9 +9,9 @@ TEST_F(DECODER_TEST, CUDF_INSTR_NONE) { counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CUDF); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::NONE); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp index 7c8610d6..82dca347 100644 --- a/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,7 +485,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_M_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -498,7 +498,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_M_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -511,7 +511,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_M_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -524,7 +524,7 @@ TEST_F(DECODER_TEST, CUDF_INSTR_M_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -538,6 +538,8 @@ TEST_F(DECODER_TEST, CUDF_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } +XIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); +} diff --git a/tests/Modular/EmulatorCore/Decoding/DECInstr/R.cpp b/tests/Modular/EmulatorCore/Decoding/DECInstr/R.cpp index a1c5e6d7..14865aaa 100644 --- a/tests/Modular/EmulatorCore/Decoding/DECInstr/R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DECInstr/R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -55,7 +55,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -76,7 +76,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -86,4 +86,4 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_B64) { memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp index 2894ea33..b2a28019 100644 --- a/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, DEC_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,6 +459,6 @@ TEST_F(DECODER_TEST, DEC_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/DIVInstr/R.cpp b/tests/Modular/EmulatorCore/Decoding/DIVInstr/R.cpp index 2c8e14b5..80743c2c 100644 --- a/tests/Modular/EmulatorCore/Decoding/DIVInstr/R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DIVInstr/R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -55,7 +55,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -76,7 +76,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); diff --git a/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp index feb0e0ee..84ae67e5 100644 --- a/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -28,7 +28,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -74,7 +74,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -87,7 +87,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -100,7 +100,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -113,7 +113,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -126,7 +126,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -139,7 +139,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -152,7 +152,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -165,7 +165,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -178,7 +178,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -191,7 +191,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -204,7 +204,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -217,7 +217,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -230,7 +230,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -243,7 +243,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -256,7 +256,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -269,7 +269,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -282,7 +282,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -295,7 +295,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -308,7 +308,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -321,7 +321,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -334,7 +334,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -347,7 +347,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -360,7 +360,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -373,7 +373,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -386,7 +386,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -399,7 +399,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -412,7 +412,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -425,7 +425,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -438,7 +438,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -451,7 +451,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -464,7 +464,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -477,7 +477,7 @@ TEST_F(DECODER_TEST, DIV_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -490,6 +490,6 @@ TEST_F(DECODER_TEST, DIV_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/Features/AddressAddition.cpp b/tests/Modular/EmulatorCore/Decoding/Features/AddressAddition.cpp index c98f7602..3772acee 100644 --- a/tests/Modular/EmulatorCore/Decoding/Features/AddressAddition.cpp +++ b/tests/Modular/EmulatorCore/Decoding/Features/AddressAddition.cpp @@ -1,6 +1,6 @@ #include -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, ADDR_ADDITION_DISABLED) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -40,7 +40,7 @@ TEST_F(DECODER_TEST, ADDR_ADDITION_OP1) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -68,7 +68,7 @@ TEST_F(DECODER_TEST, ADDR_ADDITION_OP2) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -82,4 +82,4 @@ TEST_F(DECODER_TEST, ADDR_ADDITION_OP2) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/HALTInstr/None.cpp b/tests/Modular/EmulatorCore/Decoding/HALTInstr/None.cpp index ad3e8cc7..0f87ce72 100644 --- a/tests/Modular/EmulatorCore/Decoding/HALTInstr/None.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HALTInstr/None.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -9,9 +9,9 @@ TEST_F(DECODER_TEST, HALT_INSTR_NONE) { counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::HALT); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::NONE); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp index 0058bdbe..be8d0624 100644 --- a/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,7 +485,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_M_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -498,7 +498,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_M_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -511,7 +511,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_M_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -524,7 +524,7 @@ TEST_F(DECODER_TEST, HALT_INSTR_M_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -538,6 +538,6 @@ TEST_F(DECODER_TEST, HALT_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } diff --git a/tests/Modular/EmulatorCore/Decoding/HIDInstr/None.cpp b/tests/Modular/EmulatorCore/Decoding/HIDInstr/None.cpp index fb62a22e..e4de2a8d 100644 --- a/tests/Modular/EmulatorCore/Decoding/HIDInstr/None.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HIDInstr/None.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -9,9 +9,9 @@ TEST_F(DECODER_TEST, HID_INSTR_NONE) { counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::HID); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::NONE); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp index dbe29ceb..50d368f1 100644 --- a/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, HID_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, HID_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, HID_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, HID_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, HID_INSTR_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,7 +485,7 @@ TEST_F(DECODER_TEST, HID_INSTR_M_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -498,7 +498,7 @@ TEST_F(DECODER_TEST, HID_INSTR_M_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -511,7 +511,7 @@ TEST_F(DECODER_TEST, HID_INSTR_M_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -524,7 +524,7 @@ TEST_F(DECODER_TEST, HID_INSTR_M_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -538,6 +538,6 @@ TEST_F(DECODER_TEST, HID_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } diff --git a/tests/Modular/EmulatorCore/Decoding/INCInstr/R.cpp b/tests/Modular/EmulatorCore/Decoding/INCInstr/R.cpp index 1b3cef74..6fcde901 100644 --- a/tests/Modular/EmulatorCore/Decoding/INCInstr/R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/INCInstr/R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -55,7 +55,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -76,7 +76,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -86,4 +86,4 @@ TEST_F(DECODER_TEST, INC_INSTR_R_B64) { memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp index f526d0ff..8fdc6bac 100644 --- a/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, INC_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, INC_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, INC_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, INC_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, INC_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, INC_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, INC_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,6 +459,6 @@ TEST_F(DECODER_TEST, INC_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_imm.cpp index 91badc23..890234db 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_imm.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, JME_INSTR_IMM) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +20,4 @@ TEST_F(DECODER_TEST, JME_INSTR_IMM) { memcpy(&mem_ptr, &instr.m_op1, sizeof(std::uint64_t)); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_r.cpp index 711241c8..0d0669c9 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_r.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,10 +13,10 @@ TEST_F(DECODER_TEST, JME_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::JME); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp index 627ac599..505d516b 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, JME_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, JME_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, JME_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, JME_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, JME_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, JME_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,6 +485,6 @@ TEST_F(DECODER_TEST, JME_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_imm.cpp index 4346c7ac..09cda145 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_imm.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_IMM) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +20,4 @@ TEST_F(DECODER_TEST, JMGR_INSTR_IMM) { memcpy(&mem_ptr, &instr.m_op1, sizeof(std::uint64_t)); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_r.cpp index 338eb801..64c8efa4 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_r.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,10 +13,10 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::JMGR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp index a8fefb53..ffe83fbe 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, JMGR_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,6 +485,6 @@ TEST_F(DECODER_TEST, JMGR_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_imm.cpp index 2b5309d7..90346e97 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_imm.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, JML_INSTR_IMM) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +20,4 @@ TEST_F(DECODER_TEST, JML_INSTR_IMM) { memcpy(&mem_ptr, &instr.m_op1, sizeof(std::uint64_t)); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_r.cpp index 4863e775..4a23684f 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_r.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,10 +13,10 @@ TEST_F(DECODER_TEST, JML_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::JML); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp index b8b08ea4..49677b95 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, JML_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, JML_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, JML_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, JML_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, JML_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, JML_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,6 +485,6 @@ TEST_F(DECODER_TEST, JML_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_imm.cpp index 81e383d9..97e19405 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_imm.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_IMM) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +20,4 @@ TEST_F(DECODER_TEST, JMP_INSTR_IMM) { memcpy(&mem_ptr, &instr.m_op1, sizeof(std::uint64_t)); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_r.cpp index 5ebd7cc2..7738e71b 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_r.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,10 +13,10 @@ TEST_F(DECODER_TEST, JMP_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::JMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp index dcd2275a..913e1afd 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -17,7 +17,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -30,7 +30,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -43,7 +43,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -56,7 +56,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -69,7 +69,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -95,7 +95,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -108,7 +108,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -121,7 +121,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -134,7 +134,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -147,7 +147,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -160,7 +160,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -173,7 +173,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -186,7 +186,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -199,7 +199,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -212,7 +212,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -225,7 +225,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -238,7 +238,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -251,7 +251,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -264,7 +264,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -277,7 +277,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -290,7 +290,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -303,7 +303,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -316,7 +316,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -329,7 +329,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -342,7 +342,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -355,7 +355,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -368,7 +368,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -381,7 +381,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -394,7 +394,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -407,7 +407,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -420,7 +420,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -433,7 +433,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -446,7 +446,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -459,7 +459,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -472,7 +472,7 @@ TEST_F(DECODER_TEST, JMP_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -485,6 +485,6 @@ TEST_F(DECODER_TEST, JMP_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/M_R.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/M_R.cpp index 6149e53a..471b426e 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/M_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/M_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, MOV_INSTR_M_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(mem_ptr, MEM_PTR); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_IMM.cpp index 49bfaba8..f7c2a967 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_IMM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B64) { memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(data, 0x5555555555555555); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_M.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_M.cpp index 4fb39107..8ae5fab4 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_M.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B64) { memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_R.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_R.cpp index d5c6d070..362e56d2 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -36,7 +36,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -59,7 +59,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,4 +94,4 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_IMM.cpp index efa8a810..9b6dff25 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_IMM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_M.cpp index 9a8e9fb5..16d5e855 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_M.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_M_B64) { memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_R.cpp index 7ae422cc..0ec0b09b 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -57,7 +57,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -80,7 +80,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -92,4 +92,4 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_RM.cpp index 27ebe652..818d04c1 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_RM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -36,7 +36,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -59,7 +59,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,4 +94,4 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_RM_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp index 3b52a0ae..0375ae2f 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -19,7 +19,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -32,7 +32,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -45,7 +45,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -58,6 +58,6 @@ TEST_F(DECODER_TEST, MOV_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_IMM.cpp index c438616a..86685095 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_IMM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,6 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B64) { memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(data, 0x5555555555555555); -} \ No newline at end of file +} +555); +} diff --git a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_M.cpp index fbdda4e8..bf13ec38 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_M.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_M_B64) { memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_R.cpp index 455e77d3..ffc4c3ae 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -57,7 +57,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -80,7 +80,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -92,4 +92,4 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_RM.cpp index ace4469a..651d5242 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_RM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -36,7 +36,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -59,7 +59,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,4 +94,6 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_RM_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} +:X7); +} diff --git a/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp index 0caab6d3..32fc0b1b 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -19,7 +19,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -32,7 +32,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -45,7 +45,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -58,7 +58,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -71,7 +71,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -84,7 +84,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -97,7 +97,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -110,7 +110,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -123,7 +123,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -136,7 +136,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -149,7 +149,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -162,7 +162,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -175,7 +175,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -188,7 +188,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -201,7 +201,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -214,7 +214,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -227,7 +227,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -240,7 +240,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -253,7 +253,7 @@ TEST_F(DECODER_TEST, MUL_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -266,6 +266,8 @@ TEST_F(DECODER_TEST, MUL_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} +xitedWithCode(1), "Invalid opcode!"); +} diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_IMM.cpp index f7e45048..58aef598 100644 --- a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_IMM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,6 @@ TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B64) { memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(data, 0x5555555555555555); -} \ No newline at end of file +} +555); +} diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_M.cpp index 05f54a34..827e1828 100644 --- a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_M.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, OR_INSTR_R_M_B64) { memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_R.cpp index 00333a58..ffe298b1 100644 --- a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -57,7 +57,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -80,7 +80,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -92,4 +92,4 @@ TEST_F(DECODER_TEST, OR_INSTR_R_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_RM.cpp index 94d37544..6dadd77e 100644 --- a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_RM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -36,7 +36,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -59,7 +59,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,4 +94,4 @@ TEST_F(DECODER_TEST, OR_INSTR_R_RM_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp index a15d590f..14709d67 100644 --- a/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -19,7 +19,7 @@ TEST_F(DECODER_TEST, OR_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -32,7 +32,7 @@ TEST_F(DECODER_TEST, OR_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -45,7 +45,7 @@ TEST_F(DECODER_TEST, OR_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -58,7 +58,7 @@ TEST_F(DECODER_TEST, OR_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -71,7 +71,7 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -84,7 +84,7 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -97,7 +97,7 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -110,7 +110,7 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -123,7 +123,7 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -136,7 +136,7 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -149,7 +149,7 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -162,7 +162,7 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -175,7 +175,7 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -188,7 +188,7 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -201,7 +201,7 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -214,7 +214,7 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -227,7 +227,7 @@ TEST_F(DECODER_TEST, OR_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -240,7 +240,7 @@ TEST_F(DECODER_TEST, OR_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -253,7 +253,7 @@ TEST_F(DECODER_TEST, OR_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -266,6 +266,6 @@ TEST_F(DECODER_TEST, OR_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_IMM.cpp index fc22a6ba..72108d19 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_IMM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B64) { memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(data, 0x5555555555555555); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_R.cpp index b7f61219..5a5a2b3c 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -57,7 +57,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -80,7 +80,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -92,4 +92,4 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp index 3e467e1d..cfff7dda 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -19,7 +19,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -32,7 +32,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -45,7 +45,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -58,7 +58,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -71,7 +71,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -84,7 +84,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -97,7 +97,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -110,7 +110,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -123,7 +123,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -136,7 +136,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -149,7 +149,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -162,7 +162,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -175,7 +175,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -188,7 +188,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -201,7 +201,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -214,7 +214,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -227,7 +227,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -240,7 +240,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -253,7 +253,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -266,7 +266,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -279,7 +279,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -292,7 +292,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -305,7 +305,7 @@ TEST_F(DECODER_TEST, SHFL_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -318,6 +318,6 @@ TEST_F(DECODER_TEST, SHFL_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_IMM.cpp index 5a4dea2d..b178c2cc 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_IMM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B64) { memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(data, 0x5555555555555555); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_R.cpp index 8acdf295..b5f73a5a 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -57,7 +57,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -80,7 +80,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -92,4 +92,4 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp index 4214a15f..393a3cf9 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -19,7 +19,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -32,7 +32,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -45,7 +45,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -58,7 +58,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -71,7 +71,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -84,7 +84,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -97,7 +97,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -110,7 +110,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -123,7 +123,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -136,7 +136,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -149,7 +149,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -162,7 +162,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -175,7 +175,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -188,7 +188,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -201,7 +201,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -214,7 +214,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -227,7 +227,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -240,7 +240,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -253,7 +253,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -266,7 +266,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -279,7 +279,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -292,7 +292,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -305,7 +305,7 @@ TEST_F(DECODER_TEST, SHFR_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -318,6 +318,8 @@ TEST_F(DECODER_TEST, SHFR_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} +sting::ExitedWithCode(1), "Invalid opcode!"); +} diff --git a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_IMM.cpp index afd3ff85..a9747cb5 100644 --- a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_IMM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HyperCPU::Registers reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HyperCPU::Registers reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HyperCPU::Registers reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B64) { memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(data, 0x5555555555555555); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_M.cpp index b0e4247b..12e51e1f 100644 --- a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_M.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -37,7 +37,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -61,7 +61,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -85,7 +85,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HyperCPU::Registers reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -98,4 +98,4 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_M_B64) { memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(mem_ptr, MEM_PTR); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_R.cpp index cc81b32a..58d8320c 100644 --- a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_R.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -11,7 +11,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,7 +34,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -57,7 +57,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -80,7 +80,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -92,4 +92,4 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_R_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_RM.cpp index 3d9105f1..3f2952cf 100644 --- a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_RM.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -13,7 +13,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -36,7 +36,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -59,7 +59,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -82,7 +82,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HyperCPU::Registers reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,4 +94,4 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_RM_B64) { memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp index c12c1a57..d33f52ed 100644 --- a/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -19,7 +19,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -32,7 +32,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -45,7 +45,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -58,7 +58,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -71,7 +71,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -84,7 +84,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -97,7 +97,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -110,7 +110,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -123,7 +123,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -136,7 +136,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -149,7 +149,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -162,7 +162,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -175,7 +175,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -188,7 +188,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -201,7 +201,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -214,7 +214,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -227,7 +227,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -240,7 +240,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -253,7 +253,7 @@ TEST_F(DECODER_TEST, SUB_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -266,6 +266,6 @@ TEST_F(DECODER_TEST, SUB_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp b/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp index 1831f660..b7f756c7 100644 --- a/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp +++ b/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp @@ -1,4 +1,4 @@ -#include +#include "pch.hpp" #include @@ -229,4 +229,4 @@ TEST_F(MC_ST_NEARFAILTEST, READ64) { ASSERT_EXIT({mcmt.Read64(counter); exit(0); }, ::testing::ExitedWithCode(0), ""); counter = 1017; HCPU_ASSERT_EXIT({mcmt.Read64(counter); exit(0); }, ::testing::KilledBySignal(SIGABRT), ""); -} \ No newline at end of file +} diff --git a/tests/main.cpp b/tests/main.cpp index 836659c0..7031334c 100644 --- a/tests/main.cpp +++ b/tests/main.cpp @@ -1,5 +1,5 @@ #include -#include +#include "pch.hpp" int main(int argc, char **argv) { ::testing::InitGoogleTest(&argc, argv); From c96ebba9c1e3b8965540cb60b25b30bb3b149b9b Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sat, 3 May 2025 03:40:33 +0300 Subject: [PATCH 04/40] some more mods --- src/BUILD.bazel | 0 src/BacktraceProvider/BUILD.bazel | 6 +---- src/BacktraceProvider/BacktraceProvider.cpp | 7 +++--- src/BacktraceProvider/BacktraceProvider.hpp | 5 +++- src/BacktraceProvider/CMakeLists.txt | 9 +++---- src/CMakeLists.txt | 27 +++------------------ src/Common/BUILD.bazel | 3 ++- src/PCH/CMakeLists.txt | 3 +++ src/Pog/CMakeLists.txt | 10 ++++++++ 9 files changed, 29 insertions(+), 41 deletions(-) create mode 100644 src/BUILD.bazel create mode 100644 src/PCH/CMakeLists.txt create mode 100644 src/Pog/CMakeLists.txt diff --git a/src/BUILD.bazel b/src/BUILD.bazel new file mode 100644 index 00000000..e69de29b diff --git a/src/BacktraceProvider/BUILD.bazel b/src/BacktraceProvider/BUILD.bazel index 9f197f01..dfdd6da6 100644 --- a/src/BacktraceProvider/BUILD.bazel +++ b/src/BacktraceProvider/BUILD.bazel @@ -11,12 +11,8 @@ cc_library( ], deps = [ '@fmt//:fmt', - '@argparse//:argparse', - '@eternal//:eternal', - '//src/Pog:pog', - '//src:pch', + '//src/PCH:pch_cstd', '@libbacktrace//:libbacktrace', '@libunwind//:libunwind', - '//src:include_proxy' ] ) diff --git a/src/BacktraceProvider/BacktraceProvider.cpp b/src/BacktraceProvider/BacktraceProvider.cpp index 6c1e545a..4e16d75c 100644 --- a/src/BacktraceProvider/BacktraceProvider.cpp +++ b/src/BacktraceProvider/BacktraceProvider.cpp @@ -1,15 +1,14 @@ #ifdef HCPU_ENABLE_LIBUNWIND #define UNW_LOCAL_ONLY -#include "pch.hpp" +#include #include #include -#include +#include "src/PCH/CStd.hpp" +#include "src/BacktraceProvider/BacktraceProvider.hpp" -#include -#include extern "C" { void SignalHandler(int signal) { diff --git a/src/BacktraceProvider/BacktraceProvider.hpp b/src/BacktraceProvider/BacktraceProvider.hpp index eff12a7b..5d7f3abb 100644 --- a/src/BacktraceProvider/BacktraceProvider.hpp +++ b/src/BacktraceProvider/BacktraceProvider.hpp @@ -1,9 +1,12 @@ +#pragma once + #ifdef HCPU_ENABLE_LIBUNWIND -#include "pch.hpp" #include #include +#include "src/PCH/CStd.hpp" + extern "C" { void bt_create_error_callback(void*, const char* msg, int err); } diff --git a/src/BacktraceProvider/CMakeLists.txt b/src/BacktraceProvider/CMakeLists.txt index 1b2ddd51..16b426a0 100644 --- a/src/BacktraceProvider/CMakeLists.txt +++ b/src/BacktraceProvider/CMakeLists.txt @@ -10,15 +10,12 @@ add_library( target_include_directories( backtrace-provider PUBLIC - ${CMAKE_SOURCE_DIR}/src + ${CMAKE_SOURCE_DIR} ) target_link_libraries( backtrace-provider PUBLIC fmt::fmt - argparse::argparse - pog - eternal::eternal hcpu_unwind - pch -) \ No newline at end of file + pch_cstd +) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index b3c64431..58711a9a 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,27 +1,6 @@ -# TODO: refactor dependencies for each target, there is something useless there for sure -# TODO: refactor all includes relevant to CMAKE_SOURCE_DIR, like #include - -add_library( - pch - INTERFACE - "pch.hpp" -) -target_precompile_headers(pch INTERFACE "pch.hpp") - -add_library( - pog - INTERFACE - Pog/Pog.hpp -) -target_precompile_headers(pog INTERFACE Pog/Pog.hpp) - -target_include_directories( - pog - INTERFACE - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_CURRENT_SOURCE_DIR}/Pog -) - +add_subdirectory(Pog) +add_subdirectory(PCH) +add_subdirectory(Common) add_subdirectory(Emulator) add_subdirectory(Assembler) add_subdirectory(BacktraceProvider) diff --git a/src/Common/BUILD.bazel b/src/Common/BUILD.bazel index b17b6584..eee8b63a 100644 --- a/src/Common/BUILD.bazel +++ b/src/Common/BUILD.bazel @@ -6,6 +6,7 @@ cc_library( srcs = glob(['**/*.cpp'], allow_empty = True), hdrs = glob(['**/*.hpp']), deps = [ - '@plog//:plog' + '@plog//:plog', + '//src/PCH:pch_cstd' ] ) diff --git a/src/PCH/CMakeLists.txt b/src/PCH/CMakeLists.txt new file mode 100644 index 00000000..18ad23bb --- /dev/null +++ b/src/PCH/CMakeLists.txt @@ -0,0 +1,3 @@ +add_library(pch INTERFACE "CStd.hpp") + +target_precompile_headers(pch INTERFACE "CStd.hpp") diff --git a/src/Pog/CMakeLists.txt b/src/Pog/CMakeLists.txt new file mode 100644 index 00000000..c85beb97 --- /dev/null +++ b/src/Pog/CMakeLists.txt @@ -0,0 +1,10 @@ +add_library( + pog + INTERFACE + # add other headers + Pog/Pog.hpp +) + +target_precompile_headers(pog INTERFACE Pog/Pog.hpp) + +target_include_directories(pog INTERFACE ${CMAKE_SOURCE_DIR}) From 3713ec4802c262722059c067cede1621b6ad7085 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sat, 3 May 2025 15:22:15 +0300 Subject: [PATCH 05/40] pog is being refactored --- .gitignore | 1 + .gitmodules | 3 -- conandata.yml | 4 +- dist/BUILD.bazel | 12 +++++ dist/CMakeLists.txt | 6 ++- src/Assembler/BUILD.bazel | 56 +++++++++++------------- src/Assembler/Core/BinaryTransformer.cpp | 15 +++---- src/Assembler/Core/BinaryTransformer.hpp | 7 ++- src/Assembler/Core/Compiler.cpp | 14 +++--- src/Assembler/Core/Compiler.hpp | 14 +++--- src/CMakeLists.txt | 2 + src/Emulator/BUILD.bazel | 20 +++------ src/Emulator/CMakeLists.txt | 19 ++++---- src/PCH/CMakeLists.txt | 5 ++- src/Pog/Action.hpp | 5 +-- src/Pog/Automaton.hpp | 6 +-- src/Pog/BUILD.bazel | 10 +---- src/Pog/CMakeLists.txt | 43 +++++++++++++++--- src/Pog/Errors.hpp | 4 +- src/Pog/Grammar.hpp | 10 ++--- src/Pog/HTMLReport.hpp | 2 +- src/Pog/Item.hpp | 5 +-- src/Pog/Operations/Follow.hpp | 10 ++--- src/Pog/Operations/Lookahead.hpp | 8 ++-- src/Pog/Operations/Operation.hpp | 4 +- src/Pog/Operations/Read.hpp | 4 +- src/Pog/Parser.hpp | 36 +++++++-------- src/Pog/ParserReport.hpp | 4 +- src/Pog/ParsingTable.hpp | 19 ++++---- src/Pog/Pog.hpp | 4 +- src/Pog/Relations/Includes.hpp | 4 +- src/Pog/Relations/Lookback.hpp | 6 +-- src/Pog/Relations/Relation.hpp | 4 +- src/Pog/Rule.hpp | 5 +-- src/Pog/RuleBuilder.hpp | 4 +- src/Pog/State.hpp | 10 ++--- src/Pog/Symbol.hpp | 4 +- src/Pog/Token.hpp | 2 +- src/Pog/TokenBuilder.hpp | 6 +-- src/Pog/Tokenizer.hpp | 8 ++-- src/Pog/Types/StateAndRule.hpp | 4 +- src/Pog/Types/StateAndSymbol.hpp | 4 +- 42 files changed, 208 insertions(+), 205 deletions(-) create mode 100644 dist/BUILD.bazel diff --git a/.gitignore b/.gitignore index a60a8090..6b436743 100644 --- a/.gitignore +++ b/.gitignore @@ -90,6 +90,7 @@ CMakeUserPresets* # Distribution packages dist/* +!dist/BUILD.bazel !dist/CMakeLists.txt # Bazel stuff diff --git a/.gitmodules b/.gitmodules index 14ab5e2b..62e35b98 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,6 +1,3 @@ [submodule "dist/HPool"] path = dist/HPool url = https://github.com/randommfs/HPool -[submodule "dist/libunwind"] - path = dist/libunwind - url = https://github.com/libunwind/libunwind diff --git a/conandata.yml b/conandata.yml index 559b003a..265d7f8a 100644 --- a/conandata.yml +++ b/conandata.yml @@ -11,7 +11,7 @@ requirements: argparse: "3.2" eternal: "1.0.1" re2: "20230801" - fmt: "11.1.4" + fmt: "11.0.2" libunwind: "1.8.1" boost: "1.87.0" - plog: "1.1.10" + spdlog: "1.15.0" diff --git a/dist/BUILD.bazel b/dist/BUILD.bazel new file mode 100644 index 00000000..683bf0e4 --- /dev/null +++ b/dist/BUILD.bazel @@ -0,0 +1,12 @@ +load("@rules_foreign_cc//foreign_cc:defs.bzl", "cmake") + +cmake( + name = 'hpool', + cache_entries = { + 'HPOOL_BUILD_TESTS': False, + 'HPOOL_BUILD_BENCHMARKS': False + }, + includes = [ + '.' + ] +) diff --git a/dist/CMakeLists.txt b/dist/CMakeLists.txt index b765f1c9..756d643c 100644 --- a/dist/CMakeLists.txt +++ b/dist/CMakeLists.txt @@ -1,6 +1,8 @@ -cmake_minimum_required(VERSION 3.25) +cmake_minimum_required(VERSION 3.22) # hpool set(HPOOL_BUILD_TESTS OFF CACHE BOOL "Whether to include test target into configuration" FORCE) set(HPOOL_BUILD_BENCHMARKS OFF CACHE BOOL "Whether to include benchmark target into configuration" FORCE) -add_subdirectory(HPool) \ No newline at end of file +add_subdirectory(HPool) + +add_library(dist::hpool ALIAS hpool) diff --git a/src/Assembler/BUILD.bazel b/src/Assembler/BUILD.bazel index 2e373e61..fc10da8a 100644 --- a/src/Assembler/BUILD.bazel +++ b/src/Assembler/BUILD.bazel @@ -1,34 +1,28 @@ -load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') +# load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') +# package( +# default_visibility = [ +# "//src/Emulator:__package__", +# ], +# ) -package( - default_visibility = [ - "//:__subpackages__", - ], -) +# cc_library( +# name = 'assembler_core', +# srcs = glob(['**/*.cpp'], exclude = ['Main']), +# hdrs = glob(['**/*.hpp'], exclude = ['Main']), +# deps = [ +# '@fmt//:fmt', +# '@eternal//:eternal', +# '@re2//:re2', +# '//src/PCH:pch_cstd', +# '//src/Pog:pog' +# ] +# ) - -cc_library( - name = 'assembler_core', - srcs = glob(['**/*.cpp'], exclude = ['Main']), - hdrs = glob(['**/*.hpp'], exclude = ['Main']), - deps = [ - '@fmt//:fmt', - '@argparse//:argparse', - '@eternal//:eternal', - '@re2//:re2', - '//src:pch', - '//src/Pog:pog', - '//src:include_proxy' - ] -) - - -cc_binary( - name = 'hcasm', - srcs = glob(['Main/**/*.cpp']), - deps = [ - ':assembler_core', - '//src:include_proxy' - ] -) +# cc_binary( +# name = 'hcasm', +# srcs = glob(['Main/**/*.cpp']), +# deps = [ +# ':assembler_core', +# ] +# ) diff --git a/src/Assembler/Core/BinaryTransformer.cpp b/src/Assembler/Core/BinaryTransformer.cpp index 4bfc1b71..4593e1bf 100644 --- a/src/Assembler/Core/BinaryTransformer.cpp +++ b/src/Assembler/Core/BinaryTransformer.cpp @@ -1,12 +1,9 @@ -#include -#include "pch.hpp" - -#include "Emulator/Core/CPU/Instructions/Opcodes.hpp" -#include "Emulator/Core/CPU/Instructions/Flags.hpp" -#include "Assembler/Core/BinaryTransformer.hpp" -#include "Assembler/Core/Compiler.hpp" -#include "Logger/Logger.hpp" -#include "Exit.hpp" +#include "src/Pog/Pog.hpp" +#include "src/PCH/CStd.hpp" +#include "src/Common/LanguageSpec/Opcodes.hpp" +#include "src/Common/LanguageSpec/Flags.hpp" +#include "src/Assembler/Core/BinaryTransformer.hpp" +#include "src/Assembler/Core/Compiler.hpp" HyperCPU::OperandTypes HCAsm::BinaryTransformer::DetermineOperandTypes(Operand& op1, Operand& op2) { diff --git a/src/Assembler/Core/BinaryTransformer.hpp b/src/Assembler/Core/BinaryTransformer.hpp index f287c225..0378a050 100644 --- a/src/Assembler/Core/BinaryTransformer.hpp +++ b/src/Assembler/Core/BinaryTransformer.hpp @@ -1,9 +1,8 @@ #pragma once -#include "pch.hpp" - -#include -#include +#include "src/PCH/CStd.hpp" +#include "src/Common/LanguageSpec/Flags.hpp" +#include "src/Assembler/Core/Compiler.hpp" namespace HCAsm { diff --git a/src/Assembler/Core/Compiler.cpp b/src/Assembler/Core/Compiler.cpp index 484fdd92..e3d00b53 100644 --- a/src/Assembler/Core/Compiler.cpp +++ b/src/Assembler/Core/Compiler.cpp @@ -1,12 +1,8 @@ -#include -#include "pch.hpp" - -#include -#include -#include -#include -#include -#include +#include "src/Pog/Pog.hpp" +#include "src/PCH/CStd.hpp" +#include "src/Common/LanguageSpec/Flags.hpp" +#include "src/Assembler/Core/BinaryTransformer.hpp" +#include "src/Assembler/Core/Compiler.hpp" using HyperCPU::LogLevel; diff --git a/src/Assembler/Core/Compiler.hpp b/src/Assembler/Core/Compiler.hpp index 65f213fb..ecaed5d7 100644 --- a/src/Assembler/Core/Compiler.hpp +++ b/src/Assembler/Core/Compiler.hpp @@ -1,16 +1,12 @@ #pragma once -#include -#include "pch.hpp" - -#include -#include -#include -#include -#include - #include +#include "src/Pog/Pog.hpp" +#include "src/PCH/CStd.hpp" +#include "src/Common/LanguageSpec/Opcodes.hpp" +#include "src/Common/LanguageSpec/Flags.hpp" + namespace HCAsm { enum class ValueType { diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 58711a9a..9a2d95b7 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,3 +1,5 @@ +cmake_minimum_required(VERSION 3.22) + add_subdirectory(Pog) add_subdirectory(PCH) add_subdirectory(Common) diff --git a/src/Emulator/BUILD.bazel b/src/Emulator/BUILD.bazel index 9eb742d1..6ac7773a 100644 --- a/src/Emulator/BUILD.bazel +++ b/src/Emulator/BUILD.bazel @@ -1,35 +1,25 @@ -# load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') - +load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') # cc_library( # name = 'emulator_core', # srcs = glob(['**/*.cpp']), # hdrs = glob(['**/*.hpp']), -# copts = [ -# '-Isrc/', -# '-Isrc/Assembler/', -# '-Isrc/Emulator/' -# ], # deps = [ # '@fmt//:fmt', # '@argparse//:argparse', # '@eternal//:eternal', # '//src/Assembler:assembler_core', -# '//src:pch', -# '//src/Pog:pog', -# '//src/Logger:logger', -# '//src:include_proxy' +# '//src/PCH:pch_cstd', +# '//src/Pog:pog' # ] # ) - # cc_binary( # name = 'hcemul', # srcs = glob(['**/*.cpp']), # deps = [ # ':emulator_core', -# '//src:pch', -# '//src/Pog:pog', -# '//src:include_proxy' +# '//src/PCH:pch_cstd', +# '//src/Pog:pog' # ] # ) diff --git a/src/Emulator/CMakeLists.txt b/src/Emulator/CMakeLists.txt index f194c8d4..88d7e7ab 100644 --- a/src/Emulator/CMakeLists.txt +++ b/src/Emulator/CMakeLists.txt @@ -1,8 +1,8 @@ -cmake_minimum_required(VERSION 3.25) +cmake_minimum_required(VERSION 3.22) add_library( - emulator-core + hcpu::emulator-core STATIC Core/CPU/Instructions/AllowedFlags.cpp Core/CPU/Interrupts/InterruptHandler.cpp @@ -70,28 +70,29 @@ add_library( ) target_include_directories( - emulator-core + hcpu::emulator-core PUBLIC ${CMAKE_SOURCE_DIR}/src ${CMAKE_CURRENT_SOURCE_DIR} ) target_link_libraries( - emulator-core + hcpu::emulator-core PUBLIC + hcpu::pog + hcpu::pch + dist::hpool fmt::fmt argparse::argparse - pog eternal::eternal - pch - hpool ) add_executable( - hcemul + hcpu::hcemul Main/Main.hpp Main/Main.cpp Main/ExceptionHandling.cpp Main/ExceptionHandling.hpp ) -target_link_libraries(hcemul PRIVATE emulator-core) \ No newline at end of file + +target_link_libraries(hcpu::hcemul PRIVATE hcpu::emulator-core) diff --git a/src/PCH/CMakeLists.txt b/src/PCH/CMakeLists.txt index 18ad23bb..17708bff 100644 --- a/src/PCH/CMakeLists.txt +++ b/src/PCH/CMakeLists.txt @@ -1,3 +1,4 @@ -add_library(pch INTERFACE "CStd.hpp") +cmake_minimum_required(VERSION 3.22) -target_precompile_headers(pch INTERFACE "CStd.hpp") +add_library(hcpu::pch INTERFACE "CStd.hpp") +target_precompile_headers(hcpu::pch INTERFACE "CStd.hpp") diff --git a/src/Pog/Action.hpp b/src/Pog/Action.hpp index 26ba034a..6b8901ef 100644 --- a/src/Pog/Action.hpp +++ b/src/Pog/Action.hpp @@ -1,10 +1,9 @@ #pragma once -#include #include -#include -#include +#include "src/Pog/State.hpp" +#include "src/Pog/Rule.hpp" namespace pog { diff --git a/src/Pog/Automaton.hpp b/src/Pog/Automaton.hpp index 731129c5..4dc404e4 100644 --- a/src/Pog/Automaton.hpp +++ b/src/Pog/Automaton.hpp @@ -6,9 +6,9 @@ #include -#include -#include -#include +#include "src/Pog/Types/StateAndSymbol.hpp" +#include "src/Pog/Grammar.hpp" +#include "src/Pog/State.hpp" namespace pog { diff --git a/src/Pog/BUILD.bazel b/src/Pog/BUILD.bazel index f9cb3c94..93b1be17 100644 --- a/src/Pog/BUILD.bazel +++ b/src/Pog/BUILD.bazel @@ -1,25 +1,17 @@ load('@rules_cc//cc:defs.bzl', 'cc_library') load('//tools/bazel:pch.bzl', 'precompiled_headers') - package( default_visibility = [ "//:__subpackages__", ], ) - cc_library( name = 'pog_core', - hdrs = glob(['**/*.hpp'], exclude = ['Pog.hpp']), - include_prefix = 'src', - includes = [ - # should remove in the future, all includes must be relative to src/ - '.' - ] + hdrs = glob(['**/*.hpp'], exclude = ['Pog.hpp']) ) - precompiled_headers( name = 'pog', main = 'Pog.hpp', diff --git a/src/Pog/CMakeLists.txt b/src/Pog/CMakeLists.txt index c85beb97..6047f3a6 100644 --- a/src/Pog/CMakeLists.txt +++ b/src/Pog/CMakeLists.txt @@ -1,10 +1,41 @@ +cmake_minimum_required(VERSION 3.22) + add_library( - pog + hcpu::pog INTERFACE - # add other headers - Pog/Pog.hpp + Pog.hpp + Action.hpp + Automaton.hpp + DigraphAlgo.hpp + Errors.hpp + FilterView.hpp + Grammar.hpp + HTMLReport.hpp + Item.hpp + LineSpecialization.hpp + Operations/Follow.hpp + Operations/Lookahead.hpp + Operations/Operation.hpp + Operations/Read.hpp + Parser.hpp + ParserReport.hpp + ParsingTable.hpp + Pog.hpp + Precedence.hpp + Relations/Includes.hpp + Relations/Lookback.hpp + Relations/Relation.hpp + RuleBuilder.hpp + Rule.hpp + State.hpp + Symbol.hpp + TokenBuilder.hpp + Token.hpp + Tokenizer.hpp + Types/StateAndRule.hpp + Types/StateAndSymbol.hpp + Utils.hpp ) -target_precompile_headers(pog INTERFACE Pog/Pog.hpp) - -target_include_directories(pog INTERFACE ${CMAKE_SOURCE_DIR}) +target_precompile_headers(hcpu::pog INTERFACE Pog.hpp) +target_include_directories(hcpu::pog INTERFACE ${CMAKE_SOURCE_DIR}) diff --git a/src/Pog/Errors.hpp b/src/Pog/Errors.hpp index 5b517005..fbe5fdea 100644 --- a/src/Pog/Errors.hpp +++ b/src/Pog/Errors.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -7,8 +8,7 @@ #include #include -#include -#include +#include "src/Pog/Symbol.hpp" namespace pog { diff --git a/src/Pog/Grammar.hpp b/src/Pog/Grammar.hpp index 6cdc4a54..eb406458 100644 --- a/src/Pog/Grammar.hpp +++ b/src/Pog/Grammar.hpp @@ -4,11 +4,11 @@ #include #include -#include -#include -#include -#include -#include +#include "src/Pog/LineSpecialization.hpp" +#include "src/Pog/Rule.hpp" +#include "src/Pog/Symbol.hpp" +#include "src/Pog/Token.hpp" +#include "src/Pog/Utils.hpp" namespace pog { diff --git a/src/Pog/HTMLReport.hpp b/src/Pog/HTMLReport.hpp index fc2edd40..921988d2 100644 --- a/src/Pog/HTMLReport.hpp +++ b/src/Pog/HTMLReport.hpp @@ -2,7 +2,7 @@ #include -#include +#include "src/Pog/Parser.hpp" namespace pog { diff --git a/src/Pog/Item.hpp b/src/Pog/Item.hpp index 3d860010..91b16bc7 100644 --- a/src/Pog/Item.hpp +++ b/src/Pog/Item.hpp @@ -1,13 +1,10 @@ #pragma once #include -#include -#include #include -#include -#include +#include "src/Pog/Rule.hpp" namespace pog { diff --git a/src/Pog/Operations/Follow.hpp b/src/Pog/Operations/Follow.hpp index 34dd6bc2..b3cd6dae 100644 --- a/src/Pog/Operations/Follow.hpp +++ b/src/Pog/Operations/Follow.hpp @@ -1,10 +1,10 @@ #pragma once -#include -#include -#include -#include -#include +#include "src/Pog/Types/StateAndSymbol.hpp" +#include "src/Pog/Operations/Operation.hpp" +#include "src/Pog/Relations/Includes.hpp" +#include "src/Pog/Operations/Read.hpp" +#include "src/Pog/DigraphAlgo.hpp" namespace pog { diff --git a/src/Pog/Operations/Lookahead.hpp b/src/Pog/Operations/Lookahead.hpp index 4de7c0fc..169c1cbc 100644 --- a/src/Pog/Operations/Lookahead.hpp +++ b/src/Pog/Operations/Lookahead.hpp @@ -1,9 +1,9 @@ #pragma once -#include -#include -#include -#include +#include "src/Pog/Operations/Operation.hpp" +#include "src/Pog/Types/StateAndRule.hpp" +#include "src/Pog/Relations/Lookback.hpp" +#include "src/Pog/Operations/Follow.hpp" namespace pog { diff --git a/src/Pog/Operations/Operation.hpp b/src/Pog/Operations/Operation.hpp index c4f323ab..0a8603e2 100644 --- a/src/Pog/Operations/Operation.hpp +++ b/src/Pog/Operations/Operation.hpp @@ -3,8 +3,8 @@ #include #include -#include -#include +#include "src/Pog/Automaton.hpp" +#include "src/Pog/Grammar.hpp" namespace pog { diff --git a/src/Pog/Operations/Read.hpp b/src/Pog/Operations/Read.hpp index dfb8c610..cfcf55d4 100644 --- a/src/Pog/Operations/Read.hpp +++ b/src/Pog/Operations/Read.hpp @@ -1,7 +1,7 @@ #pragma once -#include -#include +#include "src/Pog/Operations/Operation.hpp" +#include "src/Pog/Types/StateAndSymbol.hpp" namespace pog { diff --git a/src/Pog/Parser.hpp b/src/Pog/Parser.hpp index 2a7243e2..021ffb17 100644 --- a/src/Pog/Parser.hpp +++ b/src/Pog/Parser.hpp @@ -15,24 +15,24 @@ #define debug_parser(...) #endif -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include +#include "src/Pog/LineSpecialization.hpp" +#include "src/Pog/ParserReport.hpp" +#include "src/Pog/ParsingTable.hpp" +#include "src/Pog/TokenBuilder.hpp" +#include "src/Pog/RuleBuilder.hpp" +#include "src/Pog/Automaton.hpp" +#include "src/Pog/Tokenizer.hpp" +#include "src/Pog/Grammar.hpp" +#include "src/Pog/Action.hpp" +#include "src/Pog/Errors.hpp" +#include "src/Pog/Symbol.hpp" +#include "src/Pog/State.hpp" + +#include "src/Pog/Operations/Lookahead.hpp" +#include "src/Pog/Operations/Follow.hpp" +#include "src/Pog/Operations/Read.hpp" +#include "src/Pog/Relations/Includes.hpp" +#include "src/Pog/Relations/Lookback.hpp" namespace HCAsm { diff --git a/src/Pog/ParserReport.hpp b/src/Pog/ParserReport.hpp index ebe8fa98..af866d1d 100644 --- a/src/Pog/ParserReport.hpp +++ b/src/Pog/ParserReport.hpp @@ -5,8 +5,8 @@ #include -#include -#include +#include "src/Pog/State.hpp" +#include "src/Pog/Rule.hpp" namespace pog { diff --git a/src/Pog/ParsingTable.hpp b/src/Pog/ParsingTable.hpp index 8abc1fc0..abe4d977 100644 --- a/src/Pog/ParsingTable.hpp +++ b/src/Pog/ParsingTable.hpp @@ -2,16 +2,15 @@ #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "src/Pog/Operations/Lookahead.hpp" +#include "src/Pog/Types/StateAndSymbol.hpp" +#include "src/Pog/Types/StateAndRule.hpp" +#include "src/Pog/ParserReport.hpp" +#include "src/Pog/Automaton.hpp" +#include "src/Pog/Grammar.hpp" +#include "src/Pog/Action.hpp" +#include "src/Pog/Symbol.hpp" +#include "src/Pog/State.hpp" namespace pog { diff --git a/src/Pog/Pog.hpp b/src/Pog/Pog.hpp index 3651c84d..1dba6a1c 100644 --- a/src/Pog/Pog.hpp +++ b/src/Pog/Pog.hpp @@ -2,5 +2,5 @@ #define POG_VERSION "0.5.3" -#include -#include +#include "src/Pog/HTMLReport.hpp" +#include "src/Pog/Parser.hpp" diff --git a/src/Pog/Relations/Includes.hpp b/src/Pog/Relations/Includes.hpp index 191b2db2..e5445741 100644 --- a/src/Pog/Relations/Includes.hpp +++ b/src/Pog/Relations/Includes.hpp @@ -4,8 +4,8 @@ #include -#include -#include +#include "src/Pog/Types/StateAndSymbol.hpp" +#include "src/Pog/Relations/Relation.hpp" namespace pog { diff --git a/src/Pog/Relations/Lookback.hpp b/src/Pog/Relations/Lookback.hpp index 925edc01..02ee4d1c 100644 --- a/src/Pog/Relations/Lookback.hpp +++ b/src/Pog/Relations/Lookback.hpp @@ -2,9 +2,9 @@ #include -#include -#include -#include +#include "src/Pog/Types/StateAndSymbol.hpp" +#include "src/Pog/Relations/Relation.hpp" +#include "src/Pog/Types/StateAndRule.hpp" namespace pog { diff --git a/src/Pog/Relations/Relation.hpp b/src/Pog/Relations/Relation.hpp index d4313b5c..8b73d489 100644 --- a/src/Pog/Relations/Relation.hpp +++ b/src/Pog/Relations/Relation.hpp @@ -3,8 +3,8 @@ #include #include -#include -#include +#include "src/Pog/Automaton.hpp" +#include "src/Pog/Grammar.hpp" namespace pog { diff --git a/src/Pog/Rule.hpp b/src/Pog/Rule.hpp index 01fe7f9c..1e900844 100644 --- a/src/Pog/Rule.hpp +++ b/src/Pog/Rule.hpp @@ -9,9 +9,8 @@ #include #include -#include -#include -#include +#include "src/Pog/LineSpecialization.hpp" +#include "src/Pog/Symbol.hpp" namespace pog { diff --git a/src/Pog/RuleBuilder.hpp b/src/Pog/RuleBuilder.hpp index 813d953b..3e8b6283 100644 --- a/src/Pog/RuleBuilder.hpp +++ b/src/Pog/RuleBuilder.hpp @@ -1,7 +1,7 @@ #pragma once -#include -#include +#include "src/Pog/Grammar.hpp" +#include "src/Pog/Rule.hpp" namespace pog { diff --git a/src/Pog/State.hpp b/src/Pog/State.hpp index ad9ba829..1e18ff7b 100644 --- a/src/Pog/State.hpp +++ b/src/Pog/State.hpp @@ -1,11 +1,11 @@ #pragma once -#include -#include +#include +#include -#include -#include -#include +#include "src/Pog/FilterView.hpp" +#include "src/Pog/Utils.hpp" +#include "src/Pog/Item.hpp" namespace pog { diff --git a/src/Pog/Symbol.hpp b/src/Pog/Symbol.hpp index 3f913902..f3938ce0 100644 --- a/src/Pog/Symbol.hpp +++ b/src/Pog/Symbol.hpp @@ -1,11 +1,9 @@ #pragma once -#include #include #include -#include -#include +#include "src/Pog/Precedence.hpp" namespace pog { diff --git a/src/Pog/Token.hpp b/src/Pog/Token.hpp index 0134d04f..f0402149 100644 --- a/src/Pog/Token.hpp +++ b/src/Pog/Token.hpp @@ -7,7 +7,7 @@ #include -#include +#include "src/Pog/Symbol.hpp" namespace pog { diff --git a/src/Pog/TokenBuilder.hpp b/src/Pog/TokenBuilder.hpp index a4c01c66..f92d397b 100644 --- a/src/Pog/TokenBuilder.hpp +++ b/src/Pog/TokenBuilder.hpp @@ -1,8 +1,8 @@ #pragma once -#include -#include -#include +#include "src/Pog/Tokenizer.hpp" +#include "src/Pog/Grammar.hpp" +#include "src/Pog/Token.hpp" namespace pog { diff --git a/src/Pog/Tokenizer.hpp b/src/Pog/Tokenizer.hpp index d61265b0..8c7dbc41 100644 --- a/src/Pog/Tokenizer.hpp +++ b/src/Pog/Tokenizer.hpp @@ -17,9 +17,9 @@ #define debug_tokenizer(...) #endif -#include -#include -#include +#include "src/Pog/LineSpecialization.hpp" +#include "src/Pog/Grammar.hpp" +#include "src/Pog/Token.hpp" namespace pog { @@ -223,7 +223,7 @@ class Tokenizer continue; return TokenMatchType { - best_match->get_symbol(), + best_match->get_symbol(), std::move(value), static_cast(longest_match), LineSpecialization { diff --git a/src/Pog/Types/StateAndRule.hpp b/src/Pog/Types/StateAndRule.hpp index 2a8cc2a2..27474e6a 100644 --- a/src/Pog/Types/StateAndRule.hpp +++ b/src/Pog/Types/StateAndRule.hpp @@ -1,7 +1,7 @@ #pragma once -#include -#include +#include "src/Pog/State.hpp" +#include "src/Pog/Rule.hpp" namespace pog { diff --git a/src/Pog/Types/StateAndSymbol.hpp b/src/Pog/Types/StateAndSymbol.hpp index 271124f6..f1f6f8b7 100644 --- a/src/Pog/Types/StateAndSymbol.hpp +++ b/src/Pog/Types/StateAndSymbol.hpp @@ -1,7 +1,7 @@ #pragma once -#include -#include +#include "src/Pog/Symbol.hpp" +#include "src/Pog/State.hpp" namespace pog { From 3327f76f6acef57d2a59f576b93cb4283e3af930 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sun, 4 May 2025 03:59:10 +0300 Subject: [PATCH 06/40] more renames --- MODULE.bazel | 2 +- src/Assembler/BUILD.bazel | 59 ++++++++++++--------- src/Assembler/CMakeLists.txt | 33 ++++++------ src/Assembler/Core/BinaryTransformer.cpp | 12 ++--- src/Assembler/Core/BinaryTransformer.hpp | 6 +-- src/Assembler/Core/Compiler.cpp | 10 ++-- src/Assembler/Core/Compiler.hpp | 8 +-- src/Assembler/Core/ModeNameAssoc.hpp | 6 +-- src/Assembler/Core/OpcodeNameAssoc.hpp | 6 +-- src/Assembler/Core/Parsers.cpp | 11 ++-- src/Assembler/Core/RegNameAssoc.hpp | 6 +-- src/Assembler/Core/StatementCompilers.cpp | 11 ++-- src/Assembler/Core/Tokenizers.cpp | 6 +-- src/Assembler/Main/Main.cpp | 20 +++---- src/Assembler/Utils/Extension.hpp | 2 +- src/BacktraceProvider/BUILD.bazel | 1 + src/BacktraceProvider/BacktraceProvider.cpp | 4 +- src/BacktraceProvider/BacktraceProvider.hpp | 2 +- src/BacktraceProvider/CMakeLists.txt | 11 ++-- src/Common/BUILD.bazel | 4 +- src/Common/CMakeLists.txt | 17 ++++++ src/Common/LanguageSpec/AllowedFlags.hpp | 2 +- src/Common/LanguageSpec/Flags.hpp | 2 +- src/Common/LanguageSpec/Opcodes.hpp | 2 +- src/Common/LanguageSpec/Registers.hpp | 2 +- src/Common/NotImplemented.hpp | 6 +-- src/PCH/BUILD.bazel | 2 +- src/PCH/CMakeLists.txt | 4 +- src/Pog/Action.hpp | 4 +- src/Pog/Automaton.hpp | 6 +-- src/Pog/BUILD.bazel | 5 +- src/Pog/CMakeLists.txt | 2 +- src/Pog/Errors.hpp | 2 +- src/Pog/Grammar.hpp | 10 ++-- src/Pog/HTMLReport.hpp | 2 +- src/Pog/Item.hpp | 2 +- src/Pog/Operations/Follow.hpp | 10 ++-- src/Pog/Operations/Lookahead.hpp | 8 +-- src/Pog/Operations/Operation.hpp | 4 +- src/Pog/Operations/Read.hpp | 4 +- src/Pog/Parser.hpp | 36 ++++++------- src/Pog/ParserReport.hpp | 4 +- src/Pog/ParsingTable.hpp | 18 +++---- src/Pog/Pog.hpp | 4 +- src/Pog/Relations/Includes.hpp | 4 +- src/Pog/Relations/Lookback.hpp | 6 +-- src/Pog/Relations/Relation.hpp | 4 +- src/Pog/Rule.hpp | 4 +- src/Pog/RuleBuilder.hpp | 4 +- src/Pog/State.hpp | 6 +-- src/Pog/Symbol.hpp | 2 +- src/Pog/Token.hpp | 2 +- src/Pog/TokenBuilder.hpp | 6 +-- src/Pog/Tokenizer.hpp | 6 +-- src/Pog/Types/StateAndRule.hpp | 4 +- src/Pog/Types/StateAndSymbol.hpp | 4 +- 56 files changed, 224 insertions(+), 206 deletions(-) create mode 100644 src/Common/CMakeLists.txt diff --git a/MODULE.bazel b/MODULE.bazel index b9a0a632..a73c70a9 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -23,7 +23,7 @@ use_repo( 're2', 'xz_utils', 'zlib', - 'plog' + 'spdlog' ) bazel_dep(name = 'rules_cc', version = '0.0.17') diff --git a/src/Assembler/BUILD.bazel b/src/Assembler/BUILD.bazel index fc10da8a..fcecfa6b 100644 --- a/src/Assembler/BUILD.bazel +++ b/src/Assembler/BUILD.bazel @@ -1,28 +1,37 @@ -# load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') +load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') -# package( -# default_visibility = [ -# "//src/Emulator:__package__", -# ], -# ) +package( + default_visibility = [ + '//src/Emulator:__pkg__', + ], +) -# cc_library( -# name = 'assembler_core', -# srcs = glob(['**/*.cpp'], exclude = ['Main']), -# hdrs = glob(['**/*.hpp'], exclude = ['Main']), -# deps = [ -# '@fmt//:fmt', -# '@eternal//:eternal', -# '@re2//:re2', -# '//src/PCH:pch_cstd', -# '//src/Pog:pog' -# ] -# ) +cc_library( + name = 'assembler_core', + srcs = glob(['**/*.cpp'], exclude = ['Main']), + hdrs = glob(['**/*.hpp'], exclude = ['Main']), + strip_include_prefix = '/src', + copts = [ + '-Isrc/' + ], + deps = [ + '//src/PCH:pch_cstd', + '//src/Pog:pog', + '@fmt//:fmt', + '@re2//:re2', + '@eternal//:eternal', + '@argparse//:argparse' + ] +) -# cc_binary( -# name = 'hcasm', -# srcs = glob(['Main/**/*.cpp']), -# deps = [ -# ':assembler_core', -# ] -# ) +cc_binary( + name = 'hcasm', + srcs = glob(['Main/**/*.cpp']), + copts = [ + '-Isrc/' + ], + deps = [ + ':assembler_core', + '@eternal//:eternal' + ] +) diff --git a/src/Assembler/CMakeLists.txt b/src/Assembler/CMakeLists.txt index cb0ab849..1f2180d1 100644 --- a/src/Assembler/CMakeLists.txt +++ b/src/Assembler/CMakeLists.txt @@ -1,8 +1,7 @@ -cmake_minimum_required(VERSION 3.25) - +cmake_minimum_required(VERSION 3.22) add_library( - assembler-core + hcpu::assembler-core STATIC Core/StatementCompilers.cpp Core/Parsers.cpp @@ -16,23 +15,21 @@ add_library( Core/Compiler.hpp Core/ModeNameAssoc.hpp ) -target_include_directories( - assembler-core - PUBLIC - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_CURRENT_SOURCE_DIR} -) + +target_include_directories(hcpu::assembler-core PUBLIC ${CMAKE_SOURCE_DIR}/src) + target_link_libraries( - assembler-core + hcpu::assembler-core PUBLIC - fmt::fmt - argparse::argparse - eternal::eternal - re2::re2 - pch - pog - hpool + fmt::fmt + argparse::argparse + eternal::eternal + re2::re2 + pch + pog + hpool ) add_executable(hcasm Main/Main.cpp) -target_link_libraries(hcasm PRIVATE assembler-core) \ No newline at end of file + +target_link_libraries(hcasm PRIVATE hcpu::assembler-core) diff --git a/src/Assembler/Core/BinaryTransformer.cpp b/src/Assembler/Core/BinaryTransformer.cpp index 4593e1bf..17d1aa63 100644 --- a/src/Assembler/Core/BinaryTransformer.cpp +++ b/src/Assembler/Core/BinaryTransformer.cpp @@ -1,9 +1,9 @@ -#include "src/Pog/Pog.hpp" -#include "src/PCH/CStd.hpp" -#include "src/Common/LanguageSpec/Opcodes.hpp" -#include "src/Common/LanguageSpec/Flags.hpp" -#include "src/Assembler/Core/BinaryTransformer.hpp" -#include "src/Assembler/Core/Compiler.hpp" +#include "Pog/Pog.hpp" +#include "PCH/CStd.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "Assembler/Core/BinaryTransformer.hpp" +#include "Assembler/Core/Compiler.hpp" HyperCPU::OperandTypes HCAsm::BinaryTransformer::DetermineOperandTypes(Operand& op1, Operand& op2) { diff --git a/src/Assembler/Core/BinaryTransformer.hpp b/src/Assembler/Core/BinaryTransformer.hpp index 0378a050..339244ff 100644 --- a/src/Assembler/Core/BinaryTransformer.hpp +++ b/src/Assembler/Core/BinaryTransformer.hpp @@ -1,8 +1,8 @@ #pragma once -#include "src/PCH/CStd.hpp" -#include "src/Common/LanguageSpec/Flags.hpp" -#include "src/Assembler/Core/Compiler.hpp" +#include "PCH/CStd.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "Assembler/Core/Compiler.hpp" namespace HCAsm { diff --git a/src/Assembler/Core/Compiler.cpp b/src/Assembler/Core/Compiler.cpp index e3d00b53..c2a58ab3 100644 --- a/src/Assembler/Core/Compiler.cpp +++ b/src/Assembler/Core/Compiler.cpp @@ -1,8 +1,8 @@ -#include "src/Pog/Pog.hpp" -#include "src/PCH/CStd.hpp" -#include "src/Common/LanguageSpec/Flags.hpp" -#include "src/Assembler/Core/BinaryTransformer.hpp" -#include "src/Assembler/Core/Compiler.hpp" +#include "Pog/Pog.hpp" +#include "PCH/CStd.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "Assembler/Core/BinaryTransformer.hpp" +#include "Assembler/Core/Compiler.hpp" using HyperCPU::LogLevel; diff --git a/src/Assembler/Core/Compiler.hpp b/src/Assembler/Core/Compiler.hpp index ecaed5d7..4c6a7d39 100644 --- a/src/Assembler/Core/Compiler.hpp +++ b/src/Assembler/Core/Compiler.hpp @@ -2,10 +2,10 @@ #include -#include "src/Pog/Pog.hpp" -#include "src/PCH/CStd.hpp" -#include "src/Common/LanguageSpec/Opcodes.hpp" -#include "src/Common/LanguageSpec/Flags.hpp" +#include "Pog/Pog.hpp" +#include "PCH/CStd.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" +#include "Common/LanguageSpec/Flags.hpp" namespace HCAsm { diff --git a/src/Assembler/Core/ModeNameAssoc.hpp b/src/Assembler/Core/ModeNameAssoc.hpp index 41b59fca..849d9a30 100644 --- a/src/Assembler/Core/ModeNameAssoc.hpp +++ b/src/Assembler/Core/ModeNameAssoc.hpp @@ -1,10 +1,10 @@ #pragma once -#include "pch.hpp" +#include -#include +#include "PCH/CStd.hpp" +#include "Assembler/Core/Compiler.hpp" -#include constexpr inline const auto mode_assoc = mapbox::eternal::hash_map({ {"b8", HCAsm::Mode::b8}, diff --git a/src/Assembler/Core/OpcodeNameAssoc.hpp b/src/Assembler/Core/OpcodeNameAssoc.hpp index 556e7ab2..7a4b0641 100644 --- a/src/Assembler/Core/OpcodeNameAssoc.hpp +++ b/src/Assembler/Core/OpcodeNameAssoc.hpp @@ -1,10 +1,10 @@ #pragma once -#include "pch.hpp" +#include -#include +#include "PCH/CStd.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" -#include constexpr inline const auto opcode_assoc = mapbox::eternal::hash_map({ {"adc", HyperCPU::Opcode::ADC}, diff --git a/src/Assembler/Core/Parsers.cpp b/src/Assembler/Core/Parsers.cpp index 9303189c..22d5e540 100644 --- a/src/Assembler/Core/Parsers.cpp +++ b/src/Assembler/Core/Parsers.cpp @@ -1,9 +1,8 @@ -#include -#include "pch.hpp" - -#include -#include -#include +#include "Pog/Pog.hpp" +#include "PCH/CStd.hpp" +#include "Assembler/Core/ModeNameAssoc.hpp" +#include "Assembler/Core/RegNameAssoc.hpp" +#include "Assembler/Core/Compiler.hpp" using HCAsm::Value; diff --git a/src/Assembler/Core/RegNameAssoc.hpp b/src/Assembler/Core/RegNameAssoc.hpp index 5175dfd4..d2ca1f93 100644 --- a/src/Assembler/Core/RegNameAssoc.hpp +++ b/src/Assembler/Core/RegNameAssoc.hpp @@ -1,10 +1,10 @@ #pragma once -#include "pch.hpp" +#include -#include +#include "PCH/CStd.hpp" +#include "Common/LanguageSpec/Registers.hpp" -#include constexpr inline const auto registers_assoc = mapbox::eternal::hash_map({ {"x0", HyperCPU::Registers::X0}, diff --git a/src/Assembler/Core/StatementCompilers.cpp b/src/Assembler/Core/StatementCompilers.cpp index 67780d80..a46788d8 100644 --- a/src/Assembler/Core/StatementCompilers.cpp +++ b/src/Assembler/Core/StatementCompilers.cpp @@ -1,9 +1,8 @@ -#include -#include "pch.hpp" - -#include -#include -#include +#include "Pog/Pog.hpp" +#include "PCH/CStd.hpp" +#include "Assembler/Core/Compiler.hpp" +#include "Assembler/Core/OpcodeNameAssoc.hpp" +#include "Assembler/Core/RegNameAssoc.hpp" using HCAsm::Value; diff --git a/src/Assembler/Core/Tokenizers.cpp b/src/Assembler/Core/Tokenizers.cpp index fd19f74e..b5073152 100644 --- a/src/Assembler/Core/Tokenizers.cpp +++ b/src/Assembler/Core/Tokenizers.cpp @@ -1,7 +1,7 @@ -#include -#include "pch.hpp" +#include "Pog/Pog.hpp" +#include "PCH/CStd.hpp" +#include "Assembler/Core/Compiler.hpp" -#include using HCAsm::Value; diff --git a/src/Assembler/Main/Main.cpp b/src/Assembler/Main/Main.cpp index 91525c45..a8e3dc40 100644 --- a/src/Assembler/Main/Main.cpp +++ b/src/Assembler/Main/Main.cpp @@ -1,19 +1,15 @@ -#include -#include "pch.hpp" - -#include -#include -#include -#include -#include -#include - +#include #include -#include +#include "Pog/Pog.hpp" +#include "PCH/CStd.hpp" +#include "Assembler/Utils/Extension.hpp" +#include "Assembler/Core/Compiler.hpp" +#include "Common/NotImplemented.hpp" + #ifdef HCPU_ENABLE_LIBUNWIND -#include +#include "BacktraceProvider/BacktraceProvider.hpp" #endif constexpr const inline auto loglevel_assoc = mapbox::eternal::map({ diff --git a/src/Assembler/Utils/Extension.hpp b/src/Assembler/Utils/Extension.hpp index 76c295bb..6494d7ce 100644 --- a/src/Assembler/Utils/Extension.hpp +++ b/src/Assembler/Utils/Extension.hpp @@ -1,6 +1,6 @@ #pragma once -#include "pch.hpp" +#include "PCH/CStd.hpp" namespace HCAsm { std::string CreateObjectFilename(std::string str); diff --git a/src/BacktraceProvider/BUILD.bazel b/src/BacktraceProvider/BUILD.bazel index dfdd6da6..ba62a0fe 100644 --- a/src/BacktraceProvider/BUILD.bazel +++ b/src/BacktraceProvider/BUILD.bazel @@ -9,6 +9,7 @@ cc_library( hdrs = [ 'BacktraceProvider.hpp' ], + strip_include_prefix = '/src', deps = [ '@fmt//:fmt', '//src/PCH:pch_cstd', diff --git a/src/BacktraceProvider/BacktraceProvider.cpp b/src/BacktraceProvider/BacktraceProvider.cpp index 4e16d75c..308a8404 100644 --- a/src/BacktraceProvider/BacktraceProvider.cpp +++ b/src/BacktraceProvider/BacktraceProvider.cpp @@ -6,8 +6,8 @@ #include #include -#include "src/PCH/CStd.hpp" -#include "src/BacktraceProvider/BacktraceProvider.hpp" +#include "PCH/CStd.hpp" +#include "BacktraceProvider/BacktraceProvider.hpp" extern "C" { diff --git a/src/BacktraceProvider/BacktraceProvider.hpp b/src/BacktraceProvider/BacktraceProvider.hpp index 5d7f3abb..2fff099b 100644 --- a/src/BacktraceProvider/BacktraceProvider.hpp +++ b/src/BacktraceProvider/BacktraceProvider.hpp @@ -5,7 +5,7 @@ #include #include -#include "src/PCH/CStd.hpp" +#include "PCH/CStd.hpp" extern "C" { void bt_create_error_callback(void*, const char* msg, int err); diff --git a/src/BacktraceProvider/CMakeLists.txt b/src/BacktraceProvider/CMakeLists.txt index 16b426a0..ab15e40e 100644 --- a/src/BacktraceProvider/CMakeLists.txt +++ b/src/BacktraceProvider/CMakeLists.txt @@ -1,19 +1,20 @@ cmake_minimum_required(VERSION 3.25) - add_library( - backtrace-provider + hcpu::backtrace-provider STATIC BacktraceProvider.cpp BacktraceProvider.hpp ) + target_include_directories( - backtrace-provider + hcpu::backtrace-provider PUBLIC - ${CMAKE_SOURCE_DIR} + ${CMAKE_SOURCE_DIR}/src ) + target_link_libraries( - backtrace-provider + hcpu::backtrace-provider PUBLIC fmt::fmt hcpu_unwind diff --git a/src/Common/BUILD.bazel b/src/Common/BUILD.bazel index eee8b63a..ce614a9f 100644 --- a/src/Common/BUILD.bazel +++ b/src/Common/BUILD.bazel @@ -1,12 +1,12 @@ load('@rules_cc//cc:defs.bzl', 'cc_library') - cc_library( name = 'hcpu_common', srcs = glob(['**/*.cpp'], allow_empty = True), hdrs = glob(['**/*.hpp']), + strip_include_prefix = '/src', deps = [ - '@plog//:plog', + '@spdlog//:spdlog', '//src/PCH:pch_cstd' ] ) diff --git a/src/Common/CMakeLists.txt b/src/Common/CMakeLists.txt new file mode 100644 index 00000000..d1267ec9 --- /dev/null +++ b/src/Common/CMakeLists.txt @@ -0,0 +1,17 @@ +cmake_minimum_required(VERSION 3.22) + + +add_library( + hcpu::common + INTERFACE + Defs.hpp + NotImplemented.hpp + LanguageSpec/AllowedFlags.hpp + LanguageSpec/Flags.hpp + LanguageSpec/Opcodes.hpp + LanguageSpec/Registers.hpp +) + +target_include_directories(hcpu::common INTERFACE ${CMAKE_SOURCE_DIR}) + +target_link_libraries(hcpu::Common INTERFACE spdlog::spdlog hcpu::pch) diff --git a/src/Common/LanguageSpec/AllowedFlags.hpp b/src/Common/LanguageSpec/AllowedFlags.hpp index c4d69795..5bf029cf 100644 --- a/src/Common/LanguageSpec/AllowedFlags.hpp +++ b/src/Common/LanguageSpec/AllowedFlags.hpp @@ -1,6 +1,6 @@ #pragma once -#include "src/PCH/CStd.hpp" +#include "PCH/CStd.hpp" namespace HyperCPU { diff --git a/src/Common/LanguageSpec/Flags.hpp b/src/Common/LanguageSpec/Flags.hpp index 1483f471..d9ec9e93 100644 --- a/src/Common/LanguageSpec/Flags.hpp +++ b/src/Common/LanguageSpec/Flags.hpp @@ -1,6 +1,6 @@ #pragma once -#include "src/PCH/CStd.hpp" +#include "PCH/CStd.hpp" namespace HyperCPU { diff --git a/src/Common/LanguageSpec/Opcodes.hpp b/src/Common/LanguageSpec/Opcodes.hpp index 8a02fd82..612e5508 100644 --- a/src/Common/LanguageSpec/Opcodes.hpp +++ b/src/Common/LanguageSpec/Opcodes.hpp @@ -1,6 +1,6 @@ #pragma once -#include "src/PCH/CStd.hpp" +#include "PCH/CStd.hpp" namespace HyperCPU { diff --git a/src/Common/LanguageSpec/Registers.hpp b/src/Common/LanguageSpec/Registers.hpp index 37287a0a..b9db1654 100644 --- a/src/Common/LanguageSpec/Registers.hpp +++ b/src/Common/LanguageSpec/Registers.hpp @@ -1,6 +1,6 @@ #pragma once -#include "src/PCH/CStd.hpp" +#include "PCH/CStd.hpp" namespace HyperCPU { diff --git a/src/Common/NotImplemented.hpp b/src/Common/NotImplemented.hpp index 240ce44b..abcf0e4d 100644 --- a/src/Common/NotImplemented.hpp +++ b/src/Common/NotImplemented.hpp @@ -1,9 +1,7 @@ #pragma once -#include - -#include "src/PCH/CStd.hpp" -#include "src/Common/Defs.hpp" +#include "PCH/CStd.hpp" +#include "Common/Defs.hpp" namespace HyperCPU { HCPU_ALWAYS_INLINE static void PrintUnsupported(std::string_view msg) { diff --git a/src/PCH/BUILD.bazel b/src/PCH/BUILD.bazel index 555530d6..bfd82cc8 100644 --- a/src/PCH/BUILD.bazel +++ b/src/PCH/BUILD.bazel @@ -2,7 +2,7 @@ load('//tools/bazel:pch.bzl', 'precompiled_headers') package( default_visibility = [ - "//:__subpackages__", + '//:__subpackages__', ], ) diff --git a/src/PCH/CMakeLists.txt b/src/PCH/CMakeLists.txt index 17708bff..d4e981a6 100644 --- a/src/PCH/CMakeLists.txt +++ b/src/PCH/CMakeLists.txt @@ -1,4 +1,4 @@ cmake_minimum_required(VERSION 3.22) -add_library(hcpu::pch INTERFACE "CStd.hpp") -target_precompile_headers(hcpu::pch INTERFACE "CStd.hpp") +add_library(hcpu::pch INTERFACE CStd.hpp) +target_precompile_headers(hcpu::pch INTERFACE CStd.hpp) diff --git a/src/Pog/Action.hpp b/src/Pog/Action.hpp index 6b8901ef..9a82a089 100644 --- a/src/Pog/Action.hpp +++ b/src/Pog/Action.hpp @@ -2,8 +2,8 @@ #include -#include "src/Pog/State.hpp" -#include "src/Pog/Rule.hpp" +#include "Pog/State.hpp" +#include "Pog/Rule.hpp" namespace pog { diff --git a/src/Pog/Automaton.hpp b/src/Pog/Automaton.hpp index 4dc404e4..ba76e51d 100644 --- a/src/Pog/Automaton.hpp +++ b/src/Pog/Automaton.hpp @@ -6,9 +6,9 @@ #include -#include "src/Pog/Types/StateAndSymbol.hpp" -#include "src/Pog/Grammar.hpp" -#include "src/Pog/State.hpp" +#include "Pog/Types/StateAndSymbol.hpp" +#include "Pog/Grammar.hpp" +#include "Pog/State.hpp" namespace pog { diff --git a/src/Pog/BUILD.bazel b/src/Pog/BUILD.bazel index 93b1be17..093f3c28 100644 --- a/src/Pog/BUILD.bazel +++ b/src/Pog/BUILD.bazel @@ -3,13 +3,14 @@ load('//tools/bazel:pch.bzl', 'precompiled_headers') package( default_visibility = [ - "//:__subpackages__", + '//:__subpackages__', ], ) cc_library( name = 'pog_core', - hdrs = glob(['**/*.hpp'], exclude = ['Pog.hpp']) + hdrs = glob(['**/*.hpp'], exclude = ['Pog.hpp']), + strip_include_prefix = '/src' ) precompiled_headers( diff --git a/src/Pog/CMakeLists.txt b/src/Pog/CMakeLists.txt index 6047f3a6..7882ec59 100644 --- a/src/Pog/CMakeLists.txt +++ b/src/Pog/CMakeLists.txt @@ -38,4 +38,4 @@ add_library( ) target_precompile_headers(hcpu::pog INTERFACE Pog.hpp) -target_include_directories(hcpu::pog INTERFACE ${CMAKE_SOURCE_DIR}) +target_include_directories(hcpu::pog INTERFACE ${CMAKE_SOURCE_DIR}/src) diff --git a/src/Pog/Errors.hpp b/src/Pog/Errors.hpp index fbe5fdea..a0eb0b05 100644 --- a/src/Pog/Errors.hpp +++ b/src/Pog/Errors.hpp @@ -8,7 +8,7 @@ #include #include -#include "src/Pog/Symbol.hpp" +#include "Pog/Symbol.hpp" namespace pog { diff --git a/src/Pog/Grammar.hpp b/src/Pog/Grammar.hpp index eb406458..767d9aec 100644 --- a/src/Pog/Grammar.hpp +++ b/src/Pog/Grammar.hpp @@ -4,11 +4,11 @@ #include #include -#include "src/Pog/LineSpecialization.hpp" -#include "src/Pog/Rule.hpp" -#include "src/Pog/Symbol.hpp" -#include "src/Pog/Token.hpp" -#include "src/Pog/Utils.hpp" +#include "Pog/LineSpecialization.hpp" +#include "Pog/Rule.hpp" +#include "Pog/Symbol.hpp" +#include "Pog/Token.hpp" +#include "Pog/Utils.hpp" namespace pog { diff --git a/src/Pog/HTMLReport.hpp b/src/Pog/HTMLReport.hpp index 921988d2..255952bf 100644 --- a/src/Pog/HTMLReport.hpp +++ b/src/Pog/HTMLReport.hpp @@ -2,7 +2,7 @@ #include -#include "src/Pog/Parser.hpp" +#include "Pog/Parser.hpp" namespace pog { diff --git a/src/Pog/Item.hpp b/src/Pog/Item.hpp index 91b16bc7..7a29935a 100644 --- a/src/Pog/Item.hpp +++ b/src/Pog/Item.hpp @@ -4,7 +4,7 @@ #include -#include "src/Pog/Rule.hpp" +#include "Pog/Rule.hpp" namespace pog { diff --git a/src/Pog/Operations/Follow.hpp b/src/Pog/Operations/Follow.hpp index b3cd6dae..f831b8a6 100644 --- a/src/Pog/Operations/Follow.hpp +++ b/src/Pog/Operations/Follow.hpp @@ -1,10 +1,10 @@ #pragma once -#include "src/Pog/Types/StateAndSymbol.hpp" -#include "src/Pog/Operations/Operation.hpp" -#include "src/Pog/Relations/Includes.hpp" -#include "src/Pog/Operations/Read.hpp" -#include "src/Pog/DigraphAlgo.hpp" +#include "Pog/Types/StateAndSymbol.hpp" +#include "Pog/Operations/Operation.hpp" +#include "Pog/Relations/Includes.hpp" +#include "Pog/Operations/Read.hpp" +#include "Pog/DigraphAlgo.hpp" namespace pog { diff --git a/src/Pog/Operations/Lookahead.hpp b/src/Pog/Operations/Lookahead.hpp index 169c1cbc..f2d0dbe8 100644 --- a/src/Pog/Operations/Lookahead.hpp +++ b/src/Pog/Operations/Lookahead.hpp @@ -1,9 +1,9 @@ #pragma once -#include "src/Pog/Operations/Operation.hpp" -#include "src/Pog/Types/StateAndRule.hpp" -#include "src/Pog/Relations/Lookback.hpp" -#include "src/Pog/Operations/Follow.hpp" +#include "Pog/Operations/Operation.hpp" +#include "Pog/Types/StateAndRule.hpp" +#include "Pog/Relations/Lookback.hpp" +#include "Pog/Operations/Follow.hpp" namespace pog { diff --git a/src/Pog/Operations/Operation.hpp b/src/Pog/Operations/Operation.hpp index 0a8603e2..beea5e21 100644 --- a/src/Pog/Operations/Operation.hpp +++ b/src/Pog/Operations/Operation.hpp @@ -3,8 +3,8 @@ #include #include -#include "src/Pog/Automaton.hpp" -#include "src/Pog/Grammar.hpp" +#include "Pog/Automaton.hpp" +#include "Pog/Grammar.hpp" namespace pog { diff --git a/src/Pog/Operations/Read.hpp b/src/Pog/Operations/Read.hpp index cfcf55d4..13a14f7b 100644 --- a/src/Pog/Operations/Read.hpp +++ b/src/Pog/Operations/Read.hpp @@ -1,7 +1,7 @@ #pragma once -#include "src/Pog/Operations/Operation.hpp" -#include "src/Pog/Types/StateAndSymbol.hpp" +#include "Pog/Operations/Operation.hpp" +#include "Pog/Types/StateAndSymbol.hpp" namespace pog { diff --git a/src/Pog/Parser.hpp b/src/Pog/Parser.hpp index 021ffb17..9123ea15 100644 --- a/src/Pog/Parser.hpp +++ b/src/Pog/Parser.hpp @@ -15,24 +15,24 @@ #define debug_parser(...) #endif -#include "src/Pog/LineSpecialization.hpp" -#include "src/Pog/ParserReport.hpp" -#include "src/Pog/ParsingTable.hpp" -#include "src/Pog/TokenBuilder.hpp" -#include "src/Pog/RuleBuilder.hpp" -#include "src/Pog/Automaton.hpp" -#include "src/Pog/Tokenizer.hpp" -#include "src/Pog/Grammar.hpp" -#include "src/Pog/Action.hpp" -#include "src/Pog/Errors.hpp" -#include "src/Pog/Symbol.hpp" -#include "src/Pog/State.hpp" - -#include "src/Pog/Operations/Lookahead.hpp" -#include "src/Pog/Operations/Follow.hpp" -#include "src/Pog/Operations/Read.hpp" -#include "src/Pog/Relations/Includes.hpp" -#include "src/Pog/Relations/Lookback.hpp" +#include "Pog/LineSpecialization.hpp" +#include "Pog/ParserReport.hpp" +#include "Pog/ParsingTable.hpp" +#include "Pog/TokenBuilder.hpp" +#include "Pog/RuleBuilder.hpp" +#include "Pog/Automaton.hpp" +#include "Pog/Tokenizer.hpp" +#include "Pog/Grammar.hpp" +#include "Pog/Action.hpp" +#include "Pog/Errors.hpp" +#include "Pog/Symbol.hpp" +#include "Pog/State.hpp" + +#include "Pog/Operations/Lookahead.hpp" +#include "Pog/Operations/Follow.hpp" +#include "Pog/Operations/Read.hpp" +#include "Pog/Relations/Includes.hpp" +#include "Pog/Relations/Lookback.hpp" namespace HCAsm { diff --git a/src/Pog/ParserReport.hpp b/src/Pog/ParserReport.hpp index af866d1d..821854a7 100644 --- a/src/Pog/ParserReport.hpp +++ b/src/Pog/ParserReport.hpp @@ -5,8 +5,8 @@ #include -#include "src/Pog/State.hpp" -#include "src/Pog/Rule.hpp" +#include "Pog/State.hpp" +#include "Pog/Rule.hpp" namespace pog { diff --git a/src/Pog/ParsingTable.hpp b/src/Pog/ParsingTable.hpp index abe4d977..7f0fd73c 100644 --- a/src/Pog/ParsingTable.hpp +++ b/src/Pog/ParsingTable.hpp @@ -2,15 +2,15 @@ #include -#include "src/Pog/Operations/Lookahead.hpp" -#include "src/Pog/Types/StateAndSymbol.hpp" -#include "src/Pog/Types/StateAndRule.hpp" -#include "src/Pog/ParserReport.hpp" -#include "src/Pog/Automaton.hpp" -#include "src/Pog/Grammar.hpp" -#include "src/Pog/Action.hpp" -#include "src/Pog/Symbol.hpp" -#include "src/Pog/State.hpp" +#include "Pog/Operations/Lookahead.hpp" +#include "Pog/Types/StateAndSymbol.hpp" +#include "Pog/Types/StateAndRule.hpp" +#include "Pog/ParserReport.hpp" +#include "Pog/Automaton.hpp" +#include "Pog/Grammar.hpp" +#include "Pog/Action.hpp" +#include "Pog/Symbol.hpp" +#include "Pog/State.hpp" namespace pog { diff --git a/src/Pog/Pog.hpp b/src/Pog/Pog.hpp index 1dba6a1c..fcd4bec2 100644 --- a/src/Pog/Pog.hpp +++ b/src/Pog/Pog.hpp @@ -2,5 +2,5 @@ #define POG_VERSION "0.5.3" -#include "src/Pog/HTMLReport.hpp" -#include "src/Pog/Parser.hpp" +#include "Pog/HTMLReport.hpp" +#include "Pog/Parser.hpp" diff --git a/src/Pog/Relations/Includes.hpp b/src/Pog/Relations/Includes.hpp index e5445741..c10ad620 100644 --- a/src/Pog/Relations/Includes.hpp +++ b/src/Pog/Relations/Includes.hpp @@ -4,8 +4,8 @@ #include -#include "src/Pog/Types/StateAndSymbol.hpp" -#include "src/Pog/Relations/Relation.hpp" +#include "Pog/Types/StateAndSymbol.hpp" +#include "Pog/Relations/Relation.hpp" namespace pog { diff --git a/src/Pog/Relations/Lookback.hpp b/src/Pog/Relations/Lookback.hpp index 02ee4d1c..3bdfe058 100644 --- a/src/Pog/Relations/Lookback.hpp +++ b/src/Pog/Relations/Lookback.hpp @@ -2,9 +2,9 @@ #include -#include "src/Pog/Types/StateAndSymbol.hpp" -#include "src/Pog/Relations/Relation.hpp" -#include "src/Pog/Types/StateAndRule.hpp" +#include "Pog/Types/StateAndSymbol.hpp" +#include "Pog/Relations/Relation.hpp" +#include "Pog/Types/StateAndRule.hpp" namespace pog { diff --git a/src/Pog/Relations/Relation.hpp b/src/Pog/Relations/Relation.hpp index 8b73d489..fdff09b5 100644 --- a/src/Pog/Relations/Relation.hpp +++ b/src/Pog/Relations/Relation.hpp @@ -3,8 +3,8 @@ #include #include -#include "src/Pog/Automaton.hpp" -#include "src/Pog/Grammar.hpp" +#include "Pog/Automaton.hpp" +#include "Pog/Grammar.hpp" namespace pog { diff --git a/src/Pog/Rule.hpp b/src/Pog/Rule.hpp index 1e900844..b82e950c 100644 --- a/src/Pog/Rule.hpp +++ b/src/Pog/Rule.hpp @@ -9,8 +9,8 @@ #include #include -#include "src/Pog/LineSpecialization.hpp" -#include "src/Pog/Symbol.hpp" +#include "Pog/LineSpecialization.hpp" +#include "Pog/Symbol.hpp" namespace pog { diff --git a/src/Pog/RuleBuilder.hpp b/src/Pog/RuleBuilder.hpp index 3e8b6283..c42c3b06 100644 --- a/src/Pog/RuleBuilder.hpp +++ b/src/Pog/RuleBuilder.hpp @@ -1,7 +1,7 @@ #pragma once -#include "src/Pog/Grammar.hpp" -#include "src/Pog/Rule.hpp" +#include "Pog/Grammar.hpp" +#include "Pog/Rule.hpp" namespace pog { diff --git a/src/Pog/State.hpp b/src/Pog/State.hpp index 1e18ff7b..e605c29d 100644 --- a/src/Pog/State.hpp +++ b/src/Pog/State.hpp @@ -3,9 +3,9 @@ #include #include -#include "src/Pog/FilterView.hpp" -#include "src/Pog/Utils.hpp" -#include "src/Pog/Item.hpp" +#include "Pog/FilterView.hpp" +#include "Pog/Utils.hpp" +#include "Pog/Item.hpp" namespace pog { diff --git a/src/Pog/Symbol.hpp b/src/Pog/Symbol.hpp index f3938ce0..3654984f 100644 --- a/src/Pog/Symbol.hpp +++ b/src/Pog/Symbol.hpp @@ -3,7 +3,7 @@ #include #include -#include "src/Pog/Precedence.hpp" +#include "Pog/Precedence.hpp" namespace pog { diff --git a/src/Pog/Token.hpp b/src/Pog/Token.hpp index f0402149..71a43ff9 100644 --- a/src/Pog/Token.hpp +++ b/src/Pog/Token.hpp @@ -7,7 +7,7 @@ #include -#include "src/Pog/Symbol.hpp" +#include "Pog/Symbol.hpp" namespace pog { diff --git a/src/Pog/TokenBuilder.hpp b/src/Pog/TokenBuilder.hpp index f92d397b..0cbb8000 100644 --- a/src/Pog/TokenBuilder.hpp +++ b/src/Pog/TokenBuilder.hpp @@ -1,8 +1,8 @@ #pragma once -#include "src/Pog/Tokenizer.hpp" -#include "src/Pog/Grammar.hpp" -#include "src/Pog/Token.hpp" +#include "Pog/Tokenizer.hpp" +#include "Pog/Grammar.hpp" +#include "Pog/Token.hpp" namespace pog { diff --git a/src/Pog/Tokenizer.hpp b/src/Pog/Tokenizer.hpp index 8c7dbc41..84c0c1c1 100644 --- a/src/Pog/Tokenizer.hpp +++ b/src/Pog/Tokenizer.hpp @@ -17,9 +17,9 @@ #define debug_tokenizer(...) #endif -#include "src/Pog/LineSpecialization.hpp" -#include "src/Pog/Grammar.hpp" -#include "src/Pog/Token.hpp" +#include "Pog/LineSpecialization.hpp" +#include "Pog/Grammar.hpp" +#include "Pog/Token.hpp" namespace pog { diff --git a/src/Pog/Types/StateAndRule.hpp b/src/Pog/Types/StateAndRule.hpp index 27474e6a..3b7a5f36 100644 --- a/src/Pog/Types/StateAndRule.hpp +++ b/src/Pog/Types/StateAndRule.hpp @@ -1,7 +1,7 @@ #pragma once -#include "src/Pog/State.hpp" -#include "src/Pog/Rule.hpp" +#include "Pog/State.hpp" +#include "Pog/Rule.hpp" namespace pog { diff --git a/src/Pog/Types/StateAndSymbol.hpp b/src/Pog/Types/StateAndSymbol.hpp index f1f6f8b7..325b6df8 100644 --- a/src/Pog/Types/StateAndSymbol.hpp +++ b/src/Pog/Types/StateAndSymbol.hpp @@ -1,7 +1,7 @@ #pragma once -#include "src/Pog/Symbol.hpp" -#include "src/Pog/State.hpp" +#include "Pog/Symbol.hpp" +#include "Pog/State.hpp" namespace pog { From d8ab0e0b9923e7d030d7f505a6ebe6bfcb616ec9 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Tue, 6 May 2025 02:19:38 +0300 Subject: [PATCH 07/40] too lazy to add ignore revisions here --- .bazelrc | 2 + .bazelversion | 4 + .clang-tidy | 33 + BUILD.bazel | 10 +- MODULE.bazel | 14 +- bench/memory_fetch/memory_fetch.cpp | 16 +- dist/BUILD.bazel | 19 +- src/Assembler/BUILD.bazel | 11 +- src/Assembler/Core/BinaryTransformer.cpp | 338 ++-- src/Assembler/Core/BinaryTransformer.hpp | 116 +- src/Assembler/Core/Compiler.cpp | 477 +++-- src/Assembler/Core/Compiler.hpp | 134 +- src/Assembler/Core/ModeNameAssoc.hpp | 3 +- src/Assembler/Core/OpcodeNameAssoc.hpp | 77 +- src/Assembler/Core/Parsers.cpp | 327 ++-- src/Assembler/Core/RegNameAssoc.hpp | 87 +- src/Assembler/Core/StatementCompilers.cpp | 150 +- src/Assembler/Core/Tokenizers.cpp | 65 +- src/Assembler/Main/Main.cpp | 41 +- src/BacktraceProvider/BacktraceProvider.cpp | 117 +- src/BacktraceProvider/BacktraceProvider.hpp | 6 +- src/Common/BUILD.bazel | 6 + src/Common/Defs.hpp | 5 +- .../Main.hpp => Common/Helpers/Classes.hpp} | 11 +- src/Common/LanguageSpec/AllowedFlags.hpp | 272 +-- src/Common/LanguageSpec/Flags.hpp | 22 +- src/Common/LanguageSpec/Opcodes.hpp | 139 +- src/Common/LanguageSpec/Registers.hpp | 142 +- src/Common/NotImplemented.hpp | 6 +- src/Emulator/Core/CPU/ALU.hpp | 27 +- src/Emulator/Core/CPU/Assert.hpp | 6 +- src/Emulator/Core/CPU/CPU.cpp | 230 ++- src/Emulator/Core/CPU/CPU.hpp | 11 +- src/Emulator/Core/CPU/Decoders/IDecoder.hpp | 2 +- src/Emulator/Core/CPU/Decoders/StdDecoder.cpp | 213 +-- src/Emulator/Core/CPU/Decoders/StdDecoder.hpp | 59 +- src/Emulator/Core/CPU/IO/Simple.cpp | 41 +- src/Emulator/Core/CPU/IO/Simple.hpp | 3 +- .../Core/CPU/InstructionsImpl/ADC.cpp | 309 ++-- .../Core/CPU/InstructionsImpl/ADD.cpp | 261 ++- .../Core/CPU/InstructionsImpl/AND.cpp | 225 ++- .../Core/CPU/InstructionsImpl/ANDN.cpp | 269 ++- .../Core/CPU/InstructionsImpl/BSWAP.cpp | 41 +- .../Core/CPU/InstructionsImpl/CALL.cpp | 23 +- .../Core/CPU/InstructionsImpl/CALLE.cpp | 23 +- .../Core/CPU/InstructionsImpl/CALLGR.cpp | 23 +- .../Core/CPU/InstructionsImpl/CALLL.cpp | 23 +- .../Core/CPU/InstructionsImpl/CCRF.cpp | 1 - .../Core/CPU/InstructionsImpl/CMP.cpp | 303 ++- .../Core/CPU/InstructionsImpl/COVF.cpp | 1 - .../Core/CPU/InstructionsImpl/CUDF.cpp | 1 - .../Core/CPU/InstructionsImpl/DEC.cpp | 49 +- .../Core/CPU/InstructionsImpl/DIV.cpp | 59 +- .../Core/CPU/InstructionsImpl/HALT.cpp | 1 - .../Core/CPU/InstructionsImpl/HID.cpp | 23 +- .../Core/CPU/InstructionsImpl/INC.cpp | 49 +- .../Core/CPU/InstructionsImpl/INTR.cpp | 19 +- .../Core/CPU/InstructionsImpl/JME.cpp | 19 +- .../Core/CPU/InstructionsImpl/JMGR.cpp | 19 +- .../Core/CPU/InstructionsImpl/JML.cpp | 19 +- .../Core/CPU/InstructionsImpl/JMP.cpp | 19 +- .../Core/CPU/InstructionsImpl/LOIVT.cpp | 16 +- .../Core/CPU/InstructionsImpl/MOV.cpp | 279 ++- .../Core/CPU/InstructionsImpl/MUL.cpp | 261 ++- src/Emulator/Core/CPU/InstructionsImpl/OR.cpp | 225 ++- .../Core/CPU/InstructionsImpl/POP.cpp | 28 +- .../Core/CPU/InstructionsImpl/PUSH.cpp | 57 +- .../Core/CPU/InstructionsImpl/READ.cpp | 21 +- .../Core/CPU/InstructionsImpl/SHFL.cpp | 85 +- .../Core/CPU/InstructionsImpl/SHFR.cpp | 83 +- .../Core/CPU/InstructionsImpl/SUB.cpp | 237 ++- .../Core/CPU/InstructionsImpl/WRITE.cpp | 21 +- .../Core/CPU/Interrupts/InterruptHandler.cpp | 10 +- .../CPU/Interrupts/ReservedInterrupts.hpp | 1 - src/Emulator/Core/CPU/OperandsEvaluation.cpp | 239 ++- src/Emulator/Core/CPU/Stack.cpp | 1 - .../MemoryController/IMemoryController.hpp | 20 +- .../MemoryController/MemoryControllerST.hpp | 10 +- src/Emulator/Main/ExceptionHandling.cpp | 13 - src/Emulator/Main/ExceptionHandling.hpp | 10 - src/Emulator/Main/Main.cpp | 70 +- src/Emulator/Misc/bit_cast.hpp | 9 +- src/Emulator/Misc/byteswap.hpp | 4 +- src/Emulator/Misc/deref.hpp | 4 +- src/Emulator/Misc/overflow.hpp | 5 +- src/Emulator/Misc/print.hpp | 8 +- src/Emulator/Misc/underflow.hpp | 4 +- src/Emulator/Misc/unreachable.hpp | 2 +- src/Pog/Action.hpp | 26 +- src/Pog/Automaton.hpp | 265 ++- src/Pog/DigraphAlgo.hpp | 124 +- src/Pog/Errors.hpp | 99 +- src/Pog/FilterView.hpp | 147 +- src/Pog/Grammar.hpp | 506 +++-- src/Pog/HTMLReport.hpp | 297 ++- src/Pog/Item.hpp | 240 ++- src/Pog/LineSpecialization.hpp | 52 +- src/Pog/Operations/Follow.hpp | 93 +- src/Pog/Operations/Lookahead.hpp | 115 +- src/Pog/Operations/Operation.hpp | 87 +- src/Pog/Operations/Read.hpp | 105 +- src/Pog/Parser.hpp | 556 +++--- src/Pog/ParserReport.hpp | 155 +- src/Pog/ParsingTable.hpp | 294 ++- src/Pog/Precedence.hpp | 78 +- src/Pog/Relations/Includes.hpp | 250 ++- src/Pog/Relations/Lookback.hpp | 184 +- src/Pog/Relations/Relation.hpp | 90 +- src/Pog/Rule.hpp | 178 +- src/Pog/RuleBuilder.hpp | 247 ++- src/Pog/State.hpp | 283 ++- src/Pog/Symbol.hpp | 103 +- src/Pog/Token.hpp | 142 +- src/Pog/TokenBuilder.hpp | 197 +- src/Pog/Tokenizer.hpp | 489 +++-- src/Pog/Types/StateAndRule.hpp | 43 +- src/Pog/Types/StateAndSymbol.hpp | 43 +- src/Pog/Utils.hpp | 108 +- .../AssemblerCore/AssemblerFail.cpp | 31 +- .../AssemblerCore/AssemblerSuccess.cpp | 82 +- .../AssemblerCore/FullAssembler.cpp | 2 +- .../Integration/EmulatorCore/CPU/CPU_ADC.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_ADD.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_AND.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_ANDN.cpp | 3 +- .../EmulatorCore/CPU/CPU_BSWAP.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_CALL.cpp | 3 +- .../EmulatorCore/CPU/CPU_CALLE.cpp | 88 +- .../EmulatorCore/CPU/CPU_CALLGR.cpp | 7 +- .../EmulatorCore/CPU/CPU_CALLL.cpp | 7 +- .../Integration/EmulatorCore/CPU/CPU_CCRF.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_CMP.cpp | 5 +- .../Integration/EmulatorCore/CPU/CPU_COVF.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_CUDF.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_DEC.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_DIV.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_HID.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_INC.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_INTR.cpp | 5 +- .../Integration/EmulatorCore/CPU/CPU_IRET.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_JME.cpp | 5 +- .../Integration/EmulatorCore/CPU/CPU_JMGR.cpp | 7 +- .../Integration/EmulatorCore/CPU/CPU_JML.cpp | 7 +- .../Integration/EmulatorCore/CPU/CPU_JMP.cpp | 3 +- .../EmulatorCore/CPU/CPU_LOIVT.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_MOV.cpp | 5 +- .../Integration/EmulatorCore/CPU/CPU_MUL.cpp | 3 +- tests/Integration/EmulatorCore/CPU/CPU_OR.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_POP.cpp | 4 +- .../Integration/EmulatorCore/CPU/CPU_PUSH.cpp | 4 +- .../Integration/EmulatorCore/CPU/CPU_READ.cpp | 2 +- .../Integration/EmulatorCore/CPU/CPU_SHFL.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_SHFR.cpp | 3 +- .../Integration/EmulatorCore/CPU/CPU_SUB.cpp | 3 +- .../EmulatorCore/CPU/CPU_WRITE.cpp | 2 +- .../EmulatorCore/CPU/OperandsEvaluation.cpp | 69 +- .../EmulatorCore/Exceptions/Exceptions.cpp | 3 +- .../Modular/AssemblerCore/Parser/Operands.cpp | 212 +-- .../AssemblerCore/Parser/Statements.cpp | 6 +- tests/Modular/AssemblerCore/Parser/Tokens.cpp | 158 +- .../Decoding/ADCInstr/Unsupported.cpp | 4 +- .../Decoding/ADDInstr/Unsupported.cpp | 4 +- .../Decoding/ANDInstr/Unsupported.cpp | 4 +- .../Decoding/ANDNInstr/Unsupported.cpp | 4 +- .../Decoding/BSWAPInstr/Unsupported.cpp | 4 +- .../CALLEInstr/test_decoder_unsupported.cpp | 4 +- .../CALLGRInstr/test_decoder_unsupported.cpp | 4 +- .../CALLInstr/test_decoder_unsupported.cpp | 4 +- .../CALLLInstr/test_decoder_unsupported.cpp | 4 +- .../CCRFInstr/test_decoder_unsupported.cpp | 5 +- .../Decoding/CMPInstr/Unsupported.cpp | 4 +- .../COVFInstr/test_decoder_unsupported.cpp | 5 +- .../Decoding/CUDFInstr/Unsupported.cpp | 5 +- .../Decoding/DECInstr/Unsupported.cpp | 4 +- .../Decoding/DIVInstr/Unsupported.cpp | 4 +- .../Decoding/HALTInstr/Unsupported.cpp | 5 +- .../Decoding/HIDInstr/Unsupported.cpp | 5 +- .../Decoding/INCInstr/Unsupported.cpp | 4 +- .../JMEInstr/test_decoder_unsupported.cpp | 4 +- .../JMGRInstr/test_decoder_unsupported.cpp | 4 +- .../JMLInstr/test_decoder_unsupported.cpp | 4 +- .../JMPInstr/test_decoder_unsupported.cpp | 4 +- .../Decoding/MOVInstr/Unsupported.cpp | 4 +- .../Decoding/MULInstr/Unsupported.cpp | 4 +- .../Decoding/ORInstr/Unsupported.cpp | 4 +- .../EmulatorCore/Decoding/READInstr/IMM.cpp | 5 +- .../Decoding/READInstr/Unsupported.cpp | 66 +- .../Decoding/SHFLInstr/Unsupported.cpp | 4 +- .../Decoding/SHFRInstr/Unsupported.cpp | 4 +- .../Decoding/SUBInstr/Unsupported.cpp | 4 +- .../Decoding/WRITEInstr/R_IMM.cpp | 3 +- .../EmulatorCore/Decoding/WRITEInstr/R_R.cpp | 3 +- .../Decoding/WRITEInstr/Unsupported.cpp | 68 +- .../EmulatorCore/MemoryControllers/ST.cpp | 7 +- tests/Modular/EmulatorCore/Stack/Stack.cpp | 1 - tests/Pog/Automaton.cpp | 279 ++- tests/Pog/FilterView.cpp | 84 +- tests/Pog/Grammar.cpp | 262 +-- tests/Pog/Item.cpp | 318 ++-- tests/Pog/Parser.cpp | 1635 ++++++++--------- tests/Pog/ParsingTable.cpp | 4 +- tests/Pog/PogTests.cpp | 7 +- tests/Pog/Precedence.cpp | 92 +- tests/Pog/Rule.cpp | 124 +- tests/Pog/RuleBuilder.cpp | 78 +- tests/Pog/State.cpp | 430 ++--- tests/Pog/Symbol.cpp | 76 +- tests/Pog/Token.cpp | 112 +- tests/Pog/TokenBuilder.cpp | 184 +- tests/Pog/Tokenizer.cpp | 423 +++-- tests/Pog/Utils.cpp | 78 +- tests/fixtures.hpp | 103 +- tests/main.cpp | 8 +- tools/bazel/BUILD.bazel | 9 +- tools/bazel/linting.bzl | 11 + 215 files changed, 8770 insertions(+), 8931 deletions(-) create mode 100644 .bazelrc create mode 100644 .bazelversion create mode 100644 .clang-tidy rename src/{Emulator/Main/Main.hpp => Common/Helpers/Classes.hpp} (78%) delete mode 100644 src/Emulator/Main/ExceptionHandling.cpp delete mode 100644 src/Emulator/Main/ExceptionHandling.hpp create mode 100644 tools/bazel/linting.bzl diff --git a/.bazelrc b/.bazelrc new file mode 100644 index 00000000..afe2c319 --- /dev/null +++ b/.bazelrc @@ -0,0 +1,2 @@ +build --cxxopt=-std=c++23 --cxxopt=-Isrc/ +build --aspects //tools/bazel:linting.bzl%clang_tidy diff --git a/.bazelversion b/.bazelversion new file mode 100644 index 00000000..c1e64b1f --- /dev/null +++ b/.bazelversion @@ -0,0 +1,4 @@ +8.2.1 +# The first line of this file is used by Bazelisk and Bazel to be sure +# the right version of Bazel is used to build and test this repo. +# This also defines which version is used on CI. diff --git a/.clang-tidy b/.clang-tidy new file mode 100644 index 00000000..1d664e14 --- /dev/null +++ b/.clang-tidy @@ -0,0 +1,33 @@ +Checks: 'clang-diagnostic-*,clang-analyzer-*,cppcoreguidelines-*,modernize-*,-modernize-use-trailing-return-type' +HeaderFilterRegex: '' +AnalyzeTemporaryDtors: false +FormatStyle: google +CheckOptions: + - key: cert-dcl16-c.NewSuffixes + value: 'L;LL;LU;LLU' + - key: cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField + value: '0' + - key: cppcoreguidelines-explicit-virtual-functions.IgnoreDestructors + value: '1' + - key: cppcoreguidelines-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic + value: '1' + - key: google-readability-braces-around-statements.ShortStatementLines + value: '1' + - key: google-readability-function-size.StatementThreshold + value: '800' + - key: google-readability-namespace-comments.ShortNamespaceLines + value: '10' + - key: google-readability-namespace-comments.SpacesBeforeComments + value: '2' + - key: modernize-loop-convert.MaxCopySize + value: '16' + - key: modernize-loop-convert.MinConfidence + value: reasonable + - key: modernize-loop-convert.NamingStyle + value: CamelCase + - key: modernize-pass-by-value.IncludeStyle + value: llvm + - key: modernize-replace-auto-ptr.IncludeStyle + value: llvm + - key: modernize-use-nullptr.NullMacros + value: 'NULL' diff --git a/BUILD.bazel b/BUILD.bazel index 981f851c..b11278ed 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -1,11 +1,19 @@ 'Top level build configuration, use for tooling only' +load('@aspect_rules_lint//format:defs.bzl', 'format_multirun') load('@hedron_compile_commands//:refresh_compile_commands.bzl', 'refresh_compile_commands') - refresh_compile_commands( name = 'refresh_compile_commands', targets = { '//src/...': '', } ) + +format_multirun( + name = 'format', + cc = '@llvm_toolchain_llvm//:bin/clang-format', + # python = '@aspect_rules_lint//format:ruff', + # starlark = '@buildifier_prebuilt//:buildifier', + print_command = True +) diff --git a/MODULE.bazel b/MODULE.bazel index a73c70a9..4b3acf78 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -27,11 +27,21 @@ use_repo( ) bazel_dep(name = 'rules_cc', version = '0.0.17') -bazel_dep(name = 'rules_foreign_cc', version = '0.11.1') - +bazel_dep(name = 'aspect_rules_lint', version = '1.3.5') +bazel_dep(name = 'bazel_skylib', version = '1.7.1') +bazel_dep(name = 'toolchains_llvm', version = '1.4.0') bazel_dep(name = 'hedron_compile_commands', dev_dependency = True) + git_override( module_name = 'hedron_compile_commands', remote = 'https://github.com/hedronvision/bazel-compile-commands-extractor.git', commit = '4f28899228fb3ad0126897876f147ca15026151e' ) + +llvm = use_extension('@toolchains_llvm//toolchain/extensions:llvm.bzl', 'llvm') +llvm.toolchain( + llvm_versions = { + '': '19.1.7', + } +) +use_repo(llvm, 'llvm_toolchain', 'llvm_toolchain_llvm') diff --git a/bench/memory_fetch/memory_fetch.cpp b/bench/memory_fetch/memory_fetch.cpp index 39defa36..b0373c06 100644 --- a/bench/memory_fetch/memory_fetch.cpp +++ b/bench/memory_fetch/memory_fetch.cpp @@ -9,7 +9,9 @@ class MC_ST : public benchmark::Fixture { public: HyperCPU::MemoryControllerST mc_st; - MC_ST() : mc_st(ITERATIONS) { } + MC_ST() + : mc_st(ITERATIONS) { + } }; void mc_st_load8([[maybe_unused]] benchmark::State& state) { @@ -37,7 +39,8 @@ void mc_st_load32([[maybe_unused]] benchmark::State& state) { } void mc_st_load64([[maybe_unused]] benchmark::State& state) { - std::size_t counter = 0; HyperCPU::MemoryControllerST mc_st{ITERATIONS}; + std::size_t counter = 0; + HyperCPU::MemoryControllerST mc_st{ITERATIONS}; while (state.KeepRunning()) { mc_st.Load64(counter, 0x55); } @@ -91,21 +94,24 @@ void mc_st_fetch16([[maybe_unused]] benchmark::State& state) { std::size_t counter = 0; HyperCPU::MemoryControllerST mc_st{ITERATIONS}; while (state.KeepRunning()) { - [[maybe_unused]] auto t = mc_st.Fetch16(counter); } + [[maybe_unused]] auto t = mc_st.Fetch16(counter); + } } void mc_st_fetch32([[maybe_unused]] benchmark::State& state) { std::size_t counter = 0; HyperCPU::MemoryControllerST mc_st{ITERATIONS}; while (state.KeepRunning()) { - [[maybe_unused]] auto t = mc_st.Fetch32(counter); } + [[maybe_unused]] auto t = mc_st.Fetch32(counter); + } } void mc_st_fetch64([[maybe_unused]] benchmark::State& state) { std::size_t counter = 0; HyperCPU::MemoryControllerST mc_st{ITERATIONS}; while (state.KeepRunning()) { - [[maybe_unused]] auto t = mc_st.Fetch64(counter); } + [[maybe_unused]] auto t = mc_st.Fetch64(counter); + } } BENCHMARK(mc_st_load8)->Iterations(ITERATIONS); diff --git a/dist/BUILD.bazel b/dist/BUILD.bazel index 683bf0e4..2d92302d 100644 --- a/dist/BUILD.bazel +++ b/dist/BUILD.bazel @@ -1,12 +1,13 @@ -load("@rules_foreign_cc//foreign_cc:defs.bzl", "cmake") +load('@rules_cc//cc:defs.bzl', 'cc_library') -cmake( +package( + default_visibility = [ + '//:__subpackages__', + ], +) + +cc_library( name = 'hpool', - cache_entries = { - 'HPOOL_BUILD_TESTS': False, - 'HPOOL_BUILD_BENCHMARKS': False - }, - includes = [ - '.' - ] + hdrs = ['HPool/hpool.hpp'], + includes = ['HPool'], ) diff --git a/src/Assembler/BUILD.bazel b/src/Assembler/BUILD.bazel index fcecfa6b..ccc827f9 100644 --- a/src/Assembler/BUILD.bazel +++ b/src/Assembler/BUILD.bazel @@ -11,25 +11,22 @@ cc_library( srcs = glob(['**/*.cpp'], exclude = ['Main']), hdrs = glob(['**/*.hpp'], exclude = ['Main']), strip_include_prefix = '/src', - copts = [ - '-Isrc/' - ], deps = [ '//src/PCH:pch_cstd', '//src/Pog:pog', + '//src/Common:hcpu_common', '@fmt//:fmt', '@re2//:re2', '@eternal//:eternal', - '@argparse//:argparse' + '@argparse//:argparse', + '@spdlog//:spdlog', + '//dist:hpool' ] ) cc_binary( name = 'hcasm', srcs = glob(['Main/**/*.cpp']), - copts = [ - '-Isrc/' - ], deps = [ ':assembler_core', '@eternal//:eternal' diff --git a/src/Assembler/Core/BinaryTransformer.cpp b/src/Assembler/Core/BinaryTransformer.cpp index 17d1aa63..2cd90be7 100644 --- a/src/Assembler/Core/BinaryTransformer.cpp +++ b/src/Assembler/Core/BinaryTransformer.cpp @@ -1,75 +1,80 @@ -#include "Pog/Pog.hpp" -#include "PCH/CStd.hpp" -#include "Common/LanguageSpec/Opcodes.hpp" -#include "Common/LanguageSpec/Flags.hpp" +#include + #include "Assembler/Core/BinaryTransformer.hpp" #include "Assembler/Core/Compiler.hpp" - +#include "Common/LanguageSpec/Flags.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" +#include "PCH/CStd.hpp" +#include "Pog/Pog.hpp" HyperCPU::OperandTypes HCAsm::BinaryTransformer::DetermineOperandTypes(Operand& op1, Operand& op2) { Op1T tp1; Op2T tp2; switch (op1.type) { - case HCAsm::OperandType::reg: - tp1 = Op1T::R; break; - case HCAsm::OperandType::mem_reg_add_int: - case HCAsm::OperandType::memaddr_reg: - tp1 = Op1T::RM; break; - case HCAsm::OperandType::sint: - case HCAsm::OperandType::uint: - case HCAsm::OperandType::label: - tp1 = Op1T::IMM; break; - case HCAsm::OperandType::memaddr_int: - case HCAsm::OperandType::memaddr_lbl: - tp1 = Op1T::M; break; - case HCAsm::OperandType::none: - tp1 = Op1T::NONE; break; - default: - UNREACHABLE(); + case HCAsm::OperandType::reg: + tp1 = Op1T::R; + break; + case HCAsm::OperandType::mem_reg_add_int: + case HCAsm::OperandType::memaddr_reg: + tp1 = Op1T::RM; + break; + case HCAsm::OperandType::sint: + case HCAsm::OperandType::uint: + case HCAsm::OperandType::label: + tp1 = Op1T::IMM; + break; + case HCAsm::OperandType::memaddr_int: + case HCAsm::OperandType::memaddr_lbl: + tp1 = Op1T::M; + break; + case HCAsm::OperandType::none: + tp1 = Op1T::NONE; + break; } switch (op2.type) { - case HCAsm::OperandType::reg: - tp2 = Op2T::R; break; - case HCAsm::OperandType::mem_reg_add_int: - case HCAsm::OperandType::memaddr_reg: - tp2 = Op2T::RM; break; - case HCAsm::OperandType::sint: - case HCAsm::OperandType::uint: - case HCAsm::OperandType::label: - tp2 = Op2T::IMM; break; - case HCAsm::OperandType::memaddr_int: - case HCAsm::OperandType::memaddr_lbl: - tp2 = Op2T::M; break; - case HCAsm::OperandType::none: - tp2 = Op2T::NONE; break; - default: - UNREACHABLE(); + case HCAsm::OperandType::reg: + tp2 = Op2T::R; + break; + case HCAsm::OperandType::mem_reg_add_int: + case HCAsm::OperandType::memaddr_reg: + tp2 = Op2T::RM; + break; + case HCAsm::OperandType::sint: + case HCAsm::OperandType::uint: + case HCAsm::OperandType::label: + tp2 = Op2T::IMM; + break; + case HCAsm::OperandType::memaddr_int: + case HCAsm::OperandType::memaddr_lbl: + tp2 = Op2T::M; + break; + case HCAsm::OperandType::none: + tp2 = Op2T::NONE; + break; } return QuickCast(QuickOR(tp1, tp2)); } - - void HCAsm::BinaryTransformer::EncodeInstruction(HCAsm::Instruction& instr) { HyperCPU::OperandTypes types = DetermineOperandTypes(instr.op1, instr.op2); res.push(static_cast(instr.opcode)); switch (instr.opcode) { - case HyperCPU::IRET: - return; - default: - break; + case HyperCPU::Opcode::IRET: + return; + default: + break; } std::uint8_t encoded_operands = 0; if (HasAddressAddition(instr.op1.type) && HasAddressAddition(instr.op2.type)) { - logger.Log(HyperCPU::LogLevel::ERROR, "You can't use memory address additions for two operands!"); - EXIT(1); + spdlog::error("You can't use memory address additions for two operands!"); + // TODO: handle error } else if (HasAddressAddition(instr.op1.type) || HasAddressAddition(instr.op2.type)) { encoded_operands |= 0b10000000; if (HasAddressAddition(instr.op2.type)) { @@ -81,133 +86,156 @@ void HCAsm::BinaryTransformer::EncodeInstruction(HCAsm::Instruction& instr) { // Handle case when one of operands is a label - we should mock the immediate 64 bit value switch (instr.op1.type) { - case HCAsm::OperandType::label: - case HCAsm::OperandType::memaddr_lbl: - instr.op1.variant = state->labels.at(*std::get>(instr.op1.variant)); - break; - default: break; + case HCAsm::OperandType::label: + case HCAsm::OperandType::memaddr_lbl: + instr.op1.variant = state->labels.at(*std::get>(instr.op1.variant)); + break; + default: + break; } switch (instr.op2.type) { - case HCAsm::OperandType::label: - case HCAsm::OperandType::memaddr_lbl: - instr.op2.variant = state->labels.at(*std::get>(instr.op2.variant)); - break; - default: break; + case HCAsm::OperandType::label: + case HCAsm::OperandType::memaddr_lbl: + instr.op2.variant = state->labels.at(*std::get>(instr.op2.variant)); + break; + default: + break; } HCAsm::Mode md; switch (types) { - case HyperCPU::OperandTypes::RM_M: - if (instr.op2.mode != HCAsm::Mode::none) { - md = instr.op2.mode; - break; - } - [[fallthrough]]; - case HyperCPU::OperandTypes::RM_IMM: - if (instr.op1.mode == HCAsm::Mode::none) { - logger.Log(HyperCPU::LogLevel::ERROR, "Ambiguous operand size!"); - EXIT(1); - } - [[fallthrough]]; - case HyperCPU::OperandTypes::R_R: - case HyperCPU::OperandTypes::R_RM: - case HyperCPU::OperandTypes::R_M: - case HyperCPU::OperandTypes::R_IMM: - case HyperCPU::OperandTypes::R: - md = instr.op1.mode; - [[fallthrough]]; - case HyperCPU::OperandTypes::IMM: - if (instr.op1.mode == Mode::none) { - logger.Log(HyperCPU::LogLevel::ERROR, "Undefined operand size!"); - EXIT(1); - } - md = instr.op1.mode; - break; - case HyperCPU::OperandTypes::RM_R: - case HyperCPU::OperandTypes::M_R: + case HyperCPU::OperandTypes::RM_M: + if (instr.op2.mode != HCAsm::Mode::none) { md = instr.op2.mode; break; - case HyperCPU::OperandTypes::NONE: - md = HCAsm::Mode::b8; // Placeholder - break; - default: - UNREACHABLE(); + } + [[fallthrough]]; + case HyperCPU::OperandTypes::RM_IMM: + if (instr.op1.mode == HCAsm::Mode::none) { + spdlog::error("Ambiguous operand size!"); + // TODO: handle error + } + [[fallthrough]]; + case HyperCPU::OperandTypes::R_R: + case HyperCPU::OperandTypes::R_RM: + case HyperCPU::OperandTypes::R_M: + case HyperCPU::OperandTypes::R_IMM: + case HyperCPU::OperandTypes::R: + md = instr.op1.mode; + [[fallthrough]]; + case HyperCPU::OperandTypes::IMM: + if (instr.op1.mode == Mode::none) { + spdlog::error("Undefined operand size!"); + // TODO: handle error + } + md = instr.op1.mode; + break; + case HyperCPU::OperandTypes::RM_R: + case HyperCPU::OperandTypes::M_R: + md = instr.op2.mode; + break; + case HyperCPU::OperandTypes::NONE: + md = HCAsm::Mode::b8; // Placeholder + break; } + encoded_operands |= (static_cast(md) << 4); encoded_operands |= static_cast(types); res.push(static_cast(encoded_operands)); switch (types) { - case HyperCPU::OperandTypes::R_R: - case HyperCPU::OperandTypes::R_RM: - case HyperCPU::OperandTypes::RM_R: - res.push(static_cast(instr.op1.reg)); - res.push(static_cast(instr.op2.reg)); - break; - case HyperCPU::OperandTypes::RM_M: - case HyperCPU::OperandTypes::R_M: - res.push(static_cast(instr.op1.reg)); - res.push(std::get(instr.op2.variant)); - break; - case HyperCPU::OperandTypes::RM_IMM: - case HyperCPU::OperandTypes::R_IMM: - res.push(static_cast(instr.op1.reg)); - if (std::holds_alternative(instr.op2.variant)) { - switch (md) { - case HCAsm::Mode::b8: res.push(static_cast(std::get(instr.op2.variant))); break; - case HCAsm::Mode::b16: res.push(static_cast(std::get(instr.op2.variant))); break; - case HCAsm::Mode::b32: res.push(static_cast(std::get(instr.op2.variant))); break; - case HCAsm::Mode::b64: res.push(static_cast(std::get(instr.op2.variant))); break; - default: - UNREACHABLE(); - } - } else { - switch (md) { - case HCAsm::Mode::b8: res.push(static_cast(std::get(instr.op2.variant))); break; - case HCAsm::Mode::b16: res.push(static_cast(std::get(instr.op2.variant))); break; - case HCAsm::Mode::b32: res.push(static_cast(std::get(instr.op2.variant))); break; - case HCAsm::Mode::b64: res.push(static_cast(std::get(instr.op2.variant))); break; - default: - UNREACHABLE(); - } + case HyperCPU::OperandTypes::R_R: + case HyperCPU::OperandTypes::R_RM: + case HyperCPU::OperandTypes::RM_R: + res.push(static_cast(instr.op1.reg)); + res.push(static_cast(instr.op2.reg)); + break; + case HyperCPU::OperandTypes::RM_M: + case HyperCPU::OperandTypes::R_M: + res.push(static_cast(instr.op1.reg)); + res.push(std::get(instr.op2.variant)); + break; + case HyperCPU::OperandTypes::RM_IMM: + case HyperCPU::OperandTypes::R_IMM: + res.push(static_cast(instr.op1.reg)); + if (std::holds_alternative(instr.op2.variant)) { + switch (md) { + case HCAsm::Mode::b8: + res.push(static_cast(std::get(instr.op2.variant))); + break; + case HCAsm::Mode::b16: + res.push(static_cast(std::get(instr.op2.variant))); + break; + case HCAsm::Mode::b32: + res.push(static_cast(std::get(instr.op2.variant))); + break; + case HCAsm::Mode::b64: + res.push(static_cast(std::get(instr.op2.variant))); + break; } - break; - case HyperCPU::OperandTypes::R: - res.push(static_cast(instr.op1.reg)); - break; - case HyperCPU::OperandTypes::M: - res.push(std::get(instr.op2.variant)); - break; - case HyperCPU::OperandTypes::IMM: - if (std::holds_alternative(instr.op2.variant)) { - switch (md) { - case HCAsm::Mode::b8: res.push(static_cast(std::get(instr.op1.variant))); break; - case HCAsm::Mode::b16: res.push(static_cast(std::get(instr.op1.variant))); break; - case HCAsm::Mode::b32: res.push(static_cast(std::get(instr.op1.variant))); break; - case HCAsm::Mode::b64: res.push(static_cast(std::get(instr.op1.variant))); break; - default: - UNREACHABLE(); - } - } else { - switch (md) { - case HCAsm::Mode::b8: res.push(static_cast(std::get(instr.op1.variant))); break; - case HCAsm::Mode::b16: res.push(static_cast(std::get(instr.op1.variant))); break; - case HCAsm::Mode::b32: res.push(static_cast(std::get(instr.op1.variant))); break; - case HCAsm::Mode::b64: res.push(static_cast(std::get(instr.op1.variant))); break; - default: - UNREACHABLE(); - } + } else { + switch (md) { + case HCAsm::Mode::b8: + res.push(static_cast(std::get(instr.op2.variant))); + break; + case HCAsm::Mode::b16: + res.push(static_cast(std::get(instr.op2.variant))); + break; + case HCAsm::Mode::b32: + res.push(static_cast(std::get(instr.op2.variant))); + break; + case HCAsm::Mode::b64: + res.push(static_cast(std::get(instr.op2.variant))); + break; } - break; - case HyperCPU::OperandTypes::M_R: - res.push(std::get(instr.op2.variant)); - res.push(static_cast(instr.op2.reg)); - break; - case HyperCPU::OperandTypes::NONE: - break; - default: - UNREACHABLE(); + } + break; + case HyperCPU::OperandTypes::R: + res.push(static_cast(instr.op1.reg)); + break; + case HyperCPU::OperandTypes::M: + res.push(std::get(instr.op2.variant)); + break; + case HyperCPU::OperandTypes::IMM: + if (std::holds_alternative(instr.op2.variant)) { + switch (md) { + case HCAsm::Mode::b8: + res.push(static_cast(std::get(instr.op1.variant))); + break; + case HCAsm::Mode::b16: + res.push(static_cast(std::get(instr.op1.variant))); + break; + case HCAsm::Mode::b32: + res.push(static_cast(std::get(instr.op1.variant))); + break; + case HCAsm::Mode::b64: + res.push(static_cast(std::get(instr.op1.variant))); + break; + } + } else { + switch (md) { + case HCAsm::Mode::b8: + res.push(static_cast(std::get(instr.op1.variant))); + break; + case HCAsm::Mode::b16: + res.push(static_cast(std::get(instr.op1.variant))); + break; + case HCAsm::Mode::b32: + res.push(static_cast(std::get(instr.op1.variant))); + break; + case HCAsm::Mode::b64: + res.push(static_cast(std::get(instr.op1.variant))); + break; + } + } + break; + case HyperCPU::OperandTypes::M_R: + res.push(std::get(instr.op2.variant)); + res.push(static_cast(instr.op2.reg)); + break; + case HyperCPU::OperandTypes::NONE: + break; } } diff --git a/src/Assembler/Core/BinaryTransformer.hpp b/src/Assembler/Core/BinaryTransformer.hpp index 339244ff..b4ffd47b 100644 --- a/src/Assembler/Core/BinaryTransformer.hpp +++ b/src/Assembler/Core/BinaryTransformer.hpp @@ -1,9 +1,10 @@ #pragma once -#include "PCH/CStd.hpp" -#include "Common/LanguageSpec/Flags.hpp" -#include "Assembler/Core/Compiler.hpp" +#include +#include "Assembler/Core/Compiler.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "PCH/CStd.hpp" namespace HCAsm { struct BinaryResult; @@ -11,19 +12,19 @@ namespace HCAsm { struct Operand; enum class Op1T : std::uint8_t { - R = 0x10, - M = 0x20, - IMM = 0x30, - RM = 0x40, - NONE = 0x50 + R = 0x10, + M = 0x20, + IMM = 0x30, + RM = 0x40, + NONE = 0x50 }; enum class Op2T : std::uint8_t { - R = 0x01, - M = 0x02, - IMM = 0x03, - RM = 0x04, - NONE = 0x05 + R = 0x01, + M = 0x02, + IMM = 0x03, + RM = 0x04, + NONE = 0x05 }; constexpr inline std::uint8_t QuickOR(Op1T a, Op2T b) { @@ -35,61 +36,76 @@ namespace HCAsm { } enum class OperandTypes : std::uint8_t { - R_R = QuickOR(Op1T::R, Op2T::R), - R_RM = QuickOR(Op1T::R, Op2T::RM), - R_M = QuickOR(Op1T::R, Op2T::M), - R_IMM = QuickOR(Op1T::R, Op2T::IMM), - RM_R = QuickOR(Op1T::RM, Op2T::R), - RM_M = QuickOR(Op1T::RM, Op2T::M), - RM_IMM = QuickOR(Op1T::RM, Op2T::IMM), - M_R = QuickOR(Op1T::M, Op2T::R), - R = QuickOR(Op1T::R, Op2T::NONE), - M = QuickOR(Op1T::M, Op2T::NONE), - IMM = QuickOR(Op1T::IMM, Op2T::NONE), - NONE = QuickOR(Op1T::NONE, Op2T::NONE), + R_R = QuickOR(Op1T::R, Op2T::R), + R_RM = QuickOR(Op1T::R, Op2T::RM), + R_M = QuickOR(Op1T::R, Op2T::M), + R_IMM = QuickOR(Op1T::R, Op2T::IMM), + RM_R = QuickOR(Op1T::RM, Op2T::R), + RM_M = QuickOR(Op1T::RM, Op2T::M), + RM_IMM = QuickOR(Op1T::RM, Op2T::IMM), + M_R = QuickOR(Op1T::M, Op2T::R), + R = QuickOR(Op1T::R, Op2T::NONE), + M = QuickOR(Op1T::M, Op2T::NONE), + IMM = QuickOR(Op1T::IMM, Op2T::NONE), + NONE = QuickOR(Op1T::NONE, Op2T::NONE), }; constexpr HyperCPU::OperandTypes QuickCast(std::uint8_t x) { switch (static_cast(x)) { - case OperandTypes::R_R: return HyperCPU::OperandTypes::R_R; - case OperandTypes::R_RM: return HyperCPU::OperandTypes::R_RM; - case OperandTypes::R_M: return HyperCPU::OperandTypes::R_M; - case OperandTypes::R_IMM: return HyperCPU::OperandTypes::R_IMM; - case OperandTypes::RM_R: return HyperCPU::OperandTypes::RM_R; - case OperandTypes::RM_M: return HyperCPU::OperandTypes::RM_M; - case OperandTypes::RM_IMM: return HyperCPU::OperandTypes::RM_IMM; - case OperandTypes::M_R: return HyperCPU::OperandTypes::M_R; - case OperandTypes::R: return HyperCPU::OperandTypes::R; - case OperandTypes::M: return HyperCPU::OperandTypes::M; - case OperandTypes::IMM: return HyperCPU::OperandTypes::IMM; - case OperandTypes::NONE: return HyperCPU::OperandTypes::NONE; - default: - logger.Log(HyperCPU::LogLevel::ERROR, "Invalid operand types!"); - EXIT(1); + case OperandTypes::R_R: + return HyperCPU::OperandTypes::R_R; + case OperandTypes::R_RM: + return HyperCPU::OperandTypes::R_RM; + case OperandTypes::R_M: + return HyperCPU::OperandTypes::R_M; + case OperandTypes::R_IMM: + return HyperCPU::OperandTypes::R_IMM; + case OperandTypes::RM_R: + return HyperCPU::OperandTypes::RM_R; + case OperandTypes::RM_M: + return HyperCPU::OperandTypes::RM_M; + case OperandTypes::RM_IMM: + return HyperCPU::OperandTypes::RM_IMM; + case OperandTypes::M_R: + return HyperCPU::OperandTypes::M_R; + case OperandTypes::R: + return HyperCPU::OperandTypes::R; + case OperandTypes::M: + return HyperCPU::OperandTypes::M; + case OperandTypes::IMM: + return HyperCPU::OperandTypes::IMM; + case OperandTypes::NONE: + return HyperCPU::OperandTypes::NONE; + default: + spdlog::error("Invalid operand types!"); + // TODO: handle error } } constexpr HyperCPU::Mode cast_mode(HCAsm::Mode md) { switch (md) { - case HCAsm::Mode::b8: return HyperCPU::Mode::b8; - case HCAsm::Mode::b16: return HyperCPU::Mode::b16; - case HCAsm::Mode::b32: return HyperCPU::Mode::b32; - case HCAsm::Mode::b64: return HyperCPU::Mode::b64; - default: - UNREACHABLE(); + case HCAsm::Mode::b8: + return HyperCPU::Mode::b8; + case HCAsm::Mode::b16: + return HyperCPU::Mode::b16; + case HCAsm::Mode::b32: + return HyperCPU::Mode::b32; + case HCAsm::Mode::b64: + return HyperCPU::Mode::b64; } } - - class BinaryTransformer { public: - BinaryTransformer(BinaryResult& result, CompilerState* state = nullptr) : res(result), state(state) { } + BinaryTransformer(BinaryResult& result, CompilerState* state = nullptr) + : res(result), state(state) { + } void EncodeInstruction(Instruction& instr); HyperCPU::OperandTypes DetermineOperandTypes(Operand& op1, Operand& op2); + private: BinaryResult& res; CompilerState* state; }; -} +} // namespace HCAsm diff --git a/src/Assembler/Core/Compiler.cpp b/src/Assembler/Core/Compiler.cpp index c2a58ab3..75b55b1d 100644 --- a/src/Assembler/Core/Compiler.cpp +++ b/src/Assembler/Core/Compiler.cpp @@ -1,146 +1,145 @@ -#include "Pog/Pog.hpp" -#include "PCH/CStd.hpp" -#include "Common/LanguageSpec/Flags.hpp" +#include + #include "Assembler/Core/BinaryTransformer.hpp" #include "Assembler/Core/Compiler.hpp" - - -using HyperCPU::LogLevel; +#include "Common/Helpers/Classes.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "PCH/CStd.hpp" +#include "Pog/Pog.hpp" namespace HCAsm { - HyperCPU::Logger logger{HyperCPU::LogLevel::WARNING}; HCAsm::CompilerState* current_state; std::uint64_t current_index = 0; -} +} // namespace HCAsm -HCAsm::HCAsmCompiler::HCAsmCompiler(LogLevel lvl) : pool(32) { - logger = HyperCPU::Logger{lvl}; +// TODO: fix constants +HCAsm::HCAsmCompiler::HCAsmCompiler() + : pool(32) { // Setup tokens parser.token("[^\\S\n]+") - .action([this]([[maybe_unused]] std::string_view tok) -> Value { - parser.get_line_offset() += tok.length(); - return {}; - }); - parser.token("\\/\\/.*"); // Single line comment + .action([this]([[maybe_unused]] std::string_view tok) -> Value { + parser.get_line_offset() += tok.length(); + return {}; + }); + parser.token("\\/\\/.*"); // Single line comment parser.token("\\/\\*[\\S\\s]+\\*\\/"); /* Multi-line comment */ parser.token(R"(\+)") - .symbol("+"); + .symbol("+"); parser.token(R"(-)") - .symbol("-"); + .symbol("-"); parser.token(",") - .symbol(","); + .symbol(","); parser.token("\\[") - .symbol("["); + .symbol("["); parser.token("\\]") - .symbol("]"); + .symbol("]"); parser.token(";") - .symbol(";"); + .symbol(";"); parser.token(":") - .symbol(":"); + .symbol(":"); parser.token(R"(\n)") - .action([this]([[maybe_unused]] std::string_view tok) -> Value { - ++parser.get_line_counter(); - parser.reset_line_offset(); - return {}; - }); + .action([this]([[maybe_unused]] std::string_view tok) -> Value { + ++parser.get_line_counter(); + parser.reset_line_offset(); + return {}; + }); parser.token(R"(\.attr\(entry\))") - .symbol("entry"); + .symbol("entry"); parser.token("#use") - .fullword() - .symbol("use"); + .fullword() + .symbol("use"); parser.token("\\.b8") - .fullword() - .symbol(".b8"); + .fullword() + .symbol(".b8"); parser.token("\\.b16") - .fullword() - .symbol(".b16"); + .fullword() + .symbol(".b16"); parser.token("\\.b32") - .fullword() - .symbol(".b32"); + .fullword() + .symbol(".b32"); parser.token("\\.b64") - .fullword() - .symbol(".b64"); + .fullword() + .symbol(".b64"); parser.token("[a-zA-Z_][a-zA-Z0-9_]*") - .symbol("ident") - .action(TokenizeIdentifier); + .symbol("ident") + .action(TokenizeIdentifier); parser.token("\"((?:\\\\[\\s\\S]|[^\"\\\\])*)\"") - .symbol("string") - .action(TokenizeString); + .symbol("string") + .action(TokenizeString); parser.token(R"(0s[0-9]+)") - .symbol("sint") - .action(TokenizeSignedInt); + .symbol("sint") + .action(TokenizeSignedInt); parser.token(R"(0u[0-9]+)") - .symbol("uint") - .action(TokenizeUnsignedInt); + .symbol("uint") + .action(TokenizeUnsignedInt); parser.token(R"(0x[0-9a-fA-F]+)") - .symbol("hex") - .action(TokenizeHexadecimal); + .symbol("hex") + .action(TokenizeHexadecimal); parser.token(R"(0b[0-1]+)") - .symbol("binary") - .action(TokenizeBinary); + .symbol("binary") + .action(TokenizeBinary); parser.token(R"('.')") - .symbol("char") - .action(TokenizeChar); + .symbol("char") + .action(TokenizeChar); parser.end_token().action([this](std::string_view) -> Value { parser.pop_input_stream(); return {}; }); - logger.Log(HyperCPU::LogLevel::DEBUG, "Tokens configured"); + spdlog::debug("Tokens configured"); // Setup parser rules parser.set_start_symbol("statements"); parser.rule("statements") - .production("statements", "statement") - .production("statement"); + .production("statements", "statement") + .production("statement"); parser.rule("statement") - /* Reserved statements */ - .production(".b8", "operand", ";", CompileRawValueb8) - .production(".b8", "string", ";", CompileRawValueb8_str) - .production(".b16", "operand", ";", CompileRawValueb16) - .production(".b32", "operand", ";", CompileRawValueb32) - .production(".b64", "operand", ";", CompileRawValueb64) - .production("ident", "operand", ",", "operand", ";", CompileStatement1) - .production("ident", "operand", ";", CompileStatement2) - .production("ident", ";", CompileStatement3) - .production("entry", "ident", ":", CompileEntryLabel) - .production("ident", ":", CompileLabel); + /* Reserved statements */ + .production(".b8", "operand", ";", CompileRawValueb8) + .production(".b8", "string", ";", CompileRawValueb8_str) + .production(".b16", "operand", ";", CompileRawValueb16) + .production(".b32", "operand", ";", CompileRawValueb32) + .production(".b64", "operand", ";", CompileRawValueb64) + .production("ident", "operand", ",", "operand", ";", CompileStatement1) + .production("ident", "operand", ";", CompileStatement2) + .production("ident", ";", CompileStatement3) + .production("entry", "ident", ":", CompileEntryLabel) + .production("ident", ":", CompileLabel); parser.rule("operand") - .production("[", "hex", "]", ParseOperand1) - .production("[", "ident", "]", ParseOperand2) - .production("[", "ident", "+", "uint", "]", ParseOperand3) - .production("[", "ident", "+", "hex", "]", ParseOperand3) - .production("[", "ident", "+", "binary", "]", ParseOperand3) - .production("ident", "ident", "[", "hex", "]", ParseOperand4) - .production("ident", "ident", "[", "ident", "]", ParseOperand5) - .production("ident", "ident", "[", "ident", "+", "uint", "]", ParseOperand6) - .production("ident", "ident", "[", "ident", "+", "hex", "]", ParseOperand6) - .production("ident", "ident", "[", "ident", "+", "binary", "]", ParseOperand6) - .production("ident", "hex", ParseOperand10) - .production("ident", "binary", ParseOperand10) - .production("ident", "uint", ParseOperand10) - .production("ident", "char", ParseOperand10) - .production("ident", "sint", ParseOperand11) - .production("ident", "ident", ParseOperand12) - .production("hex", ParseOperand8) - .production("binary", ParseOperand8) - .production("sint", ParseOperand7) - .production("uint", ParseOperand8) - .production("char", ParseOperand8) - .production("ident", ParseOperand9); - + .production("[", "hex", "]", ParseOperand1) + .production("[", "ident", "]", ParseOperand2) + .production("[", "ident", "+", "uint", "]", ParseOperand3) + .production("[", "ident", "+", "hex", "]", ParseOperand3) + .production("[", "ident", "+", "binary", "]", ParseOperand3) + .production("ident", "ident", "[", "hex", "]", ParseOperand4) + .production("ident", "ident", "[", "ident", "]", ParseOperand5) + .production("ident", "ident", "[", "ident", "+", "uint", "]", ParseOperand6) + .production("ident", "ident", "[", "ident", "+", "hex", "]", ParseOperand6) + .production("ident", "ident", "[", "ident", "+", "binary", "]", ParseOperand6) + .production("ident", "hex", ParseOperand10) + .production("ident", "binary", ParseOperand10) + .production("ident", "uint", ParseOperand10) + .production("ident", "char", ParseOperand10) + .production("ident", "sint", ParseOperand11) + .production("ident", "ident", ParseOperand12) + .production("hex", ParseOperand8) + .production("binary", ParseOperand8) + .production("sint", ParseOperand7) + .production("uint", ParseOperand8) + .production("char", ParseOperand8) + .production("ident", ParseOperand9); } HCAsm::BinaryResult HCAsm::HCAsmCompiler::Compile(std::string& contents, std::uint32_t& code_size) { files.push(std::move(contents)); - logger.Log(LogLevel::DEBUG, "Stage 1 compiling - transforming to IR"); + spdlog::info("Stage 1 compiling - transforming to IR"); CompilerState ir = TransformToIR(files.back()); - logger.Log(LogLevel::DEBUG, "Stage 2 compiling - transforming to binary"); + spdlog::info("Stage 2 compiling - transforming to binary"); auto binary = TransformToBinary(ir); code_size = ir.code_size; @@ -154,8 +153,8 @@ HCAsm::CompilerState HCAsm::HCAsmCompiler::TransformToIR(std::string& src) { parser.set_compiler_state(&state); parser.prepare(); - logger.Log(LogLevel::DEBUG, "Parser prepared."); - logger.Log(LogLevel::DEBUG, "Compiling..."); + spdlog::info("Parser prepared."); + spdlog::info("Compiling..."); parser.parse(src); current_state = nullptr; @@ -164,144 +163,131 @@ HCAsm::CompilerState HCAsm::HCAsmCompiler::TransformToIR(std::string& src) { constexpr inline std::uint8_t HCAsm::HCAsmCompiler::OperandSize(HCAsm::OperandType op) { switch (op) { - case HCAsm::OperandType::mem_reg_add_int: - case HCAsm::OperandType::memaddr_reg: - case HCAsm::OperandType::reg: - return 1; - case HCAsm::OperandType::memaddr_int: - case HCAsm::OperandType::sint: - case HCAsm::OperandType::uint: - case HCAsm::OperandType::label: - return 8; - default: UNREACHABLE(); + case HCAsm::OperandType::mem_reg_add_int: + case HCAsm::OperandType::memaddr_reg: + case HCAsm::OperandType::reg: + return 1; + case HCAsm::OperandType::memaddr_int: + case HCAsm::OperandType::sint: + case HCAsm::OperandType::uint: + case HCAsm::OperandType::label: + return 8; } } std::uint8_t HCAsm::HCAsmCompiler::ModeToSize(const Operand& op) { switch (op.mode) { - case Mode::b8_str: - return std::get>(op.variant)->size(); - case Mode::b8: - return 1; - case Mode::b16: - return 2; - case Mode::b32: - return 4; - case Mode::b64_label: - case Mode::b64: - return 8; - default: - ABORT(); + case Mode::b8_str: + return std::get>(op.variant)->size(); + case Mode::b8: + return 1; + case Mode::b16: + return 2; + case Mode::b32: + return 4; + case Mode::b64_label: + case Mode::b64: + return 8; } } std::uint8_t HCAsm::HCAsmCompiler::ModeToSize(Mode md) { switch (md) { - case Mode::b8: - return 1; - case Mode::b16: - return 2; - case Mode::b32: - return 4; - case Mode::b64_label: - case Mode::b64: - return 8; - default: - ABORT(); + case Mode::b8: + return 1; + case Mode::b16: + return 2; + case Mode::b32: + return 4; + case Mode::b64_label: + case Mode::b64: + return 8; } } std::uint8_t HCAsm::HCAsmCompiler::InstructionSize(HCAsm::Instruction& instr) { switch (instr.opcode) { - case HyperCPU::Opcode::IRET: - return 2; - default: - break; + case HyperCPU::Opcode::IRET: + return 2; + default: + break; } std::uint8_t result = 3; // Opcode is always two bytes long + one byte for operand types switch (instr.op1.type) { - case OperandType::reg: // R_* - switch (instr.op2.type) { - case OperandType::memaddr_reg: // R_RM - [[fallthrough]]; - case OperandType::reg: // R_R - result += 2; - break; - case OperandType::sint: - [[fallthrough]]; - case OperandType::uint: // R_IMM - result += 1 + ModeToSize(instr.op1); - break; - case OperandType::label: - [[fallthrough]]; - case OperandType::memaddr_int: // R_M - result += 9; - break; - case OperandType::mem_reg_add_int: - result += 10; - break; - case OperandType::none: // R - result += 1; - break; - default: - ABORT(); - } - break; - case OperandType::mem_reg_add_int: - ++result; + case OperandType::reg: // R_* + switch (instr.op2.type) { + case OperandType::memaddr_reg: // R_RM [[fallthrough]]; - case OperandType::memaddr_reg: - switch (instr.op2.type) { - case OperandType::reg: // RM_R - result += 2; - break; - case OperandType::sint: - [[fallthrough]]; - case OperandType::uint: // RM_IMM - result += 1 + ModeToSize(instr.op1); - break; - case OperandType::label: - [[fallthrough]]; - case OperandType::memaddr_int: // RM_M - result += 9; - break; - case OperandType::mem_reg_add_int: - result += 10; - break; - default: - ABORT(); - } + case OperandType::reg: // R_R + result += 2; break; case OperandType::sint: [[fallthrough]]; - case OperandType::uint: // IMM - switch (instr.op1.mode) { - case Mode::none: - ThrowError(*(instr.op1.tokens[0]), parser, "unknown operand size"); - break; - default: - result += ModeToSize(instr.op1); - break; - } + case OperandType::uint: // R_IMM + result += 1 + ModeToSize(instr.op1); break; - case OperandType::memaddr_int: - result += 8; - switch (instr.op2.type) { - case OperandType::reg: // M_R - ++result; - break; - default: - ABORT(); - } + case OperandType::label: + [[fallthrough]]; + case OperandType::memaddr_int: // R_M + result += 9; + break; + case OperandType::mem_reg_add_int: + result += 10; + break; + case OperandType::none: // R + result += 1; + break; + } + break; + case OperandType::mem_reg_add_int: + ++result; + [[fallthrough]]; + case OperandType::memaddr_reg: + switch (instr.op2.type) { + case OperandType::reg: // RM_R + result += 2; + break; + case OperandType::sint: + [[fallthrough]]; + case OperandType::uint: // RM_IMM + result += 1 + ModeToSize(instr.op1); break; case OperandType::label: - result += 8; + [[fallthrough]]; + case OperandType::memaddr_int: // RM_M + result += 9; + break; + case OperandType::mem_reg_add_int: + result += 10; break; - case OperandType::none: + } + break; + case OperandType::sint: + [[fallthrough]]; + case OperandType::uint: // IMM + switch (instr.op1.mode) { + case Mode::none: + ThrowError(*(instr.op1.tokens[0]), parser, "unknown operand size"); break; default: - ABORT(); + result += ModeToSize(instr.op1); + break; + } + break; + case OperandType::memaddr_int: + result += 8; + switch (instr.op2.type) { + case OperandType::reg: // M_R + ++result; + break; + } + break; + case OperandType::label: + result += 8; + break; + case OperandType::none: + break; } return result; @@ -309,44 +295,34 @@ std::uint8_t HCAsm::HCAsmCompiler::InstructionSize(HCAsm::Instruction& instr) { HCAsm::BinaryResult HCAsm::HCAsmCompiler::TransformToBinary(HCAsm::CompilerState& ir) { // Count code size - pass 1 - logger.Log(LogLevel::DEBUG, "Running pass 1 - counting code size"); + spdlog::info("Running pass 1 - counting code size"); for (auto& instr : ir.ir) { - VisitVariant(instr, - [this, &ir](Instruction& instruction) mutable -> void { - ir.code_size += InstructionSize(instruction); - }, - [&ir](Label& label) mutable -> void { + VisitVariant(instr, [this, &ir](Instruction& instruction) mutable -> void { ir.code_size += InstructionSize(instruction); }, [&ir](Label& label) mutable -> void { ir.labels[label.name] = ir.code_size; if (label.is_entry_point) { ir.entry_point = ir.code_size; - } - }, - [&ir](RawValue& raw) mutable -> void { - ir.code_size += [&raw]() -> std::uint8_t { - switch (raw.mode) { - case Mode::b8_str: - return std::get>(raw.value.variant)->size(); - case Mode::b8: - return 1; - case Mode::b16: - return 2; - case Mode::b32: - return 4; - case Mode::b64_label: - case Mode::b64: - return 8; - default: - ABORT(); - } - }(); - }); + } }, [&ir](RawValue& raw) mutable -> void { ir.code_size += [&raw]() -> std::uint8_t { + switch (raw.mode) { + case Mode::b8_str: + return std::get>(raw.value.variant)->size(); + case Mode::b8: + return 1; + case Mode::b16: + return 2; + case Mode::b32: + return 4; + case Mode::b64_label: + case Mode::b64: + return 8; + } + }(); }); } // Resolve references - pass 2 - logger.Log(LogLevel::DEBUG, fmt::format("{} label references are waiting for resolve", ir.pending_resolves.size())); + spdlog::info("{} label references are waiting for resolve", ir.pending_resolves.size()); if (!ir.pending_resolves.empty()) { - logger.Log(LogLevel::DEBUG, "Resolving label references"); + spdlog::info("Resolving label references"); for (auto& args : ir.pending_resolves) { auto& instr = ir.ir[args.idx]; @@ -362,22 +338,18 @@ HCAsm::BinaryResult HCAsm::HCAsmCompiler::TransformToBinary(HCAsm::CompilerState } // Compile code - pass 3 - BinaryResult binary = { new unsigned char[ir.code_size] }; + BinaryResult binary = {new unsigned char[ir.code_size]}; if (!binary.binary) { - logger.Log(LogLevel::ERROR, "Failed to allocate memory for binary data!"); - ABORT(); + spdlog::error("Failed to allocate memory for binary data!"); + // TODO: handle error } - logger.Log(LogLevel::DEBUG, "Running pass 3 - compiling"); + spdlog::info("Running pass 3 - compiling"); BinaryTransformer transformer(binary, &ir); for (auto& instr : ir.ir) { - VisitVariant(instr, - [&transformer](Instruction& instruction) mutable -> void { - transformer.EncodeInstruction(instruction); - }, - [&binary, &ir, this](RawValue& raw) mutable -> void { + VisitVariant(instr, [&transformer](Instruction& instruction) mutable -> void { transformer.EncodeInstruction(instruction); }, [&binary, &ir, this](RawValue& raw) mutable -> void { switch (raw.mode) { case Mode::b8_str: binary.push(*std::get>(raw.value.variant)); @@ -400,10 +372,7 @@ HCAsm::BinaryResult HCAsm::HCAsmCompiler::TransformToBinary(HCAsm::CompilerState case Mode::b64: binary.push(static_cast(std::get(raw.value.variant))); break; - default: ABORT(); - } - }, - [](Label&){}); + } }, [](Label&) {}); } binary.entry_point = ir.entry_point; @@ -419,7 +388,7 @@ std::string_view HCAsm::FindLine(const pog::LineSpecialization& line_spec, const while (end < str.size()) { if (str[end] == '\n') { if (current_line == line_spec.line) { - return std::string_view { str.begin() + start, end - start }; + return std::string_view{str.begin() + start, end - start}; } start = end + 1; current_line++; @@ -428,21 +397,21 @@ std::string_view HCAsm::FindLine(const pog::LineSpecialization& line_spec, const } if (current_line == line_spec.line) { - return std::string_view { str.begin() + start, str.end() }; + return std::string_view{str.begin() + start, str.end()}; } throw std::out_of_range("Line number out of range"); } [[noreturn]] void HCAsm::ThrowError(pog::TokenWithLineSpec& err_token, pog::Parser& parser, std::string err_msg) { - logger.Log(HyperCPU::LogLevel::ERROR, "error: {}", err_msg); + spdlog::error("error: {}", err_msg); auto line = FindLine(err_token.line_spec, parser.get_top_file()); - HyperCPU::println("{} | {}", err_token.line_spec.line, line); - HyperCPU::println("{:<{}} | {:<{}}{}", - "", std::to_string(err_token.line_spec.line).length(), - "", err_token.line_spec.offset, - std::string(err_token.line_spec.length, '^')); - EXIT(1); + spdlog::debug("{} | {}", err_token.line_spec.line, line); + spdlog::debug("{:<{}} | {:<{}}{}", + "", std::to_string(err_token.line_spec.line).length(), + "", err_token.line_spec.offset, + std::string(err_token.line_spec.length, '^')); + // handle error } void HCAsm::WriteResultFile(HyperCPU::FileType type, HCAsm::BinaryResult& result, std::ofstream& output, std::uint32_t code_size, std::uint32_t entry_point) { @@ -456,5 +425,3 @@ void HCAsm::WriteResultFile(HyperCPU::FileType type, HCAsm::BinaryResult& result output.write(reinterpret_cast(result.binary), code_size); } -de_size); -} diff --git a/src/Assembler/Core/Compiler.hpp b/src/Assembler/Core/Compiler.hpp index 4c6a7d39..71f88f1e 100644 --- a/src/Assembler/Core/Compiler.hpp +++ b/src/Assembler/Core/Compiler.hpp @@ -2,11 +2,11 @@ #include -#include "Pog/Pog.hpp" -#include "PCH/CStd.hpp" -#include "Common/LanguageSpec/Opcodes.hpp" #include "Common/LanguageSpec/Flags.hpp" - +#include "Common/LanguageSpec/Opcodes.hpp" +#include "Common/LanguageSpec/Registers.hpp" +#include "PCH/CStd.hpp" +#include "Pog/Pog.hpp" namespace HCAsm { enum class ValueType { @@ -30,7 +30,7 @@ namespace HCAsm { }; enum class Mode : std::uint8_t { - b8 = 0b00, + b8 = 0b00, b16 = 0b01, b32 = 0b10, b64 = 0b11, @@ -43,7 +43,7 @@ namespace HCAsm { struct Operand { OperandType type; - HyperCPU::Registers reg; + HyperCPU::Reg reg; enum Mode mode; bool needs_resolve; std::array, hpool::ReallocationPolicy::OffsetRealloc>, 2> tokens; @@ -70,18 +70,22 @@ namespace HCAsm { bool is_entry_point; }; - template + template concept Integral = std::is_integral_v; struct BinaryResult { - BinaryResult() : binary(nullptr), ptr(0), entry_point(0) { } - BinaryResult(unsigned char* ptr) : binary(ptr), ptr(0), entry_point(0) { } + BinaryResult() + : binary(nullptr), ptr(0), entry_point(0) { + } + BinaryResult(unsigned char* ptr) + : binary(ptr), ptr(0), entry_point(0) { + } unsigned char* binary; std::uint64_t ptr; std::uint32_t entry_point; - template + template constexpr inline void push(T data) { std::memcpy(binary + ptr, &data, sizeof(data)); ptr += sizeof(data); @@ -103,25 +107,26 @@ namespace HCAsm { }; // Some magic for std::visit - template + template struct MakeOverload : T... { using T::operator()...; }; - template + template MakeOverload(T...) -> MakeOverload; - template + template constexpr inline decltype(auto) VisitVariant(Variant&& variant, Alternatives&&... alternatives) { return std::visit( - MakeOverload{std::forward(alternatives)..., [](auto const&){}}, - variant - ); + MakeOverload{std::forward(alternatives)..., [](auto const&) {}}, + variant); } // Needs improvements and optimizations struct CompilerState { - CompilerState(hpool::HPool, hpool::ReallocationPolicy::OffsetRealloc>& pool) : pool(pool), code_size(0), entry_point(0) { } + CompilerState(hpool::HPool, hpool::ReallocationPolicy::OffsetRealloc>& pool) + : pool(pool), code_size(0), entry_point(0) { + } std::vector pending_resolves; std::vector> tmp_args; @@ -132,54 +137,52 @@ namespace HCAsm { std::uint32_t entry_point; }; - constexpr inline Mode ModeFromRegister(HyperCPU::Registers reg) { + constexpr inline Mode ModeFromRegister(HyperCPU::Reg reg) { using namespace HyperCPU; switch (reg) { - case Registers::X0: - case Registers::X1: - case Registers::X2: - case Registers::X3: - case Registers::X4: - case Registers::X5: - case Registers::X6: - case Registers::X7: - case Registers::XBP: - case Registers::XSP: - case Registers::XIP: - return Mode::b64; - case Registers::XH0: - case Registers::XH1: - case Registers::XH2: - case Registers::XH3: - case Registers::XH4: - case Registers::XH5: - case Registers::XH6: - case Registers::XH7: - case Registers::XL0: - case Registers::XL1: - case Registers::XL2: - case Registers::XL3: - case Registers::XL4: - case Registers::XL5: - case Registers::XL6: - case Registers::XL7: - return Mode::b32; - case Registers::XLL0: - case Registers::XLL1: - case Registers::XLL2: - case Registers::XLL3: - return Mode::b16; - case Registers::XLLH0: - case Registers::XLLH1: - case Registers::XLLH2: - case Registers::XLLH3: - case Registers::XLLL0: - case Registers::XLLL1: - case Registers::XLLL2: - case Registers::XLLL3: - return Mode::b8; - default: - UNREACHABLE(); + case Reg::X0: + case Reg::X1: + case Reg::X2: + case Reg::X3: + case Reg::X4: + case Reg::X5: + case Reg::X6: + case Reg::X7: + case Reg::XBP: + case Reg::XSP: + case Reg::XIP: + return Mode::b64; + case Reg::XH0: + case Reg::XH1: + case Reg::XH2: + case Reg::XH3: + case Reg::XH4: + case Reg::XH5: + case Reg::XH6: + case Reg::XH7: + case Reg::XL0: + case Reg::XL1: + case Reg::XL2: + case Reg::XL3: + case Reg::XL4: + case Reg::XL5: + case Reg::XL6: + case Reg::XL7: + return Mode::b32; + case Reg::XLL0: + case Reg::XLL1: + case Reg::XLL2: + case Reg::XLL3: + return Mode::b16; + case Reg::XLLH0: + case Reg::XLLH1: + case Reg::XLLH2: + case Reg::XLLH3: + case Reg::XLLL0: + case Reg::XLLL1: + case Reg::XLLL2: + case Reg::XLLL3: + return Mode::b8; } } @@ -220,13 +223,12 @@ namespace HCAsm { Value CompileRawValueb32(pog::Parser&, std::vector>&& args); Value CompileRawValueb64(pog::Parser&, std::vector>&& args); - extern HyperCPU::Logger logger; extern CompilerState* current_state; extern std::uint64_t current_index; class HCAsmCompiler { public: - HCAsmCompiler(HyperCPU::LogLevel lvl = HyperCPU::LogLevel::WARNING); + HCAsmCompiler(); BinaryResult Compile(std::string& contents, std::uint32_t& code_size); CompilerState TransformToIR(std::string& src); @@ -244,4 +246,4 @@ namespace HCAsm { std::uint8_t ModeToSize(Mode md); }; -} +} // namespace HCAsm diff --git a/src/Assembler/Core/ModeNameAssoc.hpp b/src/Assembler/Core/ModeNameAssoc.hpp index 849d9a30..42dea1ff 100644 --- a/src/Assembler/Core/ModeNameAssoc.hpp +++ b/src/Assembler/Core/ModeNameAssoc.hpp @@ -2,9 +2,8 @@ #include -#include "PCH/CStd.hpp" #include "Assembler/Core/Compiler.hpp" - +#include "PCH/CStd.hpp" constexpr inline const auto mode_assoc = mapbox::eternal::hash_map({ {"b8", HCAsm::Mode::b8}, diff --git a/src/Assembler/Core/OpcodeNameAssoc.hpp b/src/Assembler/Core/OpcodeNameAssoc.hpp index 7a4b0641..3364eb7a 100644 --- a/src/Assembler/Core/OpcodeNameAssoc.hpp +++ b/src/Assembler/Core/OpcodeNameAssoc.hpp @@ -2,45 +2,42 @@ #include -#include "PCH/CStd.hpp" #include "Common/LanguageSpec/Opcodes.hpp" +#include "PCH/CStd.hpp" - -constexpr inline const auto opcode_assoc = mapbox::eternal::hash_map({ - {"adc", HyperCPU::Opcode::ADC}, - {"add", HyperCPU::Opcode::ADD}, - {"and", HyperCPU::Opcode::AND}, - {"andn", HyperCPU::Opcode::ANDN}, - {"bswap", HyperCPU::Opcode::BSWAP}, - {"call", HyperCPU::Opcode::CALL}, - {"ccrf", HyperCPU::Opcode::CCRF}, - {"covf", HyperCPU::Opcode::COVF}, - {"cudf", HyperCPU::Opcode::CUDF}, - {"hid", HyperCPU::Opcode::HID}, - {"inc", HyperCPU::Opcode::INC}, - {"dec", HyperCPU::Opcode::DEC}, - {"div", HyperCPU::Opcode::DIV}, - {"mul", HyperCPU::Opcode::MUL}, - {"sub", HyperCPU::Opcode::SUB}, - {"shfr", HyperCPU::Opcode::SHFR}, - {"shfl", HyperCPU::Opcode::SHFL}, - {"or", HyperCPU::Opcode::OR}, - {"halt", HyperCPU::Opcode::HALT}, - {"loivt", HyperCPU::Opcode::LOIVT}, - {"intr", HyperCPU::Opcode::INTR}, - {"ret", HyperCPU::Opcode::RET}, - {"iret", HyperCPU::Opcode::IRET}, - {"mov", HyperCPU::Opcode::MOV}, - {"read", HyperCPU::Opcode::READ}, - {"write", HyperCPU::Opcode::WRITE}, - {"jmp", HyperCPU::Opcode::JMP}, - {"push", HyperCPU::Opcode::PUSH}, - {"pop", HyperCPU::Opcode::POP}, - {"calle", HyperCPU::Opcode::CALLE}, - {"callgr",HyperCPU::Opcode::CALLGR}, - {"calll", HyperCPU::Opcode::CALLL}, - {"jme", HyperCPU::Opcode::JME}, - {"jmgr", HyperCPU::Opcode::JMGR}, - {"jml", HyperCPU::Opcode::JML}, - {"cmp", HyperCPU::Opcode::CMP} -}); +constexpr inline const auto opcode_assoc = mapbox::eternal::hash_map({{"adc", HyperCPU::Opcode::ADC}, + {"add", HyperCPU::Opcode::ADD}, + {"and", HyperCPU::Opcode::AND}, + {"andn", HyperCPU::Opcode::ANDN}, + {"bswap", HyperCPU::Opcode::BSWAP}, + {"call", HyperCPU::Opcode::CALL}, + {"ccrf", HyperCPU::Opcode::CCRF}, + {"covf", HyperCPU::Opcode::COVF}, + {"cudf", HyperCPU::Opcode::CUDF}, + {"hid", HyperCPU::Opcode::HID}, + {"inc", HyperCPU::Opcode::INC}, + {"dec", HyperCPU::Opcode::DEC}, + {"div", HyperCPU::Opcode::DIV}, + {"mul", HyperCPU::Opcode::MUL}, + {"sub", HyperCPU::Opcode::SUB}, + {"shfr", HyperCPU::Opcode::SHFR}, + {"shfl", HyperCPU::Opcode::SHFL}, + {"or", HyperCPU::Opcode::OR}, + {"halt", HyperCPU::Opcode::HALT}, + {"loivt", HyperCPU::Opcode::LOIVT}, + {"intr", HyperCPU::Opcode::INTR}, + {"ret", HyperCPU::Opcode::RET}, + {"iret", HyperCPU::Opcode::IRET}, + {"mov", HyperCPU::Opcode::MOV}, + {"read", HyperCPU::Opcode::READ}, + {"write", HyperCPU::Opcode::WRITE}, + {"jmp", HyperCPU::Opcode::JMP}, + {"push", HyperCPU::Opcode::PUSH}, + {"pop", HyperCPU::Opcode::POP}, + {"calle", HyperCPU::Opcode::CALLE}, + {"callgr", HyperCPU::Opcode::CALLGR}, + {"calll", HyperCPU::Opcode::CALLL}, + {"jme", HyperCPU::Opcode::JME}, + {"jmgr", HyperCPU::Opcode::JMGR}, + {"jml", HyperCPU::Opcode::JML}, + {"cmp", HyperCPU::Opcode::CMP}}); diff --git a/src/Assembler/Core/Parsers.cpp b/src/Assembler/Core/Parsers.cpp index 22d5e540..af56dd90 100644 --- a/src/Assembler/Core/Parsers.cpp +++ b/src/Assembler/Core/Parsers.cpp @@ -1,20 +1,18 @@ -#include "Pog/Pog.hpp" -#include "PCH/CStd.hpp" +#include "Assembler/Core/Compiler.hpp" #include "Assembler/Core/ModeNameAssoc.hpp" #include "Assembler/Core/RegNameAssoc.hpp" -#include "Assembler/Core/Compiler.hpp" +#include "PCH/CStd.hpp" +#include "Pog/Pog.hpp" using HCAsm::Value; Value HCAsm::ParseOperand1(pog::Parser& parser, std::vector>&& args) { return { - .val = Operand { - .type = HCAsm::OperandType::memaddr_int, - .mode = HCAsm::Mode::none, - .tokens = { parser.get_compiler_state()->pool.allocate(std::move(args[1])) }, - .variant = { std::get(args[1].value.val) } - } - }; + .val = Operand{ + .type = HCAsm::OperandType::memaddr_int, + .mode = HCAsm::Mode::none, + .tokens = {parser.get_compiler_state()->pool.allocate(std::move(args[1]))}, + .variant = {std::get(args[1].value.val)}}}; } Value HCAsm::ParseOperand2(pog::Parser& parser, std::vector>&& args) { @@ -22,27 +20,21 @@ Value HCAsm::ParseOperand2(pog::Parser& parser, std::vectorpool.allocate(std::move(args[1])) - } - } - }; + .val = Operand{ + .type = HCAsm::OperandType::memaddr_reg, + .reg = registers_assoc.at(reg.c_str()), + .mode = HCAsm::Mode::none, + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[1]))}}}; } else { return { - .val = Operand { - .type = HCAsm::OperandType::memaddr_lbl, - .mode = HCAsm::Mode::b64, - .needs_resolve = !parser.get_compiler_state()->labels.contains(reg), - .tokens = { - parser.get_compiler_state()->pool.allocate(std::move(args[1])) - }, - .variant = { std::make_shared(reg) } - } - }; + .val = Operand{ + .type = HCAsm::OperandType::memaddr_lbl, + .mode = HCAsm::Mode::b64, + .needs_resolve = !parser.get_compiler_state()->labels.contains(reg), + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[1]))}, + .variant = {std::make_shared(reg)}}}; } } @@ -51,28 +43,25 @@ Value HCAsm::ParseOperand3(pog::Parser& parser, std::vector(args[1].value.val))); + args[1], + parser, + fmt::format("expected register, got unknown identifier \"{}\"", std::get(args[1].value.val))); } else if (std::get(args[3].value.val) > 255) [[unlikely]] { ThrowError( - args[3], - parser, - fmt::format("out of bounds integer provided: {} > 255", std::get(args[3].value.val))); + args[3], + parser, + fmt::format("out of bounds integer provided: {} > 255", std::get(args[3].value.val))); } return { - .val = Operand { - .type = HCAsm::OperandType::mem_reg_add_int, - .reg = registers_assoc.at(reg.c_str()), - .mode = HCAsm::Mode::none, - .tokens = { - parser.get_compiler_state()->pool.allocate(std::move(args[1])), - parser.get_compiler_state()->pool.allocate(std::move(args[3])) - }, - .variant = { std::get(args[3].value.val) } - } - }; + .val = Operand{ + .type = HCAsm::OperandType::mem_reg_add_int, + .reg = registers_assoc.at(reg.c_str()), + .mode = HCAsm::Mode::none, + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[1])), + parser.get_compiler_state()->pool.allocate(std::move(args[3]))}, + .variant = {std::get(args[3].value.val)}}}; } Value HCAsm::ParseOperand4(pog::Parser& parser, std::vector>&& args) { @@ -80,26 +69,23 @@ Value HCAsm::ParseOperand4(pog::Parser& parser, std::vector(args[1].value.val) != "ptr") { ThrowError( - args[1], - parser, - fmt::format("unknown keyword \"{}\" specified, \"ptr\" expected", std::get(args[1].value.val))); + args[1], + parser, + fmt::format("unknown keyword \"{}\" specified, \"ptr\" expected", std::get(args[1].value.val))); } return { - .val = Operand { - .type = HCAsm::OperandType::memaddr_int, - .mode = mode_assoc.at(Mode.c_str()), - .tokens = { - parser.get_compiler_state()->pool.allocate(std::move(args[3])) - }, - .variant = { std::get(args[3].value.val) } - } - }; + .val = Operand{ + .type = HCAsm::OperandType::memaddr_int, + .mode = mode_assoc.at(Mode.c_str()), + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[3]))}, + .variant = {std::get(args[3].value.val)}}}; } Value HCAsm::ParseOperand5(pog::Parser& parser, std::vector>&& args) { @@ -108,31 +94,28 @@ Value HCAsm::ParseOperand5(pog::Parser& parser, std::vector(args[3].value.val))); + args[3], + parser, + fmt::format("expected register, got unknown identifier \"{}\"", std::get(args[3].value.val))); } else if (!mode_assoc.contains(Mode.c_str())) [[unlikely]] { ThrowError( - args[0], - parser, - fmt::format("unknown data size specified: \"{}\"", Mode)); + args[0], + parser, + fmt::format("unknown data size specified: \"{}\"", Mode)); } else if (std::get(args[1].value.val) != "ptr") [[unlikely]] { ThrowError( - args[1], - parser, - fmt::format("unknown keyword \"{}\" specified, \"ptr\" expected", std::get(args[1].value.val))); + args[1], + parser, + fmt::format("unknown keyword \"{}\" specified, \"ptr\" expected", std::get(args[1].value.val))); } return { - .val = Operand { - .type = HCAsm::OperandType::memaddr_reg, - .reg = registers_assoc.at(reg.c_str()), - .mode = mode_assoc.at(Mode.c_str()), - .tokens = { - parser.get_compiler_state()->pool.allocate(std::move(args[3])) - } - } - }; + .val = Operand{ + .type = HCAsm::OperandType::memaddr_reg, + .reg = registers_assoc.at(reg.c_str()), + .mode = mode_assoc.at(Mode.c_str()), + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[3]))}}}; } Value HCAsm::ParseOperand6(pog::Parser& parser, std::vector>&& args) { @@ -141,63 +124,54 @@ Value HCAsm::ParseOperand6(pog::Parser& parser, std::vector(args[3].value.val))); + args[3], + parser, + fmt::format("expected register, got unknown identifier \"{}\"", std::get(args[3].value.val))); } else if (!mode_assoc.contains(Mode.c_str())) { ThrowError( - args[0], - parser, - fmt::format("unknown data size specified: \"{}\"", Mode)); + args[0], + parser, + fmt::format("unknown data size specified: \"{}\"", Mode)); } else if (std::get(args[1].value.val) != "ptr") { ThrowError( - args[1], - parser, - fmt::format("unknown keyword \"{}\" specified, \"ptr\" expected", std::get(args[1].value.val))); + args[1], + parser, + fmt::format("unknown keyword \"{}\" specified, \"ptr\" expected", std::get(args[1].value.val))); } else if (std::get(args[5].value.val) > 255) [[unlikely]] { ThrowError( - args[5], - parser, - fmt::format("out of bounds integer provided: {} > 255", std::get(args[5].value.val))); + args[5], + parser, + fmt::format("out of bounds integer provided: {} > 255", std::get(args[5].value.val))); } return { - .val = Operand { - .type = HCAsm::OperandType::mem_reg_add_int, - .reg = registers_assoc.at(reg.c_str()), - .mode = mode_assoc.at(Mode.c_str()), - .tokens = { - parser.get_compiler_state()->pool.allocate(std::move(args[5])) - }, - .variant = { std::get(args[5].value.val) } - } - }; + .val = Operand{ + .type = HCAsm::OperandType::mem_reg_add_int, + .reg = registers_assoc.at(reg.c_str()), + .mode = mode_assoc.at(Mode.c_str()), + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[5]))}, + .variant = {std::get(args[5].value.val)}}}; } Value HCAsm::ParseOperand7(pog::Parser& parser, std::vector>&& args) { return { - .val = Operand { - .type = HCAsm::OperandType::sint, - .mode = HCAsm::Mode::none, - .tokens = { - parser.get_compiler_state()->pool.allocate(std::move(args[0])) - }, - .variant = { std::get(args[0].value.val) } - } - }; + .val = Operand{ + .type = HCAsm::OperandType::sint, + .mode = HCAsm::Mode::none, + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[0]))}, + .variant = {std::get(args[0].value.val)}}}; } Value HCAsm::ParseOperand8(pog::Parser& parser, std::vector>&& args) { return { - .val = Operand { - .type = HCAsm::OperandType::uint, - .mode = HCAsm::Mode::none, - .tokens = { - parser.get_compiler_state()->pool.allocate(std::move(args[0])) - }, - .variant = { std::get(args[0].value.val) } - } - }; + .val = Operand{ + .type = HCAsm::OperandType::uint, + .mode = HCAsm::Mode::none, + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[0]))}, + .variant = {std::get(args[0].value.val)}}}; } Value HCAsm::ParseOperand9(pog::Parser& parser, std::vector>&& args) { @@ -205,28 +179,24 @@ Value HCAsm::ParseOperand9(pog::Parser& parser, std::vectorpool.allocate(std::move(args[0])) - }, - } - }; + .val = Operand{ + .type = HCAsm::OperandType::reg, + .reg = registers_assoc.at(reg.c_str()), + .mode = ModeFromRegister(registers_assoc.at(reg.c_str())), + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[0]))}, + }}; } else { parser.get_compiler_state()->tmp_args = args; return { - .val = Operand { - .type = HCAsm::OperandType::label, - .mode = Mode::b64, - .needs_resolve = !parser.get_compiler_state()->labels.contains(reg), - .tokens = { - parser.get_compiler_state()->pool.allocate(std::move(args[0])) - }, - .variant = { std::make_shared(reg) } // TODO: use std::move on reg - } - }; + .val = Operand{ + .type = HCAsm::OperandType::label, + .mode = Mode::b64, + .needs_resolve = !parser.get_compiler_state()->labels.contains(reg), + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[0]))}, + .variant = {std::make_shared(reg)} // TODO: use std::move on reg + }}; } } @@ -235,21 +205,18 @@ Value HCAsm::ParseOperand10(pog::Parser& parser, std::vectorpool.allocate(std::move(args[1])) - }, - .variant = { std::get(args[1].value.val) } - } - }; + .val = Operand{ + .type = HCAsm::OperandType::uint, + .mode = mode_assoc.at(mode.c_str()), + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[1]))}, + .variant = {std::get(args[1].value.val)}}}; } Value HCAsm::ParseOperand11(pog::Parser& parser, std::vector>&& args) { @@ -257,21 +224,18 @@ Value HCAsm::ParseOperand11(pog::Parser& parser, std::vectorpool.allocate(std::move(args[1])) - }, - .variant = { std::get(args[1].value.val) } - } - }; + .val = Operand{ + .type = HCAsm::OperandType::sint, + .mode = mode_assoc.at(mode.c_str()), + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[1]))}, + .variant = {std::get(args[1].value.val)}}}; } Value HCAsm::ParseOperand12(pog::Parser& parser, std::vector>&& args) { @@ -280,31 +244,26 @@ Value HCAsm::ParseOperand12(pog::Parser& parser, std::vectorlabels.contains(reg), - .tokens = { - parser.get_compiler_state()->pool.allocate(std::move(args[1])) - }, - .variant = { std::make_shared(reg) } // TODO: use std::move on reg - } - }; + .val = Operand{ + .type = HCAsm::OperandType::label, + .mode = mode_assoc.at(mode.c_str()), + .needs_resolve = !parser.get_compiler_state()->labels.contains(reg), + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[1]))}, + .variant = {std::make_shared(reg)} // TODO: use std::move on reg + }}; } return { - .val = Operand { - .type = HCAsm::OperandType::reg, - .mode = mode_assoc.at(mode.c_str()), - .tokens = { - parser.get_compiler_state()->pool.allocate(std::move(args[1])) - }, - .variant = { std::make_unique(reg) } - } - }; + .val = Operand{ + .type = HCAsm::OperandType::reg, + .mode = mode_assoc.at(mode.c_str()), + .tokens = { + parser.get_compiler_state()->pool.allocate(std::move(args[1]))}, + .variant = {std::make_unique(reg)}}}; } diff --git a/src/Assembler/Core/RegNameAssoc.hpp b/src/Assembler/Core/RegNameAssoc.hpp index d2ca1f93..375d68d2 100644 --- a/src/Assembler/Core/RegNameAssoc.hpp +++ b/src/Assembler/Core/RegNameAssoc.hpp @@ -2,50 +2,47 @@ #include -#include "PCH/CStd.hpp" #include "Common/LanguageSpec/Registers.hpp" +#include "PCH/CStd.hpp" - -constexpr inline const auto registers_assoc = mapbox::eternal::hash_map({ - {"x0", HyperCPU::Registers::X0}, - {"x1", HyperCPU::Registers::X1}, - {"x2", HyperCPU::Registers::X2}, - {"x3", HyperCPU::Registers::X3}, - {"x4", HyperCPU::Registers::X4}, - {"x5", HyperCPU::Registers::X5}, - {"x6", HyperCPU::Registers::X6}, - {"x7", HyperCPU::Registers::X7}, - {"xh0", HyperCPU::Registers::XH0}, - {"xh1", HyperCPU::Registers::XH1}, - {"xh2", HyperCPU::Registers::XH2}, - {"xh3", HyperCPU::Registers::XH3}, - {"xh4", HyperCPU::Registers::XH4}, - {"xh5", HyperCPU::Registers::XH5}, - {"xh6", HyperCPU::Registers::XH6}, - {"xh7", HyperCPU::Registers::XH7}, - {"xl0", HyperCPU::Registers::XL0}, - {"xl1", HyperCPU::Registers::XL1}, - {"xl2", HyperCPU::Registers::XL2}, - {"xl3", HyperCPU::Registers::XL3}, - {"xl4", HyperCPU::Registers::XL4}, - {"xl5", HyperCPU::Registers::XL5}, - {"xl6", HyperCPU::Registers::XL6}, - {"xl7", HyperCPU::Registers::XL7}, - {"xll0", HyperCPU::Registers::XLL0}, - {"xll1", HyperCPU::Registers::XLL1}, - {"xll2", HyperCPU::Registers::XLL2}, - {"xll3", HyperCPU::Registers::XLL3}, - {"xllh0", HyperCPU::Registers::XLLH0}, - {"xllh1", HyperCPU::Registers::XLLH1}, - {"xllh2", HyperCPU::Registers::XLLH2}, - {"xllh3", HyperCPU::Registers::XLLH3}, - {"xlll0", HyperCPU::Registers::XLLL0}, - {"xlll1", HyperCPU::Registers::XLLL1}, - {"xlll2", HyperCPU::Registers::XLLL2}, - {"xlll3", HyperCPU::Registers::XLLL3}, - {"xbp", HyperCPU::Registers::XBP}, - {"xsp", HyperCPU::Registers::XSP}, - {"xip", HyperCPU::Registers::XIP}, - {"xgdp", HyperCPU::Registers::XGDP}, - {"xivt", HyperCPU::Registers::XIVT} -}); +constexpr inline const auto registers_assoc = mapbox::eternal::hash_map({{"x0", HyperCPU::Registers::X0}, + {"x1", HyperCPU::Registers::X1}, + {"x2", HyperCPU::Registers::X2}, + {"x3", HyperCPU::Registers::X3}, + {"x4", HyperCPU::Registers::X4}, + {"x5", HyperCPU::Registers::X5}, + {"x6", HyperCPU::Registers::X6}, + {"x7", HyperCPU::Registers::X7}, + {"xh0", HyperCPU::Registers::XH0}, + {"xh1", HyperCPU::Registers::XH1}, + {"xh2", HyperCPU::Registers::XH2}, + {"xh3", HyperCPU::Registers::XH3}, + {"xh4", HyperCPU::Registers::XH4}, + {"xh5", HyperCPU::Registers::XH5}, + {"xh6", HyperCPU::Registers::XH6}, + {"xh7", HyperCPU::Registers::XH7}, + {"xl0", HyperCPU::Registers::XL0}, + {"xl1", HyperCPU::Registers::XL1}, + {"xl2", HyperCPU::Registers::XL2}, + {"xl3", HyperCPU::Registers::XL3}, + {"xl4", HyperCPU::Registers::XL4}, + {"xl5", HyperCPU::Registers::XL5}, + {"xl6", HyperCPU::Registers::XL6}, + {"xl7", HyperCPU::Registers::XL7}, + {"xll0", HyperCPU::Registers::XLL0}, + {"xll1", HyperCPU::Registers::XLL1}, + {"xll2", HyperCPU::Registers::XLL2}, + {"xll3", HyperCPU::Registers::XLL3}, + {"xllh0", HyperCPU::Registers::XLLH0}, + {"xllh1", HyperCPU::Registers::XLLH1}, + {"xllh2", HyperCPU::Registers::XLLH2}, + {"xllh3", HyperCPU::Registers::XLLH3}, + {"xlll0", HyperCPU::Registers::XLLL0}, + {"xlll1", HyperCPU::Registers::XLLL1}, + {"xlll2", HyperCPU::Registers::XLLL2}, + {"xlll3", HyperCPU::Registers::XLLL3}, + {"xbp", HyperCPU::Registers::XBP}, + {"xsp", HyperCPU::Registers::XSP}, + {"xip", HyperCPU::Registers::XIP}, + {"xgdp", HyperCPU::Registers::XGDP}, + {"xivt", HyperCPU::Registers::XIVT}}); diff --git a/src/Assembler/Core/StatementCompilers.cpp b/src/Assembler/Core/StatementCompilers.cpp index a46788d8..61739997 100644 --- a/src/Assembler/Core/StatementCompilers.cpp +++ b/src/Assembler/Core/StatementCompilers.cpp @@ -1,100 +1,94 @@ -#include "Pog/Pog.hpp" -#include "PCH/CStd.hpp" #include "Assembler/Core/Compiler.hpp" #include "Assembler/Core/OpcodeNameAssoc.hpp" #include "Assembler/Core/RegNameAssoc.hpp" +#include "PCH/CStd.hpp" +#include "Pog/Pog.hpp" using HCAsm::Value; Value HCAsm::CompileStatement1([[maybe_unused]] pog::Parser& parser, std::vector>&& args) { - auto& instr_name = std::get(args[0].value.val); + auto& instr_name = std::get(args[0].value.val); - if (!opcode_assoc.contains(instr_name.c_str())) { - ThrowError(args[0], parser, "unknown instruction name"); - } + if (!opcode_assoc.contains(instr_name.c_str())) { + ThrowError(args[0], parser, "unknown instruction name"); + } - ++current_index; + ++current_index; - current_state->ir.push_back(Instruction { - opcode_assoc.at(instr_name.c_str()), - std::get(args[1].value.val), - std::get(args[3].value.val) - }); + current_state->ir.push_back(Instruction{ + opcode_assoc.at(instr_name.c_str()), + std::get(args[1].value.val), + std::get(args[3].value.val)}); - if (std::get(args[1].value.val).type == OperandType::label) { - parser.get_compiler_state()->pending_resolves.push_back(PendingLabelReferenceResolve { + if (std::get(args[1].value.val).type == OperandType::label) { + parser.get_compiler_state()->pending_resolves.push_back(PendingLabelReferenceResolve{ .idx = static_cast(current_state->ir.size() - 1), - .op = 0 - }); - } else if (std::get(args[1].value.val).type == OperandType::label) { - parser.get_compiler_state()->pending_resolves.push_back(PendingLabelReferenceResolve { + .op = 0}); + } else if (std::get(args[1].value.val).type == OperandType::label) { + parser.get_compiler_state()->pending_resolves.push_back(PendingLabelReferenceResolve{ .idx = static_cast(current_state->ir.size() - 1), - .op = 1 - }); - } + .op = 1}); + } - return {}; + return {}; } Value HCAsm::CompileStatement2(pog::Parser& parser, std::vector>&& args) { - auto& instr_name = std::get(args[0].value.val); + auto& instr_name = std::get(args[0].value.val); - if (!opcode_assoc.contains(instr_name.c_str())) { - ThrowError(args[0], parser, "unknown instruction name"); - } + if (!opcode_assoc.contains(instr_name.c_str())) { + ThrowError(args[0], parser, "unknown instruction name"); + } - ++current_index; + ++current_index; - auto& tmp_op = std::get(args[1].value.val); + auto& tmp_op = std::get(args[1].value.val); - current_state->ir.push_back(Instruction { - opcode_assoc.at(instr_name.c_str()), - tmp_op, - { HCAsm::OperandType::none } - }); + current_state->ir.push_back(Instruction{ + opcode_assoc.at(instr_name.c_str()), + tmp_op, + {HCAsm::OperandType::none}}); - if (tmp_op.type == OperandType::label) { - parser.get_compiler_state()->pending_resolves.push_back(PendingLabelReferenceResolve { + if (tmp_op.type == OperandType::label) { + parser.get_compiler_state()->pending_resolves.push_back(PendingLabelReferenceResolve{ .idx = static_cast(current_state->ir.size() - 1), - .op = 0 - }); - } + .op = 0}); + } - return {}; + return {}; } Value HCAsm::CompileStatement3(pog::Parser& parser, std::vector>&& args) { - auto& instr_name = std::get(args[0].value.val); + auto& instr_name = std::get(args[0].value.val); - if (!opcode_assoc.contains(instr_name.c_str())) { - ThrowError(args[0], parser, "unknown instruction name"); - } + if (!opcode_assoc.contains(instr_name.c_str())) { + ThrowError(args[0], parser, "unknown instruction name"); + } - ++current_index; + ++current_index; - current_state->ir.push_back(Instruction{ - opcode_assoc.at(instr_name.c_str()), - { HCAsm::OperandType::none }, - { HCAsm::OperandType::none } - }); - return {}; + current_state->ir.push_back(Instruction{ + opcode_assoc.at(instr_name.c_str()), + {HCAsm::OperandType::none}, + {HCAsm::OperandType::none}}); + return {}; } Value HCAsm::CompileLabel(pog::Parser& parser, std::vector>&& args) { - // Label cant be register or instruction name - auto& name = std::get(args[0].value.val); + // Label cant be register or instruction name + auto& name = std::get(args[0].value.val); - if (opcode_assoc.contains(name.c_str()) || registers_assoc.contains(name.c_str())) { - ThrowError(args[0], parser, "reserved identifier cannot be used as a label"); - } + if (opcode_assoc.contains(name.c_str()) || registers_assoc.contains(name.c_str())) { + ThrowError(args[0], parser, "reserved identifier cannot be used as a label"); + } - if (current_state->labels.contains(name)) { - ThrowError(args[0], parser, fmt::format("redefinition of label", name)); - } + if (current_state->labels.contains(name)) { + ThrowError(args[0], parser, fmt::format("redefinition of label", name)); + } - current_state->ir.push_back(HCAsm::Label{ name, current_index++, false }); - current_state->labels[name] = current_index - 1; - return {}; + current_state->ir.push_back(HCAsm::Label{name, current_index++, false}); + current_state->labels[name] = current_index - 1; + return {}; } Value HCAsm::CompileEntryLabel(pog::Parser& parser, std::vector>&& args) { @@ -109,7 +103,7 @@ Value HCAsm::CompileEntryLabel(pog::Parser& parser, std::vectorir.push_back(HCAsm::Label{ name, current_index++, true }); + current_state->ir.push_back(HCAsm::Label{name, current_index++, true}); current_state->labels[name] = current_index - 1; return {}; } @@ -118,7 +112,7 @@ Value HCAsm::CompileRawValueb8(pog::Parser& parser, std::vector(args[1].value.val).type != OperandType::uint) { ThrowError(*std::get(args[1].value.val).tokens[0], parser, "invalid operand type for directive '.b8', expected uint"); } - current_state->ir.push_back(HCAsm::RawValue{ Mode::b8, std::get(args[1].value.val)}); + current_state->ir.push_back(HCAsm::RawValue{Mode::b8, std::get(args[1].value.val)}); return {}; } @@ -127,12 +121,10 @@ Value HCAsm::CompileRawValueb8_str([[maybe_unused]] pog::Parser& parser, ThrowError(*std::get(args[1].value.val).tokens[0], parser, "invalid operand type for directive '.b8' expected uint or string"); } - current_state->ir.push_back(HCAsm::RawValue { - Mode::b8_str, - Operand { - .variant = std::make_shared(std::move(std::get(args[1].value.val))) - } - }); + current_state->ir.push_back(HCAsm::RawValue{ + Mode::b8_str, + Operand{ + .variant = std::make_shared(std::move(std::get(args[1].value.val)))}}); return {}; } @@ -141,7 +133,7 @@ Value HCAsm::CompileRawValueb16(pog::Parser& parser, std::vector(args[1].value.val).type != OperandType::uint) { ThrowError(*std::get(args[1].value.val).tokens[0], parser, "invalid operand type for directive '.b16' expected uint"); } - current_state->ir.push_back(HCAsm::RawValue{ Mode::b16, std::get(args[1].value.val)}); + current_state->ir.push_back(HCAsm::RawValue{Mode::b16, std::get(args[1].value.val)}); return {}; } @@ -149,7 +141,7 @@ Value HCAsm::CompileRawValueb32(pog::Parser& parser, std::vector(args[1].value.val).type != OperandType::uint) { ThrowError(*std::get(args[1].value.val).tokens[0], parser, "invalid operand type for directive '.b32', expected uint"); } - current_state->ir.push_back(HCAsm::RawValue{ Mode::b32, std::get(args[1].value.val)}); + current_state->ir.push_back(HCAsm::RawValue{Mode::b32, std::get(args[1].value.val)}); return {}; } @@ -157,14 +149,14 @@ Value HCAsm::CompileRawValueb64(pog::Parser& parser, std::vector(args[1].value.val); switch (op.type) { - case HCAsm::OperandType::uint: - current_state->ir.push_back(HCAsm::RawValue{ Mode::b64, op}); - break; - case HCAsm::OperandType::label: - current_state->ir.push_back(HCAsm::RawValue{ Mode::b64_label, op}); - break; - default: - ThrowError(*std::get(args[1].value.val).tokens[0], parser, "invalid operand type for directive '.b64', label or uint expected"); + case HCAsm::OperandType::uint: + current_state->ir.push_back(HCAsm::RawValue{Mode::b64, op}); + break; + case HCAsm::OperandType::label: + current_state->ir.push_back(HCAsm::RawValue{Mode::b64_label, op}); + break; + default: + ThrowError(*std::get(args[1].value.val).tokens[0], parser, "invalid operand type for directive '.b64', label or uint expected"); } return {}; } diff --git a/src/Assembler/Core/Tokenizers.cpp b/src/Assembler/Core/Tokenizers.cpp index b5073152..b3488796 100644 --- a/src/Assembler/Core/Tokenizers.cpp +++ b/src/Assembler/Core/Tokenizers.cpp @@ -1,7 +1,6 @@ -#include "Pog/Pog.hpp" -#include "PCH/CStd.hpp" #include "Assembler/Core/Compiler.hpp" - +#include "PCH/CStd.hpp" +#include "Pog/Pog.hpp" using HCAsm::Value; @@ -26,11 +25,11 @@ std::uint64_t BinaryStrToUint64(std::string_view& binary_str) { } Value HCAsm::TokenizeSignedInt(std::string_view str) { - return { std::stol(str.begin() + 2) }; + return {std::stol(str.begin() + 2)}; } Value HCAsm::TokenizeUnsignedInt(std::string_view str) { - return { std::stoull(str.begin() + 2) }; + return {std::stoull(str.begin() + 2)}; } Value HCAsm::TokenizeString(std::string_view str) { @@ -47,37 +46,37 @@ Value HCAsm::TokenizeString(std::string_view str) { } } else { switch (c) { - case 'n': - res.push_back('\n'); - break; - case 'r': - res.push_back('\r'); - break; - case '\\': - res.push_back('\\'); - break; - case '0': - res.push_back('\0'); - break; - case 'e': - res.push_back(0x1B); - break; - case 'b': - res.push_back('\b'); - break; - case 't': - res.push_back('\t'); - break; - case '\n': - break; - default: - res.push_back(c); - break; + case 'n': + res.push_back('\n'); + break; + case 'r': + res.push_back('\r'); + break; + case '\\': + res.push_back('\\'); + break; + case '0': + res.push_back('\0'); + break; + case 'e': + res.push_back(0x1B); + break; + case 'b': + res.push_back('\b'); + break; + case 't': + res.push_back('\t'); + break; + case '\n': + break; + default: + res.push_back(c); + break; } escape = false; } } - return { res }; + return {res}; } Value HCAsm::TokenizeIdentifier(std::string_view str) { @@ -97,5 +96,5 @@ Value HCAsm::TokenizeHexadecimal(std::string_view str) { } Value HCAsm::TokenizeBinary(std::string_view str) { - return { BinaryStrToUint64(str) }; + return {BinaryStrToUint64(str)}; } diff --git a/src/Assembler/Main/Main.cpp b/src/Assembler/Main/Main.cpp index a8e3dc40..ef7e03c8 100644 --- a/src/Assembler/Main/Main.cpp +++ b/src/Assembler/Main/Main.cpp @@ -1,22 +1,21 @@ -#include #include +#include -#include "Pog/Pog.hpp" -#include "PCH/CStd.hpp" -#include "Assembler/Utils/Extension.hpp" #include "Assembler/Core/Compiler.hpp" +#include "Assembler/Utils/Extension.hpp" #include "Common/NotImplemented.hpp" - +#include "PCH/CStd.hpp" +#include "Pog/Pog.hpp" #ifdef HCPU_ENABLE_LIBUNWIND #include "BacktraceProvider/BacktraceProvider.hpp" #endif constexpr const inline auto loglevel_assoc = mapbox::eternal::map({ - {"debug", HyperCPU::LogLevel::DEBUG}, - {"info", HyperCPU::LogLevel::INFO}, - {"warning", HyperCPU::LogLevel::WARNING}, - {"error", HyperCPU::LogLevel::ERROR}, + {"debug", HyperCPU::LogLevel::DEBUG}, + {"info", HyperCPU::LogLevel::INFO}, + {"warning", HyperCPU::LogLevel::WARNING}, + {"error", HyperCPU::LogLevel::ERROR}, }); int main(int argc, char** argv) { @@ -28,18 +27,17 @@ int main(int argc, char** argv) { #endif argparse::ArgumentParser program("hcasm"); program.add_argument("source") - .help("source file to be assembled") - .required(); + .help("source file to be assembled") + .required(); program.add_argument("-o") - .help("name of the binary file"); + .help("name of the binary file"); program.add_argument("-c") - .help("compile to object file") - .default_value(false) - .implicit_value(true); + .help("compile to object file") + .default_value(false) + .implicit_value(true); program.add_argument("-v") - .default_value(std::string{"warning"}) - .help("set verbosity level. possible modes:\n- debug\n- info\n- warning\n- error"); - + .default_value(std::string{"warning"}) + .help("set verbosity level. possible modes:\n- debug\n- info\n- warning\n- error"); try { program.parse_args(argc, argv); @@ -63,7 +61,7 @@ int main(int argc, char** argv) { HyperCPU::PrintUnsupported("Compilation to object files is not implemented!"); } - HCAsm::HCAsmCompiler compiler{ loglevel_assoc.at(program.get("-v").c_str()) }; + HCAsm::HCAsmCompiler compiler{loglevel_assoc.at(program.get("-v").c_str())}; // Verify that files are available if (!std::filesystem::is_regular_file(source)) { @@ -88,9 +86,8 @@ int main(int argc, char** argv) { src.open(source); std::string contents( - (std::istreambuf_iterator(src)), - std::istreambuf_iterator() - ); + (std::istreambuf_iterator(src)), + std::istreambuf_iterator()); std::uint32_t code_size; diff --git a/src/BacktraceProvider/BacktraceProvider.cpp b/src/BacktraceProvider/BacktraceProvider.cpp index 308a8404..71e6da22 100644 --- a/src/BacktraceProvider/BacktraceProvider.cpp +++ b/src/BacktraceProvider/BacktraceProvider.cpp @@ -2,79 +2,78 @@ #define UNW_LOCAL_ONLY +#include #include #include -#include -#include "PCH/CStd.hpp" #include "BacktraceProvider/BacktraceProvider.hpp" - +#include "PCH/CStd.hpp" extern "C" { - void SignalHandler(int signal) { - switch(signal) { - case SIGSEGV: - catched_signal_type = "SIGSEGV"; - break; - case SIGFPE: - catched_signal_type = "SIGFPE"; - break; - } - global_bt_controller.Run(); +void SignalHandler(int signal) { + switch (signal) { + case SIGSEGV: + catched_signal_type = "SIGSEGV"; + break; + case SIGFPE: + catched_signal_type = "SIGFPE"; + break; + } + global_bt_controller.Run(); +} + +void bt_create_error_callback(void*, const char* msg, int err) { + fmt::println("Error {} occurred when generating the stack trace: {}", err, msg); +} + +void bt_error_callback(void*, [[maybe_unused]] const char* msg, [[maybe_unused]] int err) { + fmt::println("{}[!] Error while getting the stacktrace!{}", B_RED, RESET); +} + +int bt_callback(void*, uintptr_t, const char* filename, int lineno, const char* function) { + if (global_bt_controller.HasFinished() || global_bt_controller.iteration < 3) { + ++global_bt_controller.iteration; + return 0; } - void bt_create_error_callback(void*, const char* msg, int err) { - fmt::println("Error {} occurred when generating the stack trace: {}", err, msg); + // Demangle function name + const char* func_name = function; + int status; + unw_word_t pc, sp; + std::unique_ptr demangled{abi::__cxa_demangle(function, nullptr, nullptr, &status), &std::free}; + if (!status) { + func_name = demangled.get(); } - void bt_error_callback(void*, [[maybe_unused]] const char* msg, [[maybe_unused]] int err) { - fmt::println("{}[!] Error while getting the stacktrace!{}", B_RED, RESET); + // Null pointer protection + if (!func_name) { + func_name = ""; + } else if (!std::strcmp(func_name, "main")) { + global_bt_controller.SetFinished(); + } + if (!filename) { + filename = ""; } - int bt_callback(void*, uintptr_t, const char* filename, int lineno, const char* function) { - if (global_bt_controller.HasFinished() || global_bt_controller.iteration < 3) { - ++global_bt_controller.iteration; - return 0; - } - - // Demangle function name - const char* func_name = function; - int status; - unw_word_t pc, sp; - std::unique_ptr demangled{abi::__cxa_demangle(function, nullptr, nullptr, &status), &std::free}; - if (!status) { - func_name = demangled.get(); - } - - // Null pointer protection - if (!func_name) { - func_name = ""; - } else if (!std::strcmp(func_name, "main")) { - global_bt_controller.SetFinished(); - } - if (!filename) { - filename = ""; - } - - // Extract PC and SP - if (unw_get_reg(&global_bt_controller.cursor, UNW_REG_IP, &pc)) { - fmt::println("{}[!] Unwinding stack failed: couldn't get PC!{}", B_RED, RESET); - std::exit(1); - } - - if (unw_get_reg(&global_bt_controller.cursor, UNW_REG_SP, &sp)) { - fmt::println("{}[!] Unwinding stack failed: couldn't get SP!{}", B_RED, RESET); - std::exit(1); - } - - fmt::println("{}frame #{} (PC: {:#x}, SP: {:#x}){}", B_YELLOW, global_bt_controller.iteration, pc, sp, RESET); - fmt::println("{}{}:{}, function: {}{}", B_YELLOW, filename, lineno, func_name, RESET); - - unw_step(&global_bt_controller.cursor); + // Extract PC and SP + if (unw_get_reg(&global_bt_controller.cursor, UNW_REG_IP, &pc)) { + fmt::println("{}[!] Unwinding stack failed: couldn't get PC!{}", B_RED, RESET); + std::exit(1); + } - ++global_bt_controller.iteration; - return 0; + if (unw_get_reg(&global_bt_controller.cursor, UNW_REG_SP, &sp)) { + fmt::println("{}[!] Unwinding stack failed: couldn't get SP!{}", B_RED, RESET); + std::exit(1); } + + fmt::println("{}frame #{} (PC: {:#x}, SP: {:#x}){}", B_YELLOW, global_bt_controller.iteration, pc, sp, RESET); + fmt::println("{}{}:{}, function: {}{}", B_YELLOW, filename, lineno, func_name, RESET); + + unw_step(&global_bt_controller.cursor); + + ++global_bt_controller.iteration; + return 0; +} } BacktraceController global_bt_controller; diff --git a/src/BacktraceProvider/BacktraceProvider.hpp b/src/BacktraceProvider/BacktraceProvider.hpp index 2fff099b..53966838 100644 --- a/src/BacktraceProvider/BacktraceProvider.hpp +++ b/src/BacktraceProvider/BacktraceProvider.hpp @@ -8,13 +8,14 @@ #include "PCH/CStd.hpp" extern "C" { - void bt_create_error_callback(void*, const char* msg, int err); +void bt_create_error_callback(void*, const char* msg, int err); } class BacktraceController { public: BacktraceController() = default; - BacktraceController(char* name) : iteration(0), finished(false) { + BacktraceController(char* name) + : iteration(0), finished(false) { bt_state = backtrace_create_state(name, 0, bt_create_error_callback, nullptr); } @@ -27,6 +28,7 @@ class BacktraceController { // libunwind unw_cursor_t cursor; unw_context_t context; + private: // libbacktrace void* bt_state; diff --git a/src/Common/BUILD.bazel b/src/Common/BUILD.bazel index ce614a9f..075a33ed 100644 --- a/src/Common/BUILD.bazel +++ b/src/Common/BUILD.bazel @@ -1,5 +1,11 @@ load('@rules_cc//cc:defs.bzl', 'cc_library') +package( + default_visibility = [ + '//:__subpackages__', + ], +) + cc_library( name = 'hcpu_common', srcs = glob(['**/*.cpp'], allow_empty = True), diff --git a/src/Common/Defs.hpp b/src/Common/Defs.hpp index a01c8992..9d8f2d61 100644 --- a/src/Common/Defs.hpp +++ b/src/Common/Defs.hpp @@ -1,8 +1,7 @@ #pragma once - #if defined(__GNUC__) || defined(__clang__) - #define HCPU_ALWAYS_INLINE inline __attribute__((always_inline)) +#define HCPU_ALWAYS_INLINE inline __attribute__((always_inline)) #else - #define HCPU_ALWAYS_INLINE inline +#define HCPU_ALWAYS_INLINE inline #endif diff --git a/src/Emulator/Main/Main.hpp b/src/Common/Helpers/Classes.hpp similarity index 78% rename from src/Emulator/Main/Main.hpp rename to src/Common/Helpers/Classes.hpp index f83f9fc4..416633cf 100644 --- a/src/Emulator/Main/Main.hpp +++ b/src/Common/Helpers/Classes.hpp @@ -1,20 +1,19 @@ #pragma once -#include "pch.hpp" - +#include "PCH/CStd.hpp" namespace HyperCPU { - enum Version : std::uint8_t { + enum class Version : std::uint8_t { PreRelease = 0x01, Release1_0 = 0x02 }; - enum IOSubsystem : std::uint8_t { + enum class IOSubsystem : std::uint8_t { NCurses = 0x01, Simple = 0x02 }; - enum FileType : std::uint8_t { + enum class FileType : std::uint8_t { Object = 0x01, Binary = 0x02 }; @@ -38,4 +37,4 @@ namespace HyperCPU { }; std::uint64_t ParseMemoryString(const std::string& str); -} +} // namespace HyperCPU diff --git a/src/Common/LanguageSpec/AllowedFlags.hpp b/src/Common/LanguageSpec/AllowedFlags.hpp index 5bf029cf..4300fe4e 100644 --- a/src/Common/LanguageSpec/AllowedFlags.hpp +++ b/src/Common/LanguageSpec/AllowedFlags.hpp @@ -2,137 +2,149 @@ #include "PCH/CStd.hpp" - namespace HyperCPU { inline static constexpr std::uint8_t SUPPORT_ALL = 0b00011011; inline static const std::uint8_t AllowedOpModes[128][12] = { - {}, // NULL - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ADC - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ADD - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // AND - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ANDN - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // BSWAP - {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALL - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // CCRF - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // COVF - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // CUDF - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // HID - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // INC - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // DEC - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // DIV - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // MUL - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // SUB - {SUPPORT_ALL, 0, 0, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // SHFR - {SUPPORT_ALL, 0, 0, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // SHFL - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // OR - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // HALT - {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // LOIVT - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // INTR - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // IRET - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // RET - {0, 0, 0, 0, 0, 0, 0, 0, 0b11000000, 0, 0b11000000, 0}, // READ - {0b11000000, 0, 0, 0b11000000, 0, 0, 0, 0, 0, 0, 0}, // WRITE - {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // JMP - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, SUPPORT_ALL, 0}, // PUSH - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0, }, // POP - {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALLE - {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALLGR - {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALLL - {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // JME - {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // JMGR - {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // JML - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0}, // CMP - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {}, - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0}, // MOV + {}, // NULL + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ADC + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ADD + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // AND + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ANDN + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // BSWAP + {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALL + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // CCRF + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // COVF + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // CUDF + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // HID + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // INC + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // DEC + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // DIV + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // MUL + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // SUB + {SUPPORT_ALL, 0, 0, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // SHFR + {SUPPORT_ALL, 0, 0, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // SHFL + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // OR + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // HALT + {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // LOIVT + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // INTR + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // IRET + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // RET + {0, 0, 0, 0, 0, 0, 0, 0, 0b11000000, 0, 0b11000000, 0}, // READ + {0b11000000, 0, 0, 0b11000000, 0, 0, 0, 0, 0, 0, 0}, // WRITE + {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // JMP + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, SUPPORT_ALL, 0}, // PUSH + { + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + SUPPORT_ALL, + 0, + 0, + 0, + }, // POP + {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALLE + {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALLGR + {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALLL + {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // JME + {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // JMGR + {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // JML + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0}, // CMP + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {}, + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0}, // MOV }; -} +} // namespace HyperCPU diff --git a/src/Common/LanguageSpec/Flags.hpp b/src/Common/LanguageSpec/Flags.hpp index d9ec9e93..ae12dc14 100644 --- a/src/Common/LanguageSpec/Flags.hpp +++ b/src/Common/LanguageSpec/Flags.hpp @@ -2,14 +2,26 @@ #include "PCH/CStd.hpp" - namespace HyperCPU { enum class Mode { - b8 = 0, b16, b32, b64 + b8 = 0, + b16, + b32, + b64 }; enum class OperandTypes { - R_R = 0, R_RM, R_M, R_IMM, RM_R, RM_M, RM_IMM, - M_R, R, M, IMM, NONE + R_R = 0, + R_RM, + R_M, + R_IMM, + RM_R, + RM_M, + RM_IMM, + M_R, + R, + M, + IMM, + NONE }; -} +} // namespace HyperCPU diff --git a/src/Common/LanguageSpec/Opcodes.hpp b/src/Common/LanguageSpec/Opcodes.hpp index 612e5508..d62daafa 100644 --- a/src/Common/LanguageSpec/Opcodes.hpp +++ b/src/Common/LanguageSpec/Opcodes.hpp @@ -2,45 +2,44 @@ #include "PCH/CStd.hpp" - namespace HyperCPU { enum class Opcode : std::uint16_t { - ADC = 0x0001, - ADD = 0x0002, - AND = 0x0003, - ANDN = 0x0004, + ADC = 0x0001, + ADD = 0x0002, + AND = 0x0003, + ANDN = 0x0004, BSWAP = 0x0005, - CALL = 0x0006, - CCRF = 0x0007, - COVF = 0x0008, - CUDF = 0x0009, - HID = 0x000A, - INC = 0x000B, - DEC = 0x000C, - DIV = 0x000D, - MUL = 0x000E, - SUB = 0x000F, - SHFR = 0x0010, - SHFL = 0x0011, - OR = 0x0012, - HALT = 0x0013, + CALL = 0x0006, + CCRF = 0x0007, + COVF = 0x0008, + CUDF = 0x0009, + HID = 0x000A, + INC = 0x000B, + DEC = 0x000C, + DIV = 0x000D, + MUL = 0x000E, + SUB = 0x000F, + SHFR = 0x0010, + SHFL = 0x0011, + OR = 0x0012, + HALT = 0x0013, LOIVT = 0x0014, - INTR = 0x0015, - RET = 0x0016, - IRET = 0x0017, - READ = 0x0018, + INTR = 0x0015, + RET = 0x0016, + IRET = 0x0017, + READ = 0x0018, WRITE = 0x0019, - JMP = 0x001A, - PUSH = 0x001B, - POP = 0x001C, + JMP = 0x001A, + PUSH = 0x001B, + POP = 0x001C, CALLE = 0x001D, - CALLGR= 0x001E, + CALLGR = 0x001E, CALLL = 0x001F, - JME = 0x0020, - JMGR = 0x0021, - JML = 0x0022, - CMP = 0x0023, - MOV = 0x007F, + JME = 0x0020, + JMGR = 0x0021, + JML = 0x0022, + CMP = 0x0023, + MOV = 0x007F, _CONT = 0x6934 }; @@ -48,43 +47,43 @@ namespace HyperCPU { static constexpr inline bool IsValidOpcode(std::uint16_t op) { Opcode code = static_cast(op); switch (code) { - case Opcode::ADC: - case Opcode::ADD: - case Opcode::AND: - case Opcode::ANDN: - case Opcode::BSWAP: - case Opcode::CALL: - case Opcode::CCRF: - case Opcode::COVF: - case Opcode::CUDF: - case Opcode::HID: - case Opcode::INC: - case Opcode::DEC: - case Opcode::DIV: - case Opcode::MUL: - case Opcode::SUB: - case Opcode::SHFR: - case Opcode::SHFL: - case Opcode::OR: - case Opcode::LOIVT: - case Opcode::INTR: - case Opcode::READ: - case Opcode::WRITE: - case Opcode::JMP: - case Opcode::IRET: - case Opcode::PUSH: - case Opcode::POP: - case Opcode::CALLE: - case Opcode::CALLGR: - case Opcode::CALLL: - case Opcode::JME: - case Opcode::JMGR: - case Opcode::JML: - case Opcode::CMP: - return true; - default: - return false; + case Opcode::ADC: + case Opcode::ADD: + case Opcode::AND: + case Opcode::ANDN: + case Opcode::BSWAP: + case Opcode::CALL: + case Opcode::CCRF: + case Opcode::COVF: + case Opcode::CUDF: + case Opcode::HID: + case Opcode::INC: + case Opcode::DEC: + case Opcode::DIV: + case Opcode::MUL: + case Opcode::SUB: + case Opcode::SHFR: + case Opcode::SHFL: + case Opcode::OR: + case Opcode::LOIVT: + case Opcode::INTR: + case Opcode::READ: + case Opcode::WRITE: + case Opcode::JMP: + case Opcode::IRET: + case Opcode::PUSH: + case Opcode::POP: + case Opcode::CALLE: + case Opcode::CALLGR: + case Opcode::CALLL: + case Opcode::JME: + case Opcode::JMGR: + case Opcode::JML: + case Opcode::CMP: + return true; + default: + return false; } } - } -} + } // namespace Validator +} // namespace HyperCPU diff --git a/src/Common/LanguageSpec/Registers.hpp b/src/Common/LanguageSpec/Registers.hpp index b9db1654..146e69d8 100644 --- a/src/Common/LanguageSpec/Registers.hpp +++ b/src/Common/LanguageSpec/Registers.hpp @@ -2,69 +2,101 @@ #include "PCH/CStd.hpp" - namespace HyperCPU { enum class Reg : std::uint8_t { - X0 = 0, X1, X2, X3, X4, X5, X6, X7, - XH0, XH1, XH2, XH3, XH4, XH5, XH6, XH7, - XL0, XL1, XL2, XL3, XL4, XL5, XL6, XL7, - XLL0, XLL1, XLL2, XLL3, - XLLH0, XLLH1, XLLH2, XLLH3, - XLLL0, XLLL1, XLLL2, XLLL3, - XBP, XSP, XIP, - XGDP, XIVT + X0 = 0, + X1, + X2, + X3, + X4, + X5, + X6, + X7, + XH0, + XH1, + XH2, + XH3, + XH4, + XH5, + XH6, + XH7, + XL0, + XL1, + XL2, + XL3, + XL4, + XL5, + XL6, + XL7, + XLL0, + XLL1, + XLL2, + XLL3, + XLLH0, + XLLH1, + XLLH2, + XLLH3, + XLLL0, + XLLL1, + XLLL2, + XLLL3, + XBP, + XSP, + XIP, + XGDP, + XIVT }; namespace Validator { static constexpr inline bool IsValidRegister(std::uint8_t reg) { Reg r = static_cast(reg); switch (r) { - case Reg::X0: - case Reg::X1: - case Reg::X2: - case Reg::X3: - case Reg::X4: - case Reg::X5: - case Reg::X6: - case Reg::X7: - case Reg::XH0: - case Reg::XH1: - case Reg::XH2: - case Reg::XH3: - case Reg::XH4: - case Reg::XH5: - case Reg::XH6: - case Reg::XH7: - case Reg::XL0: - case Reg::XL1: - case Reg::XL2: - case Reg::XL3: - case Reg::XL4: - case Reg::XL5: - case Reg::XL6: - case Reg::XL7: - case Reg::XLL0: - case Reg::XLL1: - case Reg::XLL2: - case Reg::XLL3: - case Reg::XLLH0: - case Reg::XLLH1: - case Reg::XLLH2: - case Reg::XLLH3: - case Reg::XLLL0: - case Reg::XLLL1: - case Reg::XLLL2: - case Reg::XLLL3: - case Reg::XBP: - case Reg::XSP: - case Reg::XIP: - case Reg::XGDP: - case Reg::XIVT: - return true; - default: - return false; + case Reg::X0: + case Reg::X1: + case Reg::X2: + case Reg::X3: + case Reg::X4: + case Reg::X5: + case Reg::X6: + case Reg::X7: + case Reg::XH0: + case Reg::XH1: + case Reg::XH2: + case Reg::XH3: + case Reg::XH4: + case Reg::XH5: + case Reg::XH6: + case Reg::XH7: + case Reg::XL0: + case Reg::XL1: + case Reg::XL2: + case Reg::XL3: + case Reg::XL4: + case Reg::XL5: + case Reg::XL6: + case Reg::XL7: + case Reg::XLL0: + case Reg::XLL1: + case Reg::XLL2: + case Reg::XLL3: + case Reg::XLLH0: + case Reg::XLLH1: + case Reg::XLLH2: + case Reg::XLLH3: + case Reg::XLLL0: + case Reg::XLLL1: + case Reg::XLLL2: + case Reg::XLLL3: + case Reg::XBP: + case Reg::XSP: + case Reg::XIP: + case Reg::XGDP: + case Reg::XIVT: + return true; + default: + return false; } } - } -} + } // namespace Validator +} // namespace HyperCPU diff --git a/src/Common/NotImplemented.hpp b/src/Common/NotImplemented.hpp index abcf0e4d..08f078af 100644 --- a/src/Common/NotImplemented.hpp +++ b/src/Common/NotImplemented.hpp @@ -1,10 +1,10 @@ #pragma once -#include "PCH/CStd.hpp" #include "Common/Defs.hpp" +#include "PCH/CStd.hpp" namespace HyperCPU { HCPU_ALWAYS_INLINE static void PrintUnsupported(std::string_view msg) { - // ... + // ... } -} +} // namespace HyperCPU diff --git a/src/Emulator/Core/CPU/ALU.hpp b/src/Emulator/Core/CPU/ALU.hpp index f21dcc81..29efea2d 100644 --- a/src/Emulator/Core/CPU/ALU.hpp +++ b/src/Emulator/Core/CPU/ALU.hpp @@ -4,58 +4,57 @@ #define _MICROOP [[gnu::always_inline]] static constexpr inline - -namespace HyperCPU{ +namespace HyperCPU { namespace StdALU { - template + template concept UInt = std::is_integral_v && std::is_unsigned_v; - template + template _MICROOP T __hcpu_add(const T& a, const T& b) { return a + b; } - template + template _MICROOP T __hcpu_sub(const T& a, const T& b) { return a - b; } - template + template _MICROOP T __hcpu_mul(const T& a, const T& b) { return a * b; } - template + template _MICROOP T __hcpu_div(const T& a, const T& b) { return a / b; } - template + template _MICROOP T __hcpu_div_remainder(const T& a, const T& b) { return a % b; } - template + template _MICROOP T __hcpu_and(const T& a, const T& b) { return a & b; } - template + template _MICROOP T __hcpu_not(const T& a) { return ~a; } - template + template _MICROOP T __hcpu_or(const T& a, const T& b) { return a | b; } - template + template _MICROOP std::int8_t __hcpu_cmp(const T a, const T b) { return (a > b) - (a < b); } - } -} + } // namespace StdALU +} // namespace HyperCPU // Simplify switching implementations namespace HyperALU { diff --git a/src/Emulator/Core/CPU/Assert.hpp b/src/Emulator/Core/CPU/Assert.hpp index a06f42c6..388491bf 100644 --- a/src/Emulator/Core/CPU/Assert.hpp +++ b/src/Emulator/Core/CPU/Assert.hpp @@ -2,5 +2,7 @@ #include "pch.hpp" - -#define h_assert(expr, statement) if (!(expr)) { statement; } +#define h_assert(expr, statement) \ + if (!(expr)) { \ + statement; \ + } diff --git a/src/Emulator/Core/CPU/CPU.cpp b/src/Emulator/Core/CPU/CPU.cpp index 921c7504..d365ce9d 100644 --- a/src/Emulator/Core/CPU/CPU.cpp +++ b/src/Emulator/Core/CPU/CPU.cpp @@ -1,155 +1,153 @@ #include "pch.hpp" -#include -#include +#include #include +#include +#include #include -#include - -HyperCPU::CPU::CPU(std::uint16_t core_count, std::uint64_t mem_size, char* binary, std::uint64_t binary_size) : - mem_controller(dynamic_cast(new MemoryControllerST(mem_size, this))), - logger(LogLevel::ERROR), - core_count(core_count), - total_mem(mem_size), - halted(false), - ivt_initialized(false), - io_ctl(std::make_unique()) { - // Initializing all register pointers - std::memset(&data, 0, sizeof(data)); - x0 = &data[0]; - x1 = &data[1]; - x2 = &data[2]; - x3 = &data[3]; - x4 = &data[4]; - x5 = &data[5]; - x6 = &data[6]; - x7 = &data[7]; - - xl0 = reinterpret_cast(&data[0]); - xl1 = reinterpret_cast(&data[1]); - xl2 = reinterpret_cast(&data[2]); - xl3 = reinterpret_cast(&data[3]); - xl4 = reinterpret_cast(&data[4]); - xl5 = reinterpret_cast(&data[5]); - xl6 = reinterpret_cast(&data[6]); - xl7 = reinterpret_cast(&data[7]); - - xh0 = reinterpret_cast(&data[0]) + 1; - xh1 = reinterpret_cast(&data[1]) + 1; - xh2 = reinterpret_cast(&data[2]) + 1; - xh3 = reinterpret_cast(&data[3]) + 1; - xh4 = reinterpret_cast(&data[4]) + 1; - xh5 = reinterpret_cast(&data[5]) + 1; - xh6 = reinterpret_cast(&data[6]) + 1; - xh7 = reinterpret_cast(&data[7]) + 1; - - xll0 = reinterpret_cast(&data[0]); - xll1 = reinterpret_cast(&data[1]); - xll2 = reinterpret_cast(&data[2]); - xll3 = reinterpret_cast(&data[3]); - - xllh0 = reinterpret_cast(&data[0]) + 1; - xllh1 = reinterpret_cast(&data[1]) + 1; - xllh2 = reinterpret_cast(&data[2]) + 1; - xllh3 = reinterpret_cast(&data[3]) + 1; - - xlll0 = reinterpret_cast(&data[0]); - xlll1 = reinterpret_cast(&data[1]); - xlll2 = reinterpret_cast(&data[2]); - xlll3 = reinterpret_cast(&data[3]); - - xbp = &data[8]; - xsp = &data[9]; - xip = &data[10]; - xgdp = &data[11]; - xivt = &data[12]; - - crf = false; - ovf = false; - udf = false; - zrf = false; - - // TODO: Use std::bind instead of lambdas - opcode_handler_assoc[static_cast(HyperCPU::Opcode::HALT)] = +HyperCPU::CPU::CPU(std::uint16_t core_count, std::uint64_t mem_size, char* binary, std::uint64_t binary_size) + : mem_controller(dynamic_cast(new MemoryControllerST(mem_size, this))), + logger(LogLevel::ERROR), + core_count(core_count), + total_mem(mem_size), + halted(false), + ivt_initialized(false), + io_ctl(std::make_unique()) { + // Initializing all register pointers + std::memset(&data, 0, sizeof(data)); + x0 = &data[0]; + x1 = &data[1]; + x2 = &data[2]; + x3 = &data[3]; + x4 = &data[4]; + x5 = &data[5]; + x6 = &data[6]; + x7 = &data[7]; + + xl0 = reinterpret_cast(&data[0]); + xl1 = reinterpret_cast(&data[1]); + xl2 = reinterpret_cast(&data[2]); + xl3 = reinterpret_cast(&data[3]); + xl4 = reinterpret_cast(&data[4]); + xl5 = reinterpret_cast(&data[5]); + xl6 = reinterpret_cast(&data[6]); + xl7 = reinterpret_cast(&data[7]); + + xh0 = reinterpret_cast(&data[0]) + 1; + xh1 = reinterpret_cast(&data[1]) + 1; + xh2 = reinterpret_cast(&data[2]) + 1; + xh3 = reinterpret_cast(&data[3]) + 1; + xh4 = reinterpret_cast(&data[4]) + 1; + xh5 = reinterpret_cast(&data[5]) + 1; + xh6 = reinterpret_cast(&data[6]) + 1; + xh7 = reinterpret_cast(&data[7]) + 1; + + xll0 = reinterpret_cast(&data[0]); + xll1 = reinterpret_cast(&data[1]); + xll2 = reinterpret_cast(&data[2]); + xll3 = reinterpret_cast(&data[3]); + + xllh0 = reinterpret_cast(&data[0]) + 1; + xllh1 = reinterpret_cast(&data[1]) + 1; + xllh2 = reinterpret_cast(&data[2]) + 1; + xllh3 = reinterpret_cast(&data[3]) + 1; + + xlll0 = reinterpret_cast(&data[0]); + xlll1 = reinterpret_cast(&data[1]); + xlll2 = reinterpret_cast(&data[2]); + xlll3 = reinterpret_cast(&data[3]); + + xbp = &data[8]; + xsp = &data[9]; + xip = &data[10]; + xgdp = &data[11]; + xivt = &data[12]; + + crf = false; + ovf = false; + udf = false; + zrf = false; + + // TODO: Use std::bind instead of lambdas + opcode_handler_assoc[static_cast(HyperCPU::Opcode::HALT)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecHALT(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::ADD)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::ADD)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecADD(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::ADC)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::ADC)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecADC(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::AND)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::AND)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecAND(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::ANDN)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::ANDN)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecANDN(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::BSWAP)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::BSWAP)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecBSWAP(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALL)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALL)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCALL(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::CCRF)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::CCRF)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCCRF(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::COVF)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::COVF)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCOVF(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::CUDF)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::CUDF)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCUDF(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::INC)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::INC)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecINC(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::DEC)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::DEC)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecDEC(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::HID)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::HID)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecHID(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::MUL)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::MUL)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecMUL(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::OR)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::OR)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecOR(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::SUB)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::SUB)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecSUB(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::SHFL)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::SHFL)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecSHFL(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::SHFR)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::SHFR)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecSHFR(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::DIV)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::DIV)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecDIV(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::LOIVT)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::LOIVT)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecLOIVT(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::INTR)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::INTR)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecINTR(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::MOV)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::MOV)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecMOV(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::READ)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::READ)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecREAD(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::WRITE)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::WRITE)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecWRITE(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::JMP)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::JMP)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecJMP(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::PUSH)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::PUSH)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecPUSH(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::POP)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::POP)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecPOP(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALLE)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALLE)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCALLE(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALLGR)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALLGR)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCALLGR(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALLL)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::CALLL)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCALLL(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::JME)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::JME)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecJME(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::JMGR)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::JMGR)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecJMGR(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::JML)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::JML)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecJML(instr, op1, op2); }; - opcode_handler_assoc[static_cast(HyperCPU::Opcode::CMP)] = + opcode_handler_assoc[static_cast(HyperCPU::Opcode::CMP)] = [this](const IInstruction& instr, OperandContainer op1, OperandContainer op2) -> void { this->ExecCMP(instr, op1, op2); }; + read_io_handlers[0] = io_ctl->GetGetchar(); - read_io_handlers[0] = io_ctl->GetGetchar(); + write_io_handlers[0] = io_ctl->GetPutchar(); - write_io_handlers[0] = io_ctl->GetPutchar(); - - m_decoder = std::make_unique(mem_controller, xip, this); - if (binary) { - std::memcpy(mem_controller->get_ptr(), binary, binary_size); - } + m_decoder = std::make_unique(mem_controller, xip, this); + if (binary) { + std::memcpy(mem_controller->get_ptr(), binary, binary_size); } +} HyperCPU::CPU::~CPU() { delete mem_controller; @@ -258,13 +256,13 @@ void HyperCPU::CPU::Run() { buffer = m_decoder->FetchAndDecode(); switch (buffer.m_opcode) { - case _CONT: - continue; - case IRET: - *xip = StackPop64(); - continue; - default: - break; + case _CONT: + continue; + case IRET: + *xip = StackPop64(); + continue; + default: + break; } std::pair operands = GetOperands(buffer.m_op_types, buffer.m_opcode_mode, buffer.m_op1, buffer.m_op2); diff --git a/src/Emulator/Core/CPU/CPU.hpp b/src/Emulator/Core/CPU/CPU.hpp index c524cbed..b5998dee 100644 --- a/src/Emulator/Core/CPU/CPU.hpp +++ b/src/Emulator/Core/CPU/CPU.hpp @@ -2,14 +2,13 @@ #include "pch.hpp" -#include -#include -#include #include #include +#include +#include +#include #include - #define DECLARE_INSTR(name) void Exec##name(const IInstruction& instr, OperandContainer op1, OperandContainer op2) namespace HyperCPU { @@ -40,7 +39,7 @@ namespace HyperCPU { // GP Registers std::uint64_t *x0, *x1, *x2, *x3, *x4, *x5, *x6, *x7; std::uint32_t *xh0, *xh1, *xh2, *xh3, *xh4, *xh5, *xh6, *xh7; - std::uint32_t *xl0, *xl1,* xl2, *xl3, *xl4, *xl5, *xl6, *xl7; + std::uint32_t *xl0, *xl1, *xl2, *xl3, *xl4, *xl5, *xl6, *xl7; std::uint16_t *xll0, *xll1, *xll2, *xll3; std::uint8_t *xllh0, *xllh1, *xllh2, *xllh3; std::uint8_t *xlll0, *xlll1, *xlll2, *xlll3; @@ -131,4 +130,4 @@ namespace HyperCPU { ~CPU(); }; -} +} // namespace HyperCPU diff --git a/src/Emulator/Core/CPU/Decoders/IDecoder.hpp b/src/Emulator/Core/CPU/Decoders/IDecoder.hpp index 0bf51c75..e6c50e8c 100644 --- a/src/Emulator/Core/CPU/Decoders/IDecoder.hpp +++ b/src/Emulator/Core/CPU/Decoders/IDecoder.hpp @@ -8,4 +8,4 @@ namespace HyperCPU { virtual IInstruction FetchAndDecode() = 0; virtual bool IsHalted() const noexcept = 0; }; -} \ No newline at end of file +} // namespace HyperCPU \ No newline at end of file diff --git a/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp b/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp index d246cbf2..8e447554 100644 --- a/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp +++ b/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp @@ -1,16 +1,18 @@ #include "pch.hpp" -#include -#include -#include -#include +#include #include +#include #include -#include +#include +#include +#include #include - -#define dcdr_assert(expr) RaiseException((expr)); if (cpu && cpu->pending_interrupt.has_value()) return {.m_opcode = _CONT, .m_opcode_mode = b64, .m_op_types = NONE, .m_op1 = {}, .m_op2 = {}, .addr_extension_status = HyperCPU::AddrExtensionStatus::Disabled, .extension = 0} +#define dcdr_assert(expr) \ + RaiseException((expr)); \ + if (cpu && cpu->pending_interrupt.has_value()) \ + return {.m_opcode = _CONT, .m_opcode_mode = b64, .m_op_types = NONE, .m_op1 = {}, .m_op2 = {}, .addr_extension_status = HyperCPU::AddrExtensionStatus::Disabled, .extension = 0} void HyperCPU::Decoder::RaiseException(bool expr) noexcept { if (!(expr)) { @@ -25,16 +27,16 @@ void HyperCPU::Decoder::RaiseException(bool expr) noexcept { bool HyperCPU::Decoder::CheckSupportedOperandSize(std::uint8_t byte, Mode mode) const noexcept { switch (mode) { - case b8: - return byte & 0b11000000; - case b16: - return byte & 0b00110000; - case b32: - return byte & 0b00001100; - case b64: - return byte & 0b00000011; - default: - UNREACHABLE(); + case b8: + return byte & 0b11000000; + case b16: + return byte & 0b00110000; + case b32: + return byte & 0b00001100; + case b64: + return byte & 0b00000011; + default: + UNREACHABLE(); } } @@ -55,10 +57,10 @@ HyperCPU::IInstruction HyperCPU::Decoder::FetchAndDecode() { instruction.m_opcode = static_cast(opcode); switch (instruction.m_opcode) { - case IRET: - return instruction; - default: - break; + case IRET: + return instruction; + default: + break; } // Fetch flags, set opcode Mode and verify operand types @@ -76,114 +78,115 @@ HyperCPU::IInstruction HyperCPU::Decoder::FetchAndDecode() { // Check if op Mode is valid for this opcode dcdr_assert(allowed_op_modes[opcode][static_cast(instruction.m_op_types)]); dcdr_assert((allowed_op_modes[opcode][static_cast(instruction.m_op_types)] == SUPPORT_ALL) || - CheckSupportedOperandSize(allowed_op_modes[opcode][static_cast(instruction.m_op_types)], - instruction.m_opcode_mode)); + CheckSupportedOperandSize(allowed_op_modes[opcode][static_cast(instruction.m_op_types)], + instruction.m_opcode_mode)); switch (instruction.m_op_types) { - case R_R: - case RM_R: - case R_RM: { - std::uint8_t tmp = mem_controller->Fetch8(*xip); - dcdr_assert(Validator::IsValidRegister(tmp)); - instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(tmp)); - - tmp = mem_controller->Fetch8(*xip); - dcdr_assert(Validator::IsValidRegister(tmp)); - instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(tmp)); + case R_R: + case RM_R: + case R_RM: { + std::uint8_t tmp = mem_controller->Fetch8(*xip); + dcdr_assert(Validator::IsValidRegister(tmp)); + instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(tmp)); + + tmp = mem_controller->Fetch8(*xip); + dcdr_assert(Validator::IsValidRegister(tmp)); + instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(tmp)); + break; + } + + case RM_M: + case R_M: { + std::uint8_t tmp = mem_controller->Fetch8(*xip); + dcdr_assert(Validator::IsValidRegister(tmp)); + instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(tmp)); + + instruction.m_op2 = OperandContainer{mem_controller->Fetch64(*xip)}; + break; + } + + case RM_IMM: + case R_IMM: { + std::uint8_t tmp = mem_controller->Fetch8(*xip); + dcdr_assert(Validator::IsValidRegister(tmp)); + instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(tmp)); + + switch (instruction.m_opcode_mode) { + case b8: { + std::uint8_t vtmp = mem_controller->Fetch8(*xip); + instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(vtmp)); break; } - case RM_M: - case R_M: { - std::uint8_t tmp = mem_controller->Fetch8(*xip); - dcdr_assert(Validator::IsValidRegister(tmp)); - instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(tmp)); + case b16: { + std::uint16_t vtmp = mem_controller->Fetch16(*xip); + instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(vtmp)); + break; + } - instruction.m_op2 = OperandContainer{mem_controller->Fetch64(*xip)}; + case b32: { + std::uint32_t vtmp = mem_controller->Fetch32(*xip); + instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(vtmp)); break; } - case RM_IMM: - case R_IMM: { - std::uint8_t tmp = mem_controller->Fetch8(*xip); - dcdr_assert(Validator::IsValidRegister(tmp)); - instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(tmp)); - - switch (instruction.m_opcode_mode) { - case b8: { - std::uint8_t vtmp = mem_controller->Fetch8(*xip); - instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(vtmp)); - break; - } - - case b16: { - std::uint16_t vtmp = mem_controller->Fetch16(*xip); - instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(vtmp)); - break; - } - - case b32: { - std::uint32_t vtmp = mem_controller->Fetch32(*xip); - instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(vtmp)); - break; - } - - case b64: { - instruction.m_op2 = OperandContainer{mem_controller->Fetch64(*xip)}; - break; - } - } + case b64: { + instruction.m_op2 = OperandContainer{mem_controller->Fetch64(*xip)}; break; } + } + break; + } - case M_R: { - instruction.m_op1 = OperandContainer{mem_controller->Fetch64(*xip)}; + case M_R: { + instruction.m_op1 = OperandContainer{mem_controller->Fetch64(*xip)}; - std::uint8_t tmp = mem_controller->Fetch8(*xip); - dcdr_assert(Validator::IsValidRegister(tmp)); - instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(tmp)); + std::uint8_t tmp = mem_controller->Fetch8(*xip); + dcdr_assert(Validator::IsValidRegister(tmp)); + instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(tmp)); + break; + } + + case R: { + std::uint8_t tmp = mem_controller->Fetch8(*xip); + dcdr_assert(Validator::IsValidRegister(tmp)); + instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(tmp)); + break; + } + + case M: + instruction.m_op1 = OperandContainer{mem_controller->Fetch64(*xip)}; + break; + + case IMM: + switch (instruction.m_opcode_mode) { + case b8: { + std::uint8_t vtmp = mem_controller->Fetch8(*xip); + instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(vtmp)); break; } - case R: { - std::uint8_t tmp = mem_controller->Fetch8(*xip); - dcdr_assert(Validator::IsValidRegister(tmp)); - instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(tmp)); + case b16: { + std::uint16_t vtmp = mem_controller->Fetch16(*xip); + instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(vtmp)); break; } - case M: - instruction.m_op1 = OperandContainer{mem_controller->Fetch64(*xip)}; + case b32: { + std::uint32_t vtmp = mem_controller->Fetch32(*xip); + instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(vtmp)); break; + } - case IMM: - switch (instruction.m_opcode_mode) { - case b8: { - std::uint8_t vtmp = mem_controller->Fetch8(*xip); - instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(vtmp)); - break; - } - - case b16: { - std::uint16_t vtmp = mem_controller->Fetch16(*xip); - instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(vtmp)); - break; - } - - case b32: { - std::uint32_t vtmp = mem_controller->Fetch32(*xip); - instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(vtmp)); - break; - } - - case b64: { - instruction.m_op1 = OperandContainer{mem_controller->Fetch64(*xip)}; - break; - } + case b64: { + instruction.m_op1 = OperandContainer{mem_controller->Fetch64(*xip)}; + break; + } } break; - case NONE: break; + case NONE: + break; } return instruction; diff --git a/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp b/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp index ae278e88..ece30b4d 100644 --- a/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp +++ b/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp @@ -2,14 +2,13 @@ #include "pch.hpp" -#include -#include -#include #include +#include +#include +#include #include #include - namespace HyperCPU { enum class AddrExtensionStatus { Disabled = 0b00, @@ -19,37 +18,55 @@ namespace HyperCPU { struct OperandContainer { public: - OperandContainer() : value(0) { } - OperandContainer(std::nullptr_t) : value(0) { } - explicit OperandContainer(std::uint64_t value) : value(value) { } - template - explicit OperandContainer(T* ptr) : value(HyperCPU::bit_cast(ptr)) { } // Supposed to be executed from GetRegister() + OperandContainer() + : value(0) { + } + OperandContainer(std::nullptr_t) + : value(0) { + } + explicit OperandContainer(std::uint64_t value) + : value(value) { + } + template + explicit OperandContainer(T* ptr) + : value(HyperCPU::bit_cast(ptr)) { + } // Supposed to be executed from GetRegister() - operator std::uint8_t() const noexcept { return HyperCPU::bit_cast(value); } - operator std::uint16_t() const noexcept { return HyperCPU::bit_cast(value); } - operator std::uint32_t() const noexcept { return HyperCPU::bit_cast(value); } - operator std::uint64_t() const noexcept { return value; } + operator std::uint8_t() const noexcept { + return HyperCPU::bit_cast(value); + } + operator std::uint16_t() const noexcept { + return HyperCPU::bit_cast(value); + } + operator std::uint32_t() const noexcept { + return HyperCPU::bit_cast(value); + } + operator std::uint64_t() const noexcept { + return value; + } std::uint64_t& ref() noexcept { return value; } - template + template operator T*() const noexcept { return HyperCPU::bit_cast(value); } - template + template T& deref() const noexcept { return *static_cast(*this); } - template + template T* ptr() const noexcept { return static_cast(*this); } - ~OperandContainer() { } + ~OperandContainer() { + } + private: std::uint64_t value; }; @@ -78,17 +95,15 @@ namespace HyperCPU { public: explicit Decoder() = default; // For testing purposes - causes UB if used incorrectly explicit Decoder(IMemoryController* mc, std::uint64_t* counter, class CPU* cpu) - : mem_controller(mc) - , xip(counter) - , cpu(cpu) - , decoder_halted(false) {} + : mem_controller(mc), xip(counter), cpu(cpu), decoder_halted(false) { + } IInstruction FetchAndDecode() override; bool IsHalted() const noexcept override; ~Decoder() = default; }; +}; } ; - }; } diff --git a/src/Emulator/Core/CPU/IO/Simple.cpp b/src/Emulator/Core/CPU/IO/Simple.cpp index 061aee05..5bd83fdc 100644 --- a/src/Emulator/Core/CPU/IO/Simple.cpp +++ b/src/Emulator/Core/CPU/IO/Simple.cpp @@ -6,7 +6,8 @@ #include #include -HyperCPU::SimpleIOImpl::SimpleIOImpl() : state(CurrentState::Default), was_printing(true), printing(true) { +HyperCPU::SimpleIOImpl::SimpleIOImpl() + : state(CurrentState::Default), was_printing(true), printing(true) { tcgetattr(STDIN_FILENO, &oldt); newt = oldt; newt.c_lflag &= ~(ICANON | ECHO); @@ -21,31 +22,31 @@ HyperCPU::SimpleIOImpl::~SimpleIOImpl() { void HyperCPU::SimpleIOImpl::Putchar(std::uint8_t c) { if (state == CurrentState::WaitingForCommand) { - switch(HyperCPU::bit_cast(c)) { - case Command::EnablePrinting: - EnablePrinting(); - printing = true; - was_printing = true; - break; - case Command::DisablePrinting: - DisablePrinting(); - printing = false; - was_printing = false; - break; - default: - break; + switch (HyperCPU::bit_cast(c)) { + case Command::EnablePrinting: + EnablePrinting(); + printing = true; + was_printing = true; + break; + case Command::DisablePrinting: + DisablePrinting(); + printing = false; + was_printing = false; + break; + default: + break; } state = CurrentState::Default; return; } switch (c) { - case 0xFF: - state = CurrentState::WaitingForCommand; - return; - default: - std::putchar(c); - break; + case 0xFF: + state = CurrentState::WaitingForCommand; + return; + default: + std::putchar(c); + break; } } diff --git a/src/Emulator/Core/CPU/IO/Simple.hpp b/src/Emulator/Core/CPU/IO/Simple.hpp index 483ba678..b99755f9 100644 --- a/src/Emulator/Core/CPU/IO/Simple.hpp +++ b/src/Emulator/Core/CPU/IO/Simple.hpp @@ -11,6 +11,7 @@ namespace HyperCPU { std::function GetGetchar(); ~SimpleIOImpl(); + private: enum class CurrentState { Default, @@ -33,4 +34,4 @@ namespace HyperCPU { bool was_printing, printing; struct termios oldt, newt; }; -} +} // namespace HyperCPU diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp index 3dc41f43..50a97f49 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp @@ -1,161 +1,176 @@ #include "pch.hpp" -#include #include +#include #include #include - using namespace HyperALU; void HyperCPU::CPU::ExecADC(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - if (crf) ++op1.deref(); - break; - - case b16: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - if (crf) ++op1.deref(); - break; - - case b32: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - if (crf) ++op1.deref(); - break; - - case b64: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - if (crf) ++op1.deref(); - break; - } - break; - } - - case R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - } - break; - } - - case R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - } - break; - } - - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - } - break; - } - - default: + case R_R: { + switch (instr.m_opcode_mode) { + case b8: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + if (crf) + ++op1.deref(); + break; + + case b16: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + if (crf) + ++op1.deref(); + break; + + case b32: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + if (crf) + ++op1.deref(); + break; + + case b64: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + if (crf) + ++op1.deref(); + break; + } + break; + } + + case R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + } + break; + } + + case R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + } + break; + } + + case R_IMM: { + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); break; + } + + case b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp index 645277c3..c8311b5b 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp @@ -1,143 +1,142 @@ #include "pch.hpp" -#include #include +#include #include #include - void HyperCPU::CPU::ExecADD(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b16: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b32: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b64: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - break; - } - - case R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - } - break; - } - - case R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - } - break; - } - - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - } - break; - } - - default: + case R_R: { + switch (instr.m_opcode_mode) { + case b8: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b16: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b32: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b64: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + break; + } + + case R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + } + break; + } + + case R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + } + break; + } + + case R_IMM: { + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); break; + } + + case b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp b/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp index bdcd75fe..4b4fbd00 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp @@ -1,128 +1,127 @@ #include "pch.hpp" -#include #include +#include #include - using namespace HyperALU; void HyperCPU::CPU::ExecAND(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b16: - op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b32: - op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b64: - op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - break; - } - - case R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - } - break; - } - - case R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - } - break; - } - - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - } + case R_R: { + switch (instr.m_opcode_mode) { + case b8: + op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b16: + op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b32: + op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b64: + op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + break; + } + + case R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + } + break; + } + + case R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); break; - } + } + } + break; + } - default: + case R_IMM: { + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_and(op1.deref(), val); break; + } + + case b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp index 19b42d52..705949ed 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp @@ -1,148 +1,147 @@ #include "pch.hpp" -#include #include +#include #include - using namespace HyperALU; void HyperCPU::CPU::ExecANDN(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: { - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - - case b16: { - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - - case b32: { - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - - case b64: { - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - } - break; - } - - case R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - } - break; - } - - case R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - } - break; - } - - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - } - break; - } - - default: + case R_R: { + switch (instr.m_opcode_mode) { + case b8: { + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + + case b16: { + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + + case b32: { + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + + case b64: { + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + } + break; + } + + case R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + } + break; + } + + case R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + } + break; + } + + case R_IMM: { + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); break; + } + + case b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp index b90d09f7..340a5ac2 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp @@ -4,32 +4,31 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" void HyperCPU::CPU::ExecBSWAP(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_opcode_mode) { - case b8: - break; - - case b16: { - auto& dst = op1.deref(); - dst = HyperCPU::byteswap(dst); - break; - } - - case b32: { - auto& dst = op1.deref(); - dst = HyperCPU::byteswap(dst); - break; - } - - case b64: { - auto& dst = op1.deref(); - dst = HyperCPU::byteswap(dst); - break; - } + case b8: + break; + + case b16: { + auto& dst = op1.deref(); + dst = HyperCPU::byteswap(dst); + break; + } + + case b32: { + auto& dst = op1.deref(); + dst = HyperCPU::byteswap(dst); + break; + } + + case b64: { + auto& dst = op1.deref(); + dst = HyperCPU::byteswap(dst); + break; + } } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp index 4e9f304b..1be42d21 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp @@ -7,23 +7,22 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" void HyperCPU::CPU::ExecCALL(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { // Placeholders - case R: - StackPush64(*xip); - *xip = op1.deref(); - break; - case IMM: - StackPush64(*xip); - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecCALL placeholder reached: please report bug\n"; exit(1); }); - break; + case R: + StackPush64(*xip); + *xip = op1.deref(); + break; + case IMM: + StackPush64(*xip); + *xip = HyperCPU::bit_cast(op1); + break; + default: + h_assert(false, {std::cout << "HyperCPU::CPU::ExecCALL placeholder reached: please report bug\n"; exit(1); }); + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp index 1523d6fc..a2cf7f3c 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp @@ -7,7 +7,6 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" @@ -17,17 +16,17 @@ void HyperCPU::CPU::ExecCALLE(const IInstruction& instr, OperandContainer op1, O } switch (instr.m_op_types) { // Placeholders - case R: - StackPush64(*xip); - *xip = op1.deref(); - break; - case IMM: - StackPush64(*xip); - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; exit(1); }); - break; + case R: + StackPush64(*xip); + *xip = op1.deref(); + break; + case IMM: + StackPush64(*xip); + *xip = HyperCPU::bit_cast(op1); + break; + default: + h_assert(false, {std::cout << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; exit(1); }); + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp index 57cc42aa..e7998716 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp @@ -7,7 +7,6 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" @@ -17,17 +16,17 @@ void HyperCPU::CPU::ExecCALLGR(const IInstruction& instr, OperandContainer op1, } switch (instr.m_op_types) { // Placeholders - case R: - StackPush64(*xip); - *xip = op1.deref(); - break; - case IMM: - StackPush64(*xip); - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecCALLGR placeholder reached: please report bug\n"; exit(1); }); - break; + case R: + StackPush64(*xip); + *xip = op1.deref(); + break; + case IMM: + StackPush64(*xip); + *xip = HyperCPU::bit_cast(op1); + break; + default: + h_assert(false, {std::cout << "HyperCPU::CPU::ExecCALLGR placeholder reached: please report bug\n"; exit(1); }); + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp index dfbec7ec..4dac39f6 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp @@ -7,7 +7,6 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" @@ -17,17 +16,17 @@ void HyperCPU::CPU::ExecCALLL(const IInstruction& instr, OperandContainer op1, O } switch (instr.m_op_types) { // Placeholders - case R: - StackPush64(*xip); - *xip = op1.deref(); - break; - case IMM: - StackPush64(*xip); - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecCALLL placeholder reached: please report bug\n"; exit(1); }); - break; + case R: + StackPush64(*xip); + *xip = op1.deref(); + break; + case IMM: + StackPush64(*xip); + *xip = HyperCPU::bit_cast(op1); + break; + default: + h_assert(false, {std::cout << "HyperCPU::CPU::ExecCALLL placeholder reached: please report bug\n"; exit(1); }); + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp index bb8addc4..c75aebf0 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp @@ -2,7 +2,6 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp index 12bf334d..f9608757 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp @@ -1,221 +1,220 @@ #include "pch.hpp" -#include #include +#include #include - void HyperCPU::CPU::ExecCMP(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { std::int8_t res = 0; switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); - break; + case R_R: { + switch (instr.m_opcode_mode) { + case b8: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b16: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); - break; + case b16: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b32: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); - break; + case b32: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b64: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); - break; - } + case b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); break; } + break; + } - case R_RM: { - std::uint64_t ptr; - std::memcpy(&ptr, op2.ptr(), 8); + case R_RM: { + std::uint64_t ptr; + std::memcpy(&ptr, op2.ptr(), 8); - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read8(ptr)); - break; + switch (instr.m_opcode_mode) { + case b8: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read8(ptr)); + break; - case b16: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); - break; + case b16: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); + break; - case b32: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); - break; + case b32: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); + break; - case b64: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); - break; - } + case b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); break; } + break; + } - case R_M: { - std::uint64_t ptr = op2; + case R_M: { + std::uint64_t ptr = op2; - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read8(ptr)); - break; + switch (instr.m_opcode_mode) { + case b8: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read8(ptr)); + break; - case b16: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); - break; + case b16: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); + break; - case b32: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); - break; + case b32: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); + break; - case b64: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); - break; - } + case b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); break; } + break; + } - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); - break; + case R_IMM: { + switch (instr.m_opcode_mode) { + case b8: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); + break; - case b16: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); - break; + case b16: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); + break; - case b32: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); - break; + case b32: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); + break; - case b64: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); - break; - } + case b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); break; } + break; + } - case RM_M: { - std::uint64_t ptr1, ptr2 = 0; - std::memcpy(&ptr1, op1.ptr(), 8); - ptr2 = HyperCPU::bit_cast(op2); + case RM_M: { + std::uint64_t ptr1, ptr2 = 0; + std::memcpy(&ptr1, op1.ptr(), 8); + ptr2 = HyperCPU::bit_cast(op2); - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr1), mem_controller->Read8(ptr2)); - break; + switch (instr.m_opcode_mode) { + case b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr1), mem_controller->Read8(ptr2)); + break; - case b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr1), mem_controller->Read16(ptr2)); - break; + case b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr1), mem_controller->Read16(ptr2)); + break; - case b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr1), mem_controller->Read32(ptr2)); - break; + case b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr1), mem_controller->Read32(ptr2)); + break; - case b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr1), mem_controller->Read64(ptr2)); - break; - } + case b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr1), mem_controller->Read64(ptr2)); break; } + break; + } - case RM_R: { - std::uint64_t ptr = op1.deref(); + case RM_R: { + std::uint64_t ptr = op1.deref(); - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + switch (instr.m_opcode_mode) { + case b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + case b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + case b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; - } + case b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; } + break; + } - case RM_IMM: { - std::uint64_t ptr = op1.deref(); + case RM_IMM: { + std::uint64_t ptr = op1.deref(); - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast(op2)); - break; + switch (instr.m_opcode_mode) { + case b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast(op2)); + break; - case b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast(op2)); - break; + case b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast(op2)); + break; - case b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast(op2)); - break; + case b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast(op2)); + break; - case b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast(op2)); - break; - } + case b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast(op2)); break; } + break; + } - case M_R: { - std::size_t ptr = HyperCPU::bit_cast(op1); + case M_R: { + std::size_t ptr = HyperCPU::bit_cast(op1); - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + switch (instr.m_opcode_mode) { + case b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + case b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + case b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; - } + case b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; } + break; + } - default: - break; + default: + break; } switch (res) { - case -1: - zrf = 0; - crf = 1; - break; - case 0: - zrf = 1; - crf = 0; - break; - case 1: - zrf = 0; - crf = 0; - break; + case -1: + zrf = 0; + crf = 1; + break; + case 0: + zrf = 1; + crf = 0; + break; + case 1: + zrf = 0; + crf = 0; + break; } } - crf = 0; - break; - case 1: - zrf = 0; - crf = 0; - break; - } +crf = 0; +break; +case 1: +zrf = 0; +crf = 0; +break; +} } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp b/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp index 606f8a64..187a8166 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp @@ -2,7 +2,6 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp index 589f0f51..5d7f8a6d 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp @@ -2,7 +2,6 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" diff --git a/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp b/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp index 525a87ef..ca21eca6 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp @@ -2,39 +2,38 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" void HyperCPU::CPU::ExecDEC(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_opcode_mode) { - case b8: { - auto& dst = op1.deref(); - udf = (dst == 0); - --dst; - break; - } + case b8: { + auto& dst = op1.deref(); + udf = (dst == 0); + --dst; + break; + } - case b16: { - auto& dst = op1.deref(); - udf = (dst == 0); - --dst; - break; - } + case b16: { + auto& dst = op1.deref(); + udf = (dst == 0); + --dst; + break; + } - case b32: { - auto& dst = op1.deref(); - udf = (dst == 0); - --dst; - break; - } + case b32: { + auto& dst = op1.deref(); + udf = (dst == 0); + --dst; + break; + } - case b64: { - auto& dst = op1.deref(); - udf = (dst == 0); - --dst; - break; - } + case b64: { + auto& dst = op1.deref(); + udf = (dst == 0); + --dst; + break; + } } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp b/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp index 35135a75..6fcfa040 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp @@ -1,9 +1,8 @@ #include "pch.hpp" -#include -#include #include - +#include +#include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" @@ -17,33 +16,33 @@ void HyperCPU::CPU::ExecDIV(const IInstruction& instr, OperandContainer op1, Ope } switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t& dst = op1.deref(); - *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); - dst = __hcpu_div(dst, static_cast(*x2)); - break; - } - - case b16: { - auto& dst = op1.deref(); - *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); - dst = __hcpu_div(dst, static_cast(*x2)); - break; - } - - case b32: { - auto& dst = op1.deref(); - *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); - dst = __hcpu_div(dst, static_cast(*x2)); - break; - } - - case b64: { - auto& dst = op1.deref(); - *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); - dst = __hcpu_div(dst, static_cast(*x2)); - break; - } + case b8: { + std::uint8_t& dst = op1.deref(); + *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); + dst = __hcpu_div(dst, static_cast(*x2)); + break; + } + + case b16: { + auto& dst = op1.deref(); + *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); + dst = __hcpu_div(dst, static_cast(*x2)); + break; + } + + case b32: { + auto& dst = op1.deref(); + *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); + dst = __hcpu_div(dst, static_cast(*x2)); + break; + } + + case b64: { + auto& dst = op1.deref(); + *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); + dst = __hcpu_div(dst, static_cast(*x2)); + break; + } } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp b/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp index b73f1753..c941ec5e 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp @@ -2,7 +2,6 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" diff --git a/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp b/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp index 82648b1e..5badf850 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp @@ -3,23 +3,22 @@ #include #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" void HyperCPU::CPU::ExecHID(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (*x0) { - case 0: - *x0 = 2; - break; - case 1: - std::strcpy(std::bit_cast(&data), HID_CPU_NAME); - break; - case 2: - *x0 = 0; - break; - default: - break; + case 0: + *x0 = 2; + break; + case 1: + std::strcpy(std::bit_cast(&data), HID_CPU_NAME); + break; + case 2: + *x0 = 0; + break; + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp b/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp index fb8905f2..01828f0c 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp @@ -2,39 +2,38 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" void HyperCPU::CPU::ExecINC(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_opcode_mode) { - case b8: { - auto& dst = op1.deref(); - ++dst; - ovf = (dst == 0); - break; - } + case b8: { + auto& dst = op1.deref(); + ++dst; + ovf = (dst == 0); + break; + } - case b16: { - auto& dst = op1.deref(); - ++dst; - ovf = (dst == 0); - break; - } + case b16: { + auto& dst = op1.deref(); + ++dst; + ovf = (dst == 0); + break; + } - case b32: { - auto& dst = op1.deref(); - ++dst; - ovf = (dst == 0); - break; - } + case b32: { + auto& dst = op1.deref(); + ++dst; + ovf = (dst == 0); + break; + } - case b64: { - auto& dst = op1.deref(); - ++dst; - ovf = (dst == 0); - break; - } + case b64: { + auto& dst = op1.deref(); + ++dst; + ovf = (dst == 0); + break; + } } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp index 4c09b21f..83d9c36c 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp @@ -1,11 +1,10 @@ #include "pch.hpp" -#include #include +#include #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" @@ -13,10 +12,18 @@ void HyperCPU::CPU::ExecINTR(const IInstruction& instr, OperandContainer op1, Op std::uint64_t num = 0; switch (instr.m_opcode_mode) { - case b8: num = HyperCPU::bit_cast_from(op1.ptr()); break; - case b16: num = HyperCPU::bit_cast_from(op1.ptr()); break; - case b32: num = HyperCPU::bit_cast_from(op1.ptr()); break; - case b64: num = HyperCPU::bit_cast_from(op1.ptr()); break; + case b8: + num = HyperCPU::bit_cast_from(op1.ptr()); + break; + case b16: + num = HyperCPU::bit_cast_from(op1.ptr()); + break; + case b32: + num = HyperCPU::bit_cast_from(op1.ptr()); + break; + case b64: + num = HyperCPU::bit_cast_from(op1.ptr()); + break; } if (num > 255) { diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp index 85a066f2..ba913d99 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp @@ -7,7 +7,6 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" @@ -17,15 +16,15 @@ void HyperCPU::CPU::ExecJME(const IInstruction& instr, OperandContainer op1, Ope } switch (instr.m_op_types) { // Placeholders - case R: - *xip = op1.deref(); - break; - case IMM: - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecJMP placeholder reached: please report bug\n"; exit(1); }); - break; + case R: + *xip = op1.deref(); + break; + case IMM: + *xip = HyperCPU::bit_cast(op1); + break; + default: + h_assert(false, {std::cout << "HyperCPU::CPU::ExecJMP placeholder reached: please report bug\n"; exit(1); }); + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp index d3e16548..b59bc32e 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp @@ -7,7 +7,6 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" @@ -17,15 +16,15 @@ void HyperCPU::CPU::ExecJMGR(const IInstruction& instr, OperandContainer op1, Op } switch (instr.m_op_types) { // Placeholders - case R: - *xip = op1.deref(); - break; - case IMM: - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecJMP placeholder reached: please report bug\n"; exit(1); }); - break; + case R: + *xip = op1.deref(); + break; + case IMM: + *xip = HyperCPU::bit_cast(op1); + break; + default: + h_assert(false, {std::cout << "HyperCPU::CPU::ExecJMP placeholder reached: please report bug\n"; exit(1); }); + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp index f71346ff..0ef0ce20 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp @@ -7,7 +7,6 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" @@ -17,15 +16,15 @@ void HyperCPU::CPU::ExecJML(const IInstruction& instr, OperandContainer op1, Ope } switch (instr.m_op_types) { // Placeholders - case R: - *xip = op1.deref(); - break; - case IMM: - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecJMP placeholder reached: please report bug\n"; exit(1); }); - break; + case R: + *xip = op1.deref(); + break; + case IMM: + *xip = HyperCPU::bit_cast(op1); + break; + default: + h_assert(false, {std::cout << "HyperCPU::CPU::ExecJMP placeholder reached: please report bug\n"; exit(1); }); + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp index 85aaf82a..3e6d8708 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp @@ -7,21 +7,20 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" void HyperCPU::CPU::ExecJMP(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { // Placeholders - case R: - *xip = op1.deref(); - break; - case IMM: - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecJMP placeholder reached: please report bug\n"; exit(1); }); - break; + case R: + *xip = op1.deref(); + break; + case IMM: + *xip = HyperCPU::bit_cast(op1); + break; + default: + h_assert(false, {std::cout << "HyperCPU::CPU::ExecJMP placeholder reached: please report bug\n"; exit(1); }); + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp b/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp index 6c11e264..3a0fe67b 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp @@ -5,19 +5,19 @@ #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" void HyperCPU::CPU::ExecLOIVT(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case IMM: - *xivt = HyperCPU::bit_cast(op1); - break; - case R: - *xivt = HyperCPU::bit_cast_from(op1.ptr()); - break; - default: ABORT(); + case IMM: + *xivt = HyperCPU::bit_cast(op1); + break; + case R: + *xivt = HyperCPU::bit_cast_from(op1.ptr()); + break; + default: + ABORT(); } ivt_initialized = true; } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp b/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp index 80eba416..32d176e1 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp @@ -4,201 +4,200 @@ #include - void HyperCPU::CPU::ExecMOV(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - std::memcpy(op1, op2.ptr(), 1); - break; + case R_R: { + switch (instr.m_opcode_mode) { + case b8: + std::memcpy(op1, op2.ptr(), 1); + break; - case b16: - std::memcpy(op1, op2.ptr(), 2); - break; + case b16: + std::memcpy(op1, op2.ptr(), 2); + break; - case b32: - std::memcpy(op1, op2.ptr(), 4); - break; + case b32: + std::memcpy(op1, op2.ptr(), 4); + break; - case b64: - std::memcpy(op1, op2.ptr(), 8); - break; - } + case b64: + std::memcpy(op1, op2.ptr(), 8); break; } + break; + } - case R_RM: { - std::uint64_t ptr; - std::memcpy(&ptr, op2.ptr(), 8); + case R_RM: { + std::uint64_t ptr; + std::memcpy(&ptr, op2.ptr(), 8); - switch (instr.m_opcode_mode) { - case b8: - *static_cast(op1) = mem_controller->Read8(ptr); - break; + switch (instr.m_opcode_mode) { + case b8: + *static_cast(op1) = mem_controller->Read8(ptr); + break; - case b16: - *static_cast(op1) = mem_controller->Read16(ptr); - break; + case b16: + *static_cast(op1) = mem_controller->Read16(ptr); + break; - case b32: - *static_cast(op1) = mem_controller->Read32(ptr); - break; + case b32: + *static_cast(op1) = mem_controller->Read32(ptr); + break; - case b64: - *static_cast(op1) = mem_controller->Read64(ptr); - break; - } + case b64: + *static_cast(op1) = mem_controller->Read64(ptr); break; } + break; + } - case R_M: { - std::uint64_t ptr = op2; + case R_M: { + std::uint64_t ptr = op2; - switch (instr.m_opcode_mode) { - case b8: - *static_cast(op1) = mem_controller->Read8(ptr); - break; + switch (instr.m_opcode_mode) { + case b8: + *static_cast(op1) = mem_controller->Read8(ptr); + break; - case b16: - *static_cast(op1) = mem_controller->Read16(ptr); - break; + case b16: + *static_cast(op1) = mem_controller->Read16(ptr); + break; - case b32: - *static_cast(op1) = mem_controller->Read32(ptr); - break; + case b32: + *static_cast(op1) = mem_controller->Read32(ptr); + break; - case b64: - *static_cast(op1) = mem_controller->Read64(ptr); - break; - } + case b64: + *static_cast(op1) = mem_controller->Read64(ptr); break; } + break; + } - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: - std::memcpy(op1, &op2.ref(), 1); - break; + case R_IMM: { + switch (instr.m_opcode_mode) { + case b8: + std::memcpy(op1, &op2.ref(), 1); + break; - case b16: - std::memcpy(op1, &op2.ref(), 2); - break; + case b16: + std::memcpy(op1, &op2.ref(), 2); + break; - case b32: - std::memcpy(op1, &op2.ref(), 4); - break; + case b32: + std::memcpy(op1, &op2.ref(), 4); + break; - case b64: - std::memcpy(op1, &op2.ref(), 8); - break; - } + case b64: + std::memcpy(op1, &op2.ref(), 8); break; } + break; + } - case RM_M: { - std::uint64_t ptr1, ptr2 = 0; - std::memcpy(&ptr1, op1.ptr(), 8); - ptr2 = op2; + case RM_M: { + std::uint64_t ptr1, ptr2 = 0; + std::memcpy(&ptr1, op1.ptr(), 8); + ptr2 = op2; - switch (instr.m_opcode_mode) { - case b8: - mem_controller->Load8(ptr1, mem_controller->Read8(ptr2)); - break; + switch (instr.m_opcode_mode) { + case b8: + mem_controller->Load8(ptr1, mem_controller->Read8(ptr2)); + break; - case b16: - mem_controller->Load16(ptr1, mem_controller->Read16(ptr2)); - break; + case b16: + mem_controller->Load16(ptr1, mem_controller->Read16(ptr2)); + break; - case b32: - mem_controller->Load32(ptr1, mem_controller->Read32(ptr2)); - break; + case b32: + mem_controller->Load32(ptr1, mem_controller->Read32(ptr2)); + break; - case b64: - mem_controller->Load64(ptr1, mem_controller->Read64(ptr2)); - break; - } + case b64: + mem_controller->Load64(ptr1, mem_controller->Read64(ptr2)); break; } + break; + } - case RM_R: { - std::uint64_t ptr = op1.deref(); + case RM_R: { + std::uint64_t ptr = op1.deref(); - switch (instr.m_opcode_mode) { - case b8: { - mem_controller->Load8(ptr, *static_cast(op2)); - break; - } + switch (instr.m_opcode_mode) { + case b8: { + mem_controller->Load8(ptr, *static_cast(op2)); + break; + } - case b16: { - mem_controller->Load16(ptr, *static_cast(op2)); - break; - } + case b16: { + mem_controller->Load16(ptr, *static_cast(op2)); + break; + } - case b32: { - mem_controller->Load32(ptr, *static_cast(op2)); - break; - } + case b32: { + mem_controller->Load32(ptr, *static_cast(op2)); + break; + } - case b64: { - mem_controller->Load64(ptr, *static_cast(op2)); - break; - } - } + case b64: { + mem_controller->Load64(ptr, *static_cast(op2)); break; } + } + break; + } - case RM_IMM: { - std::uint64_t ptr1 = op1.deref(); + case RM_IMM: { + std::uint64_t ptr1 = op1.deref(); - switch (instr.m_opcode_mode) { - case b8: - mem_controller->Load8(ptr1, HyperCPU::bit_cast(op2)); - break; + switch (instr.m_opcode_mode) { + case b8: + mem_controller->Load8(ptr1, HyperCPU::bit_cast(op2)); + break; - case b16: - mem_controller->Load16(ptr1, HyperCPU::bit_cast(op2)); - break; + case b16: + mem_controller->Load16(ptr1, HyperCPU::bit_cast(op2)); + break; - case b32: - mem_controller->Load32(ptr1, HyperCPU::bit_cast(op2)); - break; + case b32: + mem_controller->Load32(ptr1, HyperCPU::bit_cast(op2)); + break; - case b64: - mem_controller->Load64(ptr1, HyperCPU::bit_cast(op2)); - break; - } + case b64: + mem_controller->Load64(ptr1, HyperCPU::bit_cast(op2)); break; } + break; + } - case M_R: { - std::size_t ptr1 = HyperCPU::bit_cast(op1); - - switch (instr.m_opcode_mode) { - case b8: { - mem_controller->Load8(ptr1, HyperCPU::bit_cast_from(op2.ptr())); - break; - } + case M_R: { + std::size_t ptr1 = HyperCPU::bit_cast(op1); - case b16: { - mem_controller->Load16(ptr1, HyperCPU::bit_cast_from(op2.ptr())); - break; - } + switch (instr.m_opcode_mode) { + case b8: { + mem_controller->Load8(ptr1, HyperCPU::bit_cast_from(op2.ptr())); + break; + } - case b32: { - mem_controller->Load32(ptr1, HyperCPU::bit_cast_from(op2.ptr())); - break; - } + case b16: { + mem_controller->Load16(ptr1, HyperCPU::bit_cast_from(op2.ptr())); + break; + } - case b64: { - mem_controller->Load64(ptr1, HyperCPU::bit_cast_from(op2.ptr())); - break; - } - } + case b32: { + mem_controller->Load32(ptr1, HyperCPU::bit_cast_from(op2.ptr())); break; } - default: + case b64: { + mem_controller->Load64(ptr1, HyperCPU::bit_cast_from(op2.ptr())); break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp index 8dccc83a..1b6e6494 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp @@ -2,146 +2,145 @@ #include -#include #include +#include #include #include - using namespace HyperALU; void HyperCPU::CPU::ExecMUL(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - ovf = multiplication_will_overflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b16: - ovf = multiplication_will_overflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b32: - ovf = multiplication_will_overflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b64: - ovf = multiplication_will_overflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - break; - } - - case R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - } - break; - } - - case R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - } - break; - } - - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - } - break; - } - - default: + case R_R: { + switch (instr.m_opcode_mode) { + case b8: + ovf = multiplication_will_overflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b16: + ovf = multiplication_will_overflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b32: + ovf = multiplication_will_overflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b64: + ovf = multiplication_will_overflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + break; + } + + case R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + } + break; + } + + case R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + } + break; + } + + case R_IMM: { + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); break; + } + + case b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp index 5eb7ae8c..d0b0d6fd 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp @@ -1,128 +1,127 @@ #include "pch.hpp" -#include #include +#include #include - using namespace HyperALU; void HyperCPU::CPU::ExecOR(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b16: - op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b32: - op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b64: - op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - break; - } - - case R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - } - break; - } - - case R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - } - break; - } - - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - } + case R_R: { + switch (instr.m_opcode_mode) { + case b8: + op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b16: + op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b32: + op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b64: + op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + break; + } + + case R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + } + break; + } + + case R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); break; - } + } + } + break; + } - default: + case R_IMM: { + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_or(op1.deref(), val); break; + } + + case b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp index 788f4e49..948e9871 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp @@ -1,26 +1,34 @@ #include "pch.hpp" -#include #include +#include #include - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" void HyperCPU::CPU::ExecPOP(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R: - switch (instr.m_opcode_mode) { - case HyperCPU::Mode::b8: op1.deref() = StackPop8(); break; - case HyperCPU::Mode::b16: op1.deref() = StackPop16(); break; - case HyperCPU::Mode::b32: op1.deref() = StackPop32(); break; - case HyperCPU::Mode::b64: op1.deref() = StackPop64(); break; - default: UNREACHABLE(); - } + case R: + switch (instr.m_opcode_mode) { + case HyperCPU::Mode::b8: + op1.deref() = StackPop8(); + break; + case HyperCPU::Mode::b16: + op1.deref() = StackPop16(); + break; + case HyperCPU::Mode::b32: + op1.deref() = StackPop32(); + break; + case HyperCPU::Mode::b64: + op1.deref() = StackPop64(); break; default: UNREACHABLE(); + } + break; + default: + UNREACHABLE(); } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp b/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp index f6914651..f6a30a70 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp @@ -1,36 +1,53 @@ #include "pch.hpp" -#include -#include #include +#include #include - +#include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" void HyperCPU::CPU::ExecPUSH(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R: - switch (instr.m_opcode_mode) { - case HyperCPU::Mode::b8: StackPush8(HyperCPU::bit_cast_from(op1.ptr())); break; - case HyperCPU::Mode::b16: StackPush16(HyperCPU::bit_cast_from(op1.ptr())); break; - case HyperCPU::Mode::b32: StackPush32(HyperCPU::bit_cast_from(op1.ptr())); break; - case HyperCPU::Mode::b64: StackPush64(HyperCPU::bit_cast_from(op1.ptr())); break; - default: UNREACHABLE(); - } - break; - case IMM: - switch (instr.m_opcode_mode) { - case HyperCPU::Mode::b8: StackPush8(HyperCPU::bit_cast(op1)); break; - case HyperCPU::Mode::b16: StackPush16(HyperCPU::bit_cast(op1)); break; - case HyperCPU::Mode::b32: StackPush32(HyperCPU::bit_cast(op1)); break; - case HyperCPU::Mode::b64: StackPush64(HyperCPU::bit_cast(op1)); break; - default: UNREACHABLE(); - } + case R: + switch (instr.m_opcode_mode) { + case HyperCPU::Mode::b8: + StackPush8(HyperCPU::bit_cast_from(op1.ptr())); + break; + case HyperCPU::Mode::b16: + StackPush16(HyperCPU::bit_cast_from(op1.ptr())); + break; + case HyperCPU::Mode::b32: + StackPush32(HyperCPU::bit_cast_from(op1.ptr())); + break; + case HyperCPU::Mode::b64: + StackPush64(HyperCPU::bit_cast_from(op1.ptr())); + break; + default: + UNREACHABLE(); + } + break; + case IMM: + switch (instr.m_opcode_mode) { + case HyperCPU::Mode::b8: + StackPush8(HyperCPU::bit_cast(op1)); + break; + case HyperCPU::Mode::b16: + StackPush16(HyperCPU::bit_cast(op1)); + break; + case HyperCPU::Mode::b32: + StackPush32(HyperCPU::bit_cast(op1)); + break; + case HyperCPU::Mode::b64: + StackPush64(HyperCPU::bit_cast(op1)); break; default: UNREACHABLE(); + } + break; + default: + UNREACHABLE(); } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp b/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp index 2dcb236f..750efb7f 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp @@ -1,10 +1,9 @@ #include "pch.hpp" -#include -#include #include +#include #include - +#include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" @@ -12,14 +11,14 @@ void HyperCPU::CPU::ExecREAD(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { read_operation_handler* handler = nullptr; switch (instr.m_op_types) { - case HyperCPU::IMM: - handler = &read_io_handlers[HyperCPU::bit_cast(op1)]; - break; - case HyperCPU::R: - handler = &read_io_handlers[HyperCPU::bit_cast_from(op1.ptr())]; - break; - default: - UNREACHABLE(); + case HyperCPU::IMM: + handler = &read_io_handlers[HyperCPU::bit_cast(op1)]; + break; + case HyperCPU::R: + handler = &read_io_handlers[HyperCPU::bit_cast_from(op1.ptr())]; + break; + default: + UNREACHABLE(); } if (handler) { diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp index cfcbc6f6..087b49a0 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp @@ -4,60 +4,59 @@ #include - void HyperCPU::CPU::ExecSHFL(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; + case R_R: { + switch (instr.m_opcode_mode) { + case b8: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; + + case b16: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; - case b16: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; + case b32: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; - case b32: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; + case b64: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; + } + break; + } - case b64: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; - } + case R_IMM: { + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; break; } - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - op1.deref() <<= val; - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - op1.deref() <<= val; - break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - op1.deref() <<= val; - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - op1.deref() <<= val; - break; - } - } + case b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; break; } - default: + case b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; break; + } + + case b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp index d6417a3a..af9d0829 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp @@ -1,64 +1,63 @@ #include "pch.hpp" -#include #include +#include #include - void HyperCPU::CPU::ExecSHFR(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - op1.deref() >>= op2.deref(); - break; + case R_R: { + switch (instr.m_opcode_mode) { + case b8: + op1.deref() >>= op2.deref(); + break; - case b16: - op1.deref() >>= op2.deref(); - break; + case b16: + op1.deref() >>= op2.deref(); + break; - case b32: - op1.deref() >>= op2.deref(); - break; + case b32: + op1.deref() >>= op2.deref(); + break; - case b64: - op1.deref() >>= op2.deref(); - break; - } + case b64: + op1.deref() >>= op2.deref(); break; } + break; + } - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - op1.deref() >>= val; - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - op1.deref() >>= val; - break; - } + case R_IMM: { + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; + break; + } - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - op1.deref() >>= val; - break; - } + case b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; + break; + } - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - op1.deref() >>= val; - break; - } - } + case b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; break; } - default: + case b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp index 5edc7633..cc117636 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp @@ -1,145 +1,144 @@ #include "pch.hpp" -#include #include +#include #include #include - using namespace HyperALU; void HyperCPU::CPU::ExecSUB(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b16: - udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b32: - udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b64: - udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } // TODO: mark defaults as std::unreachable() + case R_R: { + switch (instr.m_opcode_mode) { + case b8: + udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b16: + udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b32: + udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case b64: + udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } // TODO: mark defaults as std::unreachable() + break; + } + + case R_RM: { + std::uint64_t ptr = op2.deref(); + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); break; } - case R_RM: { - std::uint64_t ptr = op2.deref(); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - } + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); break; } - case R_M: { - std::uint64_t ptr = op2; - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - } + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + } + break; + } + + case R_M: { + std::uint64_t ptr = op2; + + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = mem_controller->Read8(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); break; } - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - } + case b16: { + std::uint16_t val = mem_controller->Read16(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); break; } - default: + case b32: { + std::uint32_t val = mem_controller->Read32(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); break; + } + + case b64: { + std::uint64_t val = mem_controller->Read64(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + } + break; + } + + case R_IMM: { + switch (instr.m_opcode_mode) { + case b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp b/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp index ed7317df..8073ad56 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp @@ -1,10 +1,9 @@ #include "pch.hpp" -#include -#include #include +#include #include - +#include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" @@ -14,14 +13,14 @@ void HyperCPU::CPU::ExecWRITE(const IInstruction& instr, OperandContainer op1, O if (handler) { switch (instr.m_op_types) { - case R_R: - handler(*static_cast(op2)); - break; - case R_IMM: - handler(HyperCPU::bit_cast(op2)); - break; - default: - UNREACHABLE(); + case R_R: + handler(*static_cast(op2)); + break; + case R_IMM: + handler(HyperCPU::bit_cast(op2)); + break; + default: + UNREACHABLE(); } } } diff --git a/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp b/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp index c5d732f5..7c02c43c 100644 --- a/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp +++ b/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp @@ -1,11 +1,10 @@ #include "pch.hpp" -#include -#include -#include #include +#include +#include #include - +#include void HyperCPU::CPU::TriggerInterrupt(HyperCPU::cpu_exceptions exception) { if (!ivt_initialized || pending_interrupt.has_value()) { @@ -27,7 +26,8 @@ void HyperCPU::CPU::TriggerInterrupt(HyperCPU::cpu_exceptions exception) { void HyperCPU::CPU::RunInterruptSubroutine() { while (1) { - if (halted) return; + if (halted) + return; HyperCPU::IInstruction instr = m_decoder->FetchAndDecode(); if (instr.m_opcode == Opcode::IRET) { diff --git a/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp b/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp index 74d5d8d0..b3cc0cab 100644 --- a/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp +++ b/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp @@ -2,7 +2,6 @@ #include "pch.hpp" - namespace HyperCPU { enum class cpu_exceptions : std::uint_fast8_t { IA, diff --git a/src/Emulator/Core/CPU/OperandsEvaluation.cpp b/src/Emulator/Core/CPU/OperandsEvaluation.cpp index 06194aa3..602ef8b7 100644 --- a/src/Emulator/Core/CPU/OperandsEvaluation.cpp +++ b/src/Emulator/Core/CPU/OperandsEvaluation.cpp @@ -1,123 +1,164 @@ #include "pch.hpp" -#include -#include #include +#include #include - +#include HyperCPU::OperandContainer HyperCPU::CPU::GetRegister(OperandContainer& op1) { HyperCPU::Registers reg; memcpy(®, &op1, sizeof(HyperCPU::Registers)); switch (reg) { - case X0: return OperandContainer{x0}; - case X1: return OperandContainer{x1}; - case X2: return OperandContainer{x2}; - case X3: return OperandContainer{x3}; - case X4: return OperandContainer{x4}; - case X5: return OperandContainer{x5}; - case X6: return OperandContainer{x6}; - case X7: return OperandContainer{x7}; - - case XH0: return OperandContainer{xh0}; - case XH1: return OperandContainer{xh1}; - case XH2: return OperandContainer{xh2}; - case XH3: return OperandContainer{xh3}; - case XH4: return OperandContainer{xh4}; - case XH5: return OperandContainer{xh5}; - case XH6: return OperandContainer{xh6}; - case XH7: return OperandContainer{xh7}; - - case XL0: return OperandContainer{xl0}; - case XL1: return OperandContainer{xl1}; - case XL2: return OperandContainer{xl2}; - case XL3: return OperandContainer{xl3}; - case XL4: return OperandContainer{xl4}; - case XL5: return OperandContainer{xl5}; - case XL6: return OperandContainer{xl6}; - case XL7: return OperandContainer{xl7}; - - case XLL0: return OperandContainer{xll0}; - case XLL1: return OperandContainer{xll1}; - case XLL2: return OperandContainer{xll2}; - case XLL3: return OperandContainer{xll3}; - - case XLLH0: return OperandContainer{xllh0}; - case XLLH1: return OperandContainer{xllh1}; - case XLLH2: return OperandContainer{xllh2}; - case XLLH3: return OperandContainer{xllh3}; - - case XLLL0: return OperandContainer{xlll0}; - case XLLL1: return OperandContainer{xlll1}; - case XLLL2: return OperandContainer{xlll2}; - case XLLL3: return OperandContainer{xlll3}; - - case XBP: return OperandContainer{xbp}; - case XSP: return OperandContainer{xsp}; - case XIP: return OperandContainer{xip}; - case XGDP: return OperandContainer{xgdp}; - case XIVT: return OperandContainer{xivt}; - default: throw std::runtime_error("Invalid register"); + case X0: + return OperandContainer{x0}; + case X1: + return OperandContainer{x1}; + case X2: + return OperandContainer{x2}; + case X3: + return OperandContainer{x3}; + case X4: + return OperandContainer{x4}; + case X5: + return OperandContainer{x5}; + case X6: + return OperandContainer{x6}; + case X7: + return OperandContainer{x7}; + + case XH0: + return OperandContainer{xh0}; + case XH1: + return OperandContainer{xh1}; + case XH2: + return OperandContainer{xh2}; + case XH3: + return OperandContainer{xh3}; + case XH4: + return OperandContainer{xh4}; + case XH5: + return OperandContainer{xh5}; + case XH6: + return OperandContainer{xh6}; + case XH7: + return OperandContainer{xh7}; + + case XL0: + return OperandContainer{xl0}; + case XL1: + return OperandContainer{xl1}; + case XL2: + return OperandContainer{xl2}; + case XL3: + return OperandContainer{xl3}; + case XL4: + return OperandContainer{xl4}; + case XL5: + return OperandContainer{xl5}; + case XL6: + return OperandContainer{xl6}; + case XL7: + return OperandContainer{xl7}; + + case XLL0: + return OperandContainer{xll0}; + case XLL1: + return OperandContainer{xll1}; + case XLL2: + return OperandContainer{xll2}; + case XLL3: + return OperandContainer{xll3}; + + case XLLH0: + return OperandContainer{xllh0}; + case XLLH1: + return OperandContainer{xllh1}; + case XLLH2: + return OperandContainer{xllh2}; + case XLLH3: + return OperandContainer{xllh3}; + + case XLLL0: + return OperandContainer{xlll0}; + case XLLL1: + return OperandContainer{xlll1}; + case XLLL2: + return OperandContainer{xlll2}; + case XLLL3: + return OperandContainer{xlll3}; + + case XBP: + return OperandContainer{xbp}; + case XSP: + return OperandContainer{xsp}; + case XIP: + return OperandContainer{xip}; + case XGDP: + return OperandContainer{xgdp}; + case XIVT: + return OperandContainer{xivt}; + default: + throw std::runtime_error("Invalid register"); } } std::pair HyperCPU::CPU::GetOperands(OperandTypes op_types, Mode md, OperandContainer& op1, OperandContainer& op2) { switch (op_types) { - case R_R: - case R_RM: - case RM_R: { - OperandContainer op_1, op_2; - op_1 = GetRegister(op1); - op_2 = GetRegister(op2); - return std::make_pair(op_1, op_2); - } + case R_R: + case R_RM: + case RM_R: { + OperandContainer op_1, op_2; + op_1 = GetRegister(op1); + op_2 = GetRegister(op2); + return std::make_pair(op_1, op_2); + } - case RM_M: - case R_M: - return std::make_pair(GetRegister(op1), op2); - - case RM_IMM: - case R_IMM:{ - switch (md) { - case b8:{ - std::uint8_t imm8; - std::memcpy(&imm8, &op2, sizeof(std::uint8_t)); - return std::make_pair(GetRegister(op1), OperandContainer{HyperCPU::bit_cast(imm8)}); - } - case b16:{ - std::uint16_t imm16; - std::memcpy(&imm16, &op2, sizeof(std::uint16_t)); - return std::make_pair(GetRegister(op1), OperandContainer{HyperCPU::bit_cast(imm16)}); - } - case b32:{ - std::uint32_t imm32; - std::memcpy(&imm32, &op2, sizeof(std::uint32_t)); - return std::make_pair(GetRegister(op1), OperandContainer{HyperCPU::bit_cast(imm32)}); - } - case b64:{ - std::uint64_t imm64; - std::memcpy(&imm64, &op2, sizeof(std::uint64_t)); - return std::make_pair(GetRegister(op1), OperandContainer{HyperCPU::bit_cast(imm64)}); - } - } - break; + case RM_M: + case R_M: + return std::make_pair(GetRegister(op1), op2); + + case RM_IMM: + case R_IMM: { + switch (md) { + case b8: { + std::uint8_t imm8; + std::memcpy(&imm8, &op2, sizeof(std::uint8_t)); + return std::make_pair(GetRegister(op1), OperandContainer{HyperCPU::bit_cast(imm8)}); + } + case b16: { + std::uint16_t imm16; + std::memcpy(&imm16, &op2, sizeof(std::uint16_t)); + return std::make_pair(GetRegister(op1), OperandContainer{HyperCPU::bit_cast(imm16)}); + } + case b32: { + std::uint32_t imm32; + std::memcpy(&imm32, &op2, sizeof(std::uint32_t)); + return std::make_pair(GetRegister(op1), OperandContainer{HyperCPU::bit_cast(imm32)}); } + case b64: { + std::uint64_t imm64; + std::memcpy(&imm64, &op2, sizeof(std::uint64_t)); + return std::make_pair(GetRegister(op1), OperandContainer{HyperCPU::bit_cast(imm64)}); + } + } + break; + } - case M_R: - return std::make_pair(op1, GetRegister(op2)); + case M_R: + return std::make_pair(op1, GetRegister(op2)); - case R: - return std::make_pair(GetRegister(op1), nullptr); + case R: + return std::make_pair(GetRegister(op1), nullptr); - case IMM: - case M: - return std::make_pair(op1, nullptr); + case IMM: + case M: + return std::make_pair(op1, nullptr); - case NONE: - return std::make_pair(nullptr, nullptr); - default: - ABORT(); + case NONE: + return std::make_pair(nullptr, nullptr); + default: + ABORT(); } return {}; } diff --git a/src/Emulator/Core/CPU/Stack.cpp b/src/Emulator/Core/CPU/Stack.cpp index b0ad83a0..6c86ea4e 100644 --- a/src/Emulator/Core/CPU/Stack.cpp +++ b/src/Emulator/Core/CPU/Stack.cpp @@ -3,7 +3,6 @@ #include #include - void HyperCPU::CPU::StackPush8(std::uint8_t val) noexcept { h_assert(*xsp > 1, { std::cout << "Stack pointer too low!\n"; exit(1); }); diff --git a/src/Emulator/Core/MemoryController/IMemoryController.hpp b/src/Emulator/Core/MemoryController/IMemoryController.hpp index 9c16e8a7..a1b28a79 100644 --- a/src/Emulator/Core/MemoryController/IMemoryController.hpp +++ b/src/Emulator/Core/MemoryController/IMemoryController.hpp @@ -2,15 +2,15 @@ #include "pch.hpp" - -#define mem_ctlr_assert(expr) \ - do { \ +#define mem_ctlr_assert(expr) \ + do { \ if (!(expr) && (!cpu || !cpu->CanExecuteInterrupts())) [[unlikely]] { \ - HyperCPU::println("Assertion failed: {}", #expr); \ - ABORT(); \ - } else if (!(expr) && cpu && cpu->CanExecuteInterrupts()) { \ - cpu->TriggerInterrupt(HyperCPU::cpu_exceptions::SEGF); \ - } else [[likely]] { } \ + HyperCPU::println("Assertion failed: {}", #expr); \ + ABORT(); \ + } else if (!(expr) && cpu && cpu->CanExecuteInterrupts()) { \ + cpu->TriggerInterrupt(HyperCPU::cpu_exceptions::SEGF); \ + } else [[likely]] { \ + } \ } while (false) namespace HyperCPU { @@ -33,7 +33,7 @@ namespace HyperCPU { virtual std::uint8_t* get_ptr() const noexcept = 0; - virtual ~IMemoryController() { }; + virtual ~IMemoryController() {}; }; -} +} // namespace HyperCPU diff --git a/src/Emulator/Core/MemoryController/MemoryControllerST.hpp b/src/Emulator/Core/MemoryController/MemoryControllerST.hpp index 3e433038..ed375f0f 100644 --- a/src/Emulator/Core/MemoryController/MemoryControllerST.hpp +++ b/src/Emulator/Core/MemoryController/MemoryControllerST.hpp @@ -6,7 +6,6 @@ #include #include - namespace HyperCPU { class MemoryControllerST final : public IMemoryController { private: @@ -15,7 +14,8 @@ namespace HyperCPU { std::size_t total_mem; public: - explicit MemoryControllerST(std::size_t mem_size, class CPU* cpu = nullptr) : cpu(cpu), total_mem(mem_size) { + explicit MemoryControllerST(std::size_t mem_size, class CPU* cpu = nullptr) + : cpu(cpu), total_mem(mem_size) { memory = static_cast(calloc(total_mem, 1)); if (!memory) throw std::runtime_error("Failed to allocate memory!"); @@ -100,10 +100,12 @@ namespace HyperCPU { memcpy(&memory[ptr], &data, sizeof(std::uint64_t)); } - std::uint8_t* get_ptr() const noexcept override { return reinterpret_cast(memory); } + std::uint8_t* get_ptr() const noexcept override { + return reinterpret_cast(memory); + } ~MemoryControllerST() { free(memory); } }; -} +} // namespace HyperCPU diff --git a/src/Emulator/Main/ExceptionHandling.cpp b/src/Emulator/Main/ExceptionHandling.cpp deleted file mode 100644 index 0536df50..00000000 --- a/src/Emulator/Main/ExceptionHandling.cpp +++ /dev/null @@ -1,13 +0,0 @@ -#include "pch.hpp" - -#include
-#include - -#include -#include - - -[[noreturn]] void HyperCPU::ThrowError(CPU* cpu, std::string message) { - cpu->GetLogger().Log(HyperCPU::LogLevel::ERROR, message); - EXIT(1); -} diff --git a/src/Emulator/Main/ExceptionHandling.hpp b/src/Emulator/Main/ExceptionHandling.hpp deleted file mode 100644 index 80a61df1..00000000 --- a/src/Emulator/Main/ExceptionHandling.hpp +++ /dev/null @@ -1,10 +0,0 @@ -#pragma once - -#include "pch.hpp" - - -namespace HyperCPU { - class CPU; - - [[noreturn]] void ThrowError(CPU* cpu, std::string message); -} diff --git a/src/Emulator/Main/Main.cpp b/src/Emulator/Main/Main.cpp index cd4ddfc1..efdf12e1 100644 --- a/src/Emulator/Main/Main.cpp +++ b/src/Emulator/Main/Main.cpp @@ -3,9 +3,9 @@ #include #include #include +#include #include #include -#include #include @@ -25,14 +25,14 @@ int main(int argc, char** argv) { HyperCPU::Logger logger{HyperCPU::LogLevel::ERROR}; argparse::ArgumentParser program("hcemul", HCPU_VERSION); program.add_argument("binary") - .help("binary file to execute") - .required(); + .help("binary file to execute") + .required(); program.add_argument("-v") - .default_value(std::string{"debug"}) - .help("set verbosity level. possible modes:\n- debug\n- info\n- warning\n- error"); + .default_value(std::string{"debug"}) + .help("set verbosity level. possible modes:\n- debug\n- info\n- warning\n- error"); program.add_argument("-m", "--memory") - .default_value(std::string{"8K"}) - .help("max memory to use"); + .default_value(std::string{"8K"}) + .help("max memory to use"); try { program.parse_args(argc, argv); @@ -63,23 +63,23 @@ int main(int argc, char** argv) { } switch (header.version) { - case HyperCPU::Version::PreRelease: - case HyperCPU::Version::Release1_0: - break; - default: - logger.Log(HyperCPU::LogLevel::ERROR, "Invalid release field!"); - EXIT(1); + case HyperCPU::Version::PreRelease: + case HyperCPU::Version::Release1_0: + break; + default: + logger.Log(HyperCPU::LogLevel::ERROR, "Invalid release field!"); + EXIT(1); } switch (header.type) { - case HyperCPU::FileType::Binary: - break; - case HyperCPU::FileType::Object: - logger.Log(HyperCPU::LogLevel::ERROR, "Executing object files is not supported, please link it first!"); - EXIT(1); - default: - logger.Log(HyperCPU::LogLevel::ERROR, "Invalid type field!"); - EXIT(1); + case HyperCPU::FileType::Binary: + break; + case HyperCPU::FileType::Object: + logger.Log(HyperCPU::LogLevel::ERROR, "Executing object files is not supported, please link it first!"); + EXIT(1); + default: + logger.Log(HyperCPU::LogLevel::ERROR, "Invalid type field!"); + EXIT(1); } std::unique_ptr buf(new char[binarysize]); @@ -133,20 +133,20 @@ std::uint64_t HyperCPU::ParseMemoryString(const std::string& str) { std::uint64_t multiplier; switch (suffix) { - case 'K': - multiplier = 1024ULL; - break; - case 'M': - multiplier = 1024ULL * 1024; - break; - case 'G': - multiplier = 1024ULL * 1024 * 1024; - break; - case 'T': - multiplier = 1024ULL * 1024 * 1024 * 1024; - break; - default: - return std::numeric_limits::max(); + case 'K': + multiplier = 1024ULL; + break; + case 'M': + multiplier = 1024ULL * 1024; + break; + case 'G': + multiplier = 1024ULL * 1024 * 1024; + break; + case 'T': + multiplier = 1024ULL * 1024 * 1024 * 1024; + break; + default: + return std::numeric_limits::max(); } std::uint64_t result; diff --git a/src/Emulator/Misc/bit_cast.hpp b/src/Emulator/Misc/bit_cast.hpp index 42651749..27536acc 100644 --- a/src/Emulator/Misc/bit_cast.hpp +++ b/src/Emulator/Misc/bit_cast.hpp @@ -5,16 +5,15 @@ #include - namespace HyperCPU { - template + template constexpr To bit_cast(const From& src) noexcept { To dst; std::memcpy(&dst, &src, std::min(sizeof(To), sizeof(From))); return dst; } - template + template constexpr To bit_cast_s(const From& src) noexcept { static_assert(sizeof(To) == sizeof(From), "Type sizes should be the same"); To dst; @@ -22,10 +21,10 @@ namespace HyperCPU { return dst; } - template + template constexpr To bit_cast_from(const From* src) noexcept { To dst; std::memcpy(&dst, src, sizeof(To)); return dst; } -} +} // namespace HyperCPU diff --git a/src/Emulator/Misc/byteswap.hpp b/src/Emulator/Misc/byteswap.hpp index 9e58d3a2..c16370ef 100644 --- a/src/Emulator/Misc/byteswap.hpp +++ b/src/Emulator/Misc/byteswap.hpp @@ -5,10 +5,10 @@ #include namespace HyperCPU { - template + template constexpr T byteswap(T val) { auto repr = bit_cast_s>(val); std::ranges::reverse(repr); return bit_cast_s(repr); } -} +} // namespace HyperCPU diff --git a/src/Emulator/Misc/deref.hpp b/src/Emulator/Misc/deref.hpp index 6182de6a..8afb67e4 100644 --- a/src/Emulator/Misc/deref.hpp +++ b/src/Emulator/Misc/deref.hpp @@ -1,8 +1,8 @@ #pragma once namespace HyperCPU { - template + template constexpr T& deref(std::uint64_t ptr) { return *static_cast(ptr); } -} \ No newline at end of file +} // namespace HyperCPU \ No newline at end of file diff --git a/src/Emulator/Misc/overflow.hpp b/src/Emulator/Misc/overflow.hpp index bd2e8bce..0d329e6c 100644 --- a/src/Emulator/Misc/overflow.hpp +++ b/src/Emulator/Misc/overflow.hpp @@ -2,15 +2,14 @@ #include - namespace HyperCPU { template constexpr bool AdditionWillOverflow(T& a, T& b) { return (b > 0 && a > std::numeric_limits::max() - b); } - template + template constexpr bool multiplication_will_overflow(T& a, T& b) { return (a != 0 && (static_cast(a * b)) / a != b); } -} +} // namespace HyperCPU diff --git a/src/Emulator/Misc/print.hpp b/src/Emulator/Misc/print.hpp index 95ccf972..7bee3a90 100644 --- a/src/Emulator/Misc/print.hpp +++ b/src/Emulator/Misc/print.hpp @@ -1,16 +1,16 @@ #pragma once -#include #include +#include namespace HyperCPU { - template + template constexpr void print(std::string_view form, Args... args) { std::cout << fmt::vformat(form, fmt::make_format_args(args...)); } - template + template constexpr void println(std::string_view form, Args... args) { std::cout << fmt::vformat(form, fmt::make_format_args(args...)) << '\n'; } -} +} // namespace HyperCPU diff --git a/src/Emulator/Misc/underflow.hpp b/src/Emulator/Misc/underflow.hpp index 60060199..8a138b94 100644 --- a/src/Emulator/Misc/underflow.hpp +++ b/src/Emulator/Misc/underflow.hpp @@ -1,8 +1,8 @@ #pragma once namespace HyperCPU { - template + template constexpr bool SubtractionWillUnderflow(T& a, T& b) { return b > a; } -} \ No newline at end of file +} // namespace HyperCPU \ No newline at end of file diff --git a/src/Emulator/Misc/unreachable.hpp b/src/Emulator/Misc/unreachable.hpp index 8a63023e..04f878cf 100644 --- a/src/Emulator/Misc/unreachable.hpp +++ b/src/Emulator/Misc/unreachable.hpp @@ -4,4 +4,4 @@ namespace HyperCPU { [[noreturn, gnu::always_inline]] void inline unreachable() { __builtin_unreachable(); } -} +} // namespace HyperCPU diff --git a/src/Pog/Action.hpp b/src/Pog/Action.hpp index 9a82a089..7ca65a74 100644 --- a/src/Pog/Action.hpp +++ b/src/Pog/Action.hpp @@ -2,26 +2,24 @@ #include -#include "Pog/State.hpp" #include "Pog/Rule.hpp" +#include "Pog/State.hpp" namespace pog { -template -struct Shift -{ - const State* state; -}; + template + struct Shift { + const State* state; + }; -template -struct Reduce -{ - const Rule* rule; -}; + template + struct Reduce { + const Rule* rule; + }; -struct Accept {}; + struct Accept {}; -template -using Action = std::variant, Reduce, Accept>; + template + using Action = std::variant, Reduce, Accept>; } // namespace pog diff --git a/src/Pog/Automaton.hpp b/src/Pog/Automaton.hpp index ba76e51d..7fe8c9e1 100644 --- a/src/Pog/Automaton.hpp +++ b/src/Pog/Automaton.hpp @@ -6,154 +6,143 @@ #include -#include "Pog/Types/StateAndSymbol.hpp" #include "Pog/Grammar.hpp" #include "Pog/State.hpp" +#include "Pog/Types/StateAndSymbol.hpp" namespace pog { -template -class Automaton -{ -public: - using GrammarType = Grammar; - using ItemType = Item; - using StateType = State; - using SymbolType = Symbol; - - using StateAndSymbolType = StateAndSymbol; - - Automaton(const GrammarType* grammar) : _grammar(grammar), _states(), _state_to_index() {} - - const std::vector>& get_states() const { return _states; } - - const StateType* get_state(std::size_t index) const - { - assert(index < _states.size() && "Accessing state index out of bounds"); - return _states[index].get(); - } - - template - std::pair add_state(StateT&& state) - { - auto itr = _state_to_index.find(&state); - if (itr != _state_to_index.end()) - return {_states[itr->second].get(), false}; - - _states.push_back(std::make_unique(std::forward(state))); - _state_to_index.emplace(_states.back().get(), _states.size() - 1); - return {_states.back().get(), true}; - } - - void closure(StateType& state) - { - std::deque to_process; - for (const auto& item : state) - to_process.push_back(item.get()); - - while (!to_process.empty()) - { - const auto* current_item = to_process.front(); - to_process.pop_front(); - - const auto* next_symbol = current_item->get_read_symbol(); - auto rules = _grammar->get_rules_of_symbol(next_symbol); - for (const auto* rule : rules) - { - auto new_item = Item{rule}; - auto result = state.add_item(std::move(new_item)); - if (result.second) - to_process.push_back(result.first); - } - } - } - - void construct_states() - { - StateType initial_state; - initial_state.add_item(ItemType{_grammar->get_start_rule()}); - initial_state.set_index(0); - closure(initial_state); - auto result = add_state(std::move(initial_state)); - - std::deque to_process{result.first}; - while (!to_process.empty()) - { - auto* state = to_process.front(); - to_process.pop_front(); - - std::map> prepared_states; - for (const auto& item : *state) - { - if (item->is_final()) - continue; - - auto next_sym = item->get_read_symbol(); - if (next_sym->is_end()) - continue; - - auto new_item = Item{*item}; - new_item.step(); - - auto itr = prepared_states.find(next_sym); - if (itr == prepared_states.end()) - std::tie(itr, std::ignore) = prepared_states.emplace(next_sym, StateType{}); - itr->second.add_item(std::move(new_item)); - } - - for (auto&& [symbol, prepared_state] : prepared_states) - { - prepared_state.set_index(static_cast(_states.size())); - auto result = add_state(std::move(prepared_state)); - auto* target_state = result.first; - if (result.second) - { - // We calculate closure only if it's new state introduced in the automaton. - // States can be compared only with their kernel items so it's better to just do it - // once for each state. - closure(*target_state); - to_process.push_back(target_state); - } - state->add_transition(symbol, target_state); - target_state->add_back_transition(symbol, state); - } - } - } - - std::string generate_graph() const - { - std::vector states_str(_states.size()); - std::transform(_states.begin(), _states.end(), states_str.begin(), [](const auto& state) { - std::vector items_str(state->size()); - std::transform(state->begin(), state->end(), items_str.begin(), [](const auto& item) { - return item->to_string("→", "ε", "•"); - }); - return fmt::format("{} [label=\"{}\\l\", xlabel=\"{}\"]", state->get_index(), fmt::join(items_str.begin(), items_str.end(), "\\l"), state->get_index()); - }); - std::vector edges_str; - for (const auto& state : _states) - { - for (const auto& [sym, dest] : state->get_transitions()) - { - edges_str.push_back(fmt::format("{} -> {} [label=\"{}\"]", state->get_index(), dest->get_index(), sym->get_name())); - } - } - return fmt::format(R"(digraph Automaton {{ + template + class Automaton { + public: + using GrammarType = Grammar; + using ItemType = Item; + using StateType = State; + using SymbolType = Symbol; + + using StateAndSymbolType = StateAndSymbol; + + Automaton(const GrammarType* grammar) + : _grammar(grammar), _states(), _state_to_index() { + } + + const std::vector>& get_states() const { + return _states; + } + + const StateType* get_state(std::size_t index) const { + assert(index < _states.size() && "Accessing state index out of bounds"); + return _states[index].get(); + } + + template + std::pair add_state(StateT&& state) { + auto itr = _state_to_index.find(&state); + if (itr != _state_to_index.end()) + return {_states[itr->second].get(), false}; + + _states.push_back(std::make_unique(std::forward(state))); + _state_to_index.emplace(_states.back().get(), _states.size() - 1); + return {_states.back().get(), true}; + } + + void closure(StateType& state) { + std::deque to_process; + for (const auto& item : state) + to_process.push_back(item.get()); + + while (!to_process.empty()) { + const auto* current_item = to_process.front(); + to_process.pop_front(); + + const auto* next_symbol = current_item->get_read_symbol(); + auto rules = _grammar->get_rules_of_symbol(next_symbol); + for (const auto* rule : rules) { + auto new_item = Item{rule}; + auto result = state.add_item(std::move(new_item)); + if (result.second) + to_process.push_back(result.first); + } + } + } + + void construct_states() { + StateType initial_state; + initial_state.add_item(ItemType{_grammar->get_start_rule()}); + initial_state.set_index(0); + closure(initial_state); + auto result = add_state(std::move(initial_state)); + + std::deque to_process{result.first}; + while (!to_process.empty()) { + auto* state = to_process.front(); + to_process.pop_front(); + + std::map> prepared_states; + for (const auto& item : *state) { + if (item->is_final()) + continue; + + auto next_sym = item->get_read_symbol(); + if (next_sym->is_end()) + continue; + + auto new_item = Item{*item}; + new_item.step(); + + auto itr = prepared_states.find(next_sym); + if (itr == prepared_states.end()) + std::tie(itr, std::ignore) = prepared_states.emplace(next_sym, StateType{}); + itr->second.add_item(std::move(new_item)); + } + + for (auto&& [symbol, prepared_state] : prepared_states) { + prepared_state.set_index(static_cast(_states.size())); + auto result = add_state(std::move(prepared_state)); + auto* target_state = result.first; + if (result.second) { + // We calculate closure only if it's new state introduced in the automaton. + // States can be compared only with their kernel items so it's better to just do it + // once for each state. + closure(*target_state); + to_process.push_back(target_state); + } + state->add_transition(symbol, target_state); + target_state->add_back_transition(symbol, state); + } + } + } + + std::string generate_graph() const { + std::vector states_str(_states.size()); + std::transform(_states.begin(), _states.end(), states_str.begin(), [](const auto& state) { + std::vector items_str(state->size()); + std::transform(state->begin(), state->end(), items_str.begin(), [](const auto& item) { + return item->to_string("→", "ε", "•"); + }); + return fmt::format("{} [label=\"{}\\l\", xlabel=\"{}\"]", state->get_index(), fmt::join(items_str.begin(), items_str.end(), "\\l"), state->get_index()); + }); + std::vector edges_str; + for (const auto& state : _states) { + for (const auto& [sym, dest] : state->get_transitions()) { + edges_str.push_back(fmt::format("{} -> {} [label=\"{}\"]", state->get_index(), dest->get_index(), sym->get_name())); + } + } + return fmt::format(R"(digraph Automaton {{ node [shape=rect]; {} {} }})", - fmt::join(states_str.begin(), states_str.end(), "\n"), - fmt::join(edges_str.begin(), edges_str.end(), "\n") - ); - } - -private: - const GrammarType* _grammar; - std::vector> _states; - std::unordered_map, StateKernelEquals> _state_to_index; -}; + fmt::join(states_str.begin(), states_str.end(), "\n"), + fmt::join(edges_str.begin(), edges_str.end(), "\n")); + } + + private: + const GrammarType* _grammar; + std::vector> _states; + std::unordered_map, StateKernelEquals> _state_to_index; + }; } // namespace pog diff --git a/src/Pog/DigraphAlgo.hpp b/src/Pog/DigraphAlgo.hpp index 085ded10..c5e641d3 100644 --- a/src/Pog/DigraphAlgo.hpp +++ b/src/Pog/DigraphAlgo.hpp @@ -5,76 +5,72 @@ namespace pog { -namespace detail { + namespace detail { -template -void digraph_traverse(const NodeT& x, std::deque& stack, std::unordered_map& depths, const R& rel, BaseF& base_f, F& f) -{ - stack.push_back(x); // push x - std::size_t current_depth = stack.size(); // d <- depth of stack - depths.insert_or_assign(x, current_depth); // N[x] <- d - f.insert_or_assign(x, base_f[x]); // F(x) <- F'(x) + template + void digraph_traverse(const NodeT& x, std::deque& stack, std::unordered_map& depths, const R& rel, BaseF& base_f, F& f) { + stack.push_back(x); // push x + std::size_t current_depth = stack.size(); // d <- depth of stack + depths.insert_or_assign(x, current_depth); // N[x] <- d + f.insert_or_assign(x, base_f[x]); // F(x) <- F'(x) - auto rel_with = rel.find(x); - if (rel_with) - { - for (const auto& y : *rel_with) // for each y such that xRy - { - auto include_itr = depths.find(y); - if (include_itr == depths.end()) // if N[y] == 0 - digraph_traverse(y, stack, depths, rel, base_f, f); // recursive call Traverse(y) + auto rel_with = rel.find(x); + if (rel_with) { + for (const auto& y : *rel_with) // for each y such that xRy + { + auto include_itr = depths.find(y); + if (include_itr == depths.end()) // if N[y] == 0 + digraph_traverse(y, stack, depths, rel, base_f, f); // recursive call Traverse(y) - include_itr = depths.find(y); // possible iterator invalidation - include_itr->second = std::min(depths[x], include_itr->second); // N[y] <- min(N[x], N[y]) - auto& fx = f[x]; - auto& fy = f[y]; - std::copy(fy.begin(), fy.end(), std::inserter(fx, fx.begin())); // F(x) <- F(x) union F(y) - } - } + include_itr = depths.find(y); // possible iterator invalidation + include_itr->second = std::min(depths[x], include_itr->second); // N[y] <- min(N[x], N[y]) + auto& fx = f[x]; + auto& fy = f[y]; + std::copy(fy.begin(), fy.end(), std::inserter(fx, fx.begin())); // F(x) <- F(x) union F(y) + } + } - if (depths[x] == current_depth) // if N[x] == d - { - auto top_x = std::move(stack.back()); - stack.pop_back(); - depths[top_x] = std::numeric_limits::max(); // N(top of stack) <- Infinity - if (top_x != x) - f[top_x] = f[x]; // F(top of stack) <- F(x) + if (depths[x] == current_depth) // if N[x] == d + { + auto top_x = std::move(stack.back()); + stack.pop_back(); + depths[top_x] = std::numeric_limits::max(); // N(top of stack) <- Infinity + if (top_x != x) + f[top_x] = f[x]; // F(top of stack) <- F(x) - while (top_x != x) // while top of stack != x - { - top_x = std::move(stack.back()); - stack.pop_back(); - depths[top_x] = std::numeric_limits::max(); // N(top of stack) <- Infinity - if (top_x != x) - f[top_x] = f[x]; // F(top of stack) <- F(x) - } - } -} + while (top_x != x) // while top of stack != x + { + top_x = std::move(stack.back()); + stack.pop_back(); + depths[top_x] = std::numeric_limits::max(); // N(top of stack) <- Infinity + if (top_x != x) + f[top_x] = f[x]; // F(top of stack) <- F(x) + } + } + } -} // namespace detail + } // namespace detail -/** - * Digraph algorithm for finding SCCs (Strongly Connected Components). It is used for - * computation of function F(x) using base function F'(x) over directed graph. It first - * computes F'(x) as F(x) for each node x and then perform unions of F(x) over edges - * of directed graph. Finding SCC is a crucial part to not get into infinite loops and properly - * propagate F(x) in looped relations. - * - * You can specify custom relation R which specifies edges of the directed graph, base function - * F'(x) which needs to be already precomunted. The output is operation F(x) which will - * be computed along the way. - * - * TODO: base_f should not be non-const but we require operator[] right now - */ -template -void digraph_algo(const R& rel, BaseF& base_f, F& f) -{ - std::unordered_map depths; - std::deque stack; - for (const auto& x : rel) - { - detail::digraph_traverse(x.first, stack, depths, rel, base_f, f); - } -} + /** + * Digraph algorithm for finding SCCs (Strongly Connected Components). It is used for + * computation of function F(x) using base function F'(x) over directed graph. It first + * computes F'(x) as F(x) for each node x and then perform unions of F(x) over edges + * of directed graph. Finding SCC is a crucial part to not get into infinite loops and properly + * propagate F(x) in looped relations. + * + * You can specify custom relation R which specifies edges of the directed graph, base function + * F'(x) which needs to be already precomunted. The output is operation F(x) which will + * be computed along the way. + * + * TODO: base_f should not be non-const but we require operator[] right now + */ + template + void digraph_algo(const R& rel, BaseF& base_f, F& f) { + std::unordered_map depths; + std::deque stack; + for (const auto& x : rel) { + detail::digraph_traverse(x.first, stack, depths, rel, base_f, f); + } + } } // namespace pog diff --git a/src/Pog/Errors.hpp b/src/Pog/Errors.hpp index a0eb0b05..df7eead6 100644 --- a/src/Pog/Errors.hpp +++ b/src/Pog/Errors.hpp @@ -12,52 +12,57 @@ namespace pog { -class Error : public std::exception -{ -public: - Error() : _msg() {} - template - Error(T&& msg) noexcept : _msg(std::forward(msg)) {} - Error(const Error& o) noexcept : _msg(o._msg) {} - virtual ~Error() noexcept {} - - virtual const char* what() const noexcept override { return _msg.c_str(); } - -protected: - std::string _msg; -}; - -class SyntaxError : public Error -{ -public: - template - SyntaxError(const Symbol* unexpected_symbol, const std::vector*>& expected_symbols) : Error() - { - std::vector expected_symbols_str(expected_symbols.size()); - std::transform(expected_symbols.begin(), expected_symbols.end(), expected_symbols_str.begin(), [](const auto& sym) { - return sym->get_description(); - }); - - _msg = fmt::format( - "Syntax error: Unexpected {}, expected one of {}", - unexpected_symbol->get_description(), - fmt::join(expected_symbols_str.begin(), expected_symbols_str.end(), ", ") - ); - } - - template - SyntaxError(const std::vector*>& expected_symbols) : Error() - { - std::vector expected_symbols_str(expected_symbols.size()); - std::transform(expected_symbols.begin(), expected_symbols.end(), expected_symbols_str.begin(), [](const auto& sym) { - return sym->get_description(); - }); - - _msg = fmt::format( - "Syntax error: Unknown symbol on input, expected one of {}", - fmt::join(expected_symbols_str.begin(), expected_symbols_str.end(), ", ") - ); - } -}; + class Error : public std::exception { + public: + Error() + : _msg() { + } + template + Error(T&& msg) noexcept + : _msg(std::forward(msg)) { + } + Error(const Error& o) noexcept + : _msg(o._msg) { + } + virtual ~Error() noexcept { + } + + virtual const char* what() const noexcept override { + return _msg.c_str(); + } + + protected: + std::string _msg; + }; + + class SyntaxError : public Error { + public: + template + SyntaxError(const Symbol* unexpected_symbol, const std::vector*>& expected_symbols) + : Error() { + std::vector expected_symbols_str(expected_symbols.size()); + std::transform(expected_symbols.begin(), expected_symbols.end(), expected_symbols_str.begin(), [](const auto& sym) { + return sym->get_description(); + }); + + _msg = fmt::format( + "Syntax error: Unexpected {}, expected one of {}", + unexpected_symbol->get_description(), + fmt::join(expected_symbols_str.begin(), expected_symbols_str.end(), ", ")); + } + + template + SyntaxError(const std::vector*>& expected_symbols) + : Error() { + std::vector expected_symbols_str(expected_symbols.size()); + std::transform(expected_symbols.begin(), expected_symbols.end(), expected_symbols_str.begin(), [](const auto& sym) { + return sym->get_description(); + }); + + _msg = fmt::format( + "Syntax error: Unknown symbol on input, expected one of {}", + fmt::join(expected_symbols_str.begin(), expected_symbols_str.end(), ", ")); + } + }; } // namespace pog diff --git a/src/Pog/FilterView.hpp b/src/Pog/FilterView.hpp index d5b53d68..7823974c 100644 --- a/src/Pog/FilterView.hpp +++ b/src/Pog/FilterView.hpp @@ -5,76 +5,89 @@ #include template -class FilterView -{ +class FilterView { public: - using ValueType = typename std::iterator_traits::value_type; - - class iterator - { - public: - using difference_type = typename std::iterator_traits::difference_type; - using value_type = typename std::iterator_traits::value_type; - using reference = typename std::iterator_traits::reference; - using pointer = typename std::iterator_traits::pointer; - using iterator_category = std::forward_iterator_tag; - - iterator(const FilterView* parent) : _parent(parent), _itr(_parent->_begin) { _find_next(); } - iterator(const FilterView* parent, const It& itr) : _parent(parent), _itr(itr) {} - iterator(const iterator&) = default; - iterator(iterator&&) noexcept = default; - - iterator& operator=(const iterator&) = default; - iterator& operator=(iterator&&) noexcept = default; - - reference operator*() const { return *_itr; } - pointer operator->() const { return &*_itr; } - - iterator& operator++() - { - ++_itr; - _find_next(); - return *this; - } - - iterator operator++(int) - { - auto tmp = *this; - ++_itr; - _find_next(); - return tmp; - } - - bool operator==(const iterator& rhs) const { return _itr == rhs._itr; } - bool operator!=(const iterator& rhs) const { return !(*this == rhs); } - - private: - void _find_next() - { - while (_itr != _parent->_end && !_parent->_filter(*_itr)) - ++_itr; - } - - const FilterView* _parent; - It _itr; - }; - - template - FilterView(I&& begin, I&& end, F&& filter) - : _begin(std::forward(begin)), _end(std::forward(end)), _filter(std::forward(filter)) {} - - FilterView(const FilterView&) = default; - FilterView(FilterView&&) noexcept = default; - - FilterView& operator=(const FilterView&) = default; - FilterView& operator=(FilterView&&) noexcept = default; - - auto begin() const { return iterator{this}; } - auto end() const { return iterator{this, _end}; } + using ValueType = typename std::iterator_traits::value_type; + + class iterator { + public: + using difference_type = typename std::iterator_traits::difference_type; + using value_type = typename std::iterator_traits::value_type; + using reference = typename std::iterator_traits::reference; + using pointer = typename std::iterator_traits::pointer; + using iterator_category = std::forward_iterator_tag; + + iterator(const FilterView* parent) + : _parent(parent), _itr(_parent->_begin) { + _find_next(); + } + iterator(const FilterView* parent, const It& itr) + : _parent(parent), _itr(itr) { + } + iterator(const iterator&) = default; + iterator(iterator&&) noexcept = default; + + iterator& operator=(const iterator&) = default; + iterator& operator=(iterator&&) noexcept = default; + + reference operator*() const { + return *_itr; + } + pointer operator->() const { + return &*_itr; + } + + iterator& operator++() { + ++_itr; + _find_next(); + return *this; + } + + iterator operator++(int) { + auto tmp = *this; + ++_itr; + _find_next(); + return tmp; + } + + bool operator==(const iterator& rhs) const { + return _itr == rhs._itr; + } + bool operator!=(const iterator& rhs) const { + return !(*this == rhs); + } + + private: + void _find_next() { + while (_itr != _parent->_end && !_parent->_filter(*_itr)) + ++_itr; + } + + const FilterView* _parent; + It _itr; + }; + + template + FilterView(I&& begin, I&& end, F&& filter) + : _begin(std::forward(begin)), _end(std::forward(end)), _filter(std::forward(filter)) { + } + + FilterView(const FilterView&) = default; + FilterView(FilterView&&) noexcept = default; + + FilterView& operator=(const FilterView&) = default; + FilterView& operator=(FilterView&&) noexcept = default; + + auto begin() const { + return iterator{this}; + } + auto end() const { + return iterator{this, _end}; + } private: - It _begin, _end; - std::function _filter; + It _begin, _end; + std::function _filter; }; template diff --git a/src/Pog/Grammar.hpp b/src/Pog/Grammar.hpp index 767d9aec..af37d8a0 100644 --- a/src/Pog/Grammar.hpp +++ b/src/Pog/Grammar.hpp @@ -12,277 +12,239 @@ namespace pog { -template -class Grammar -{ -public: - using RuleType = Rule; - using SymbolType = Symbol; - using TokenType = Token; - - Grammar() : _rules(), _symbols(), _name_to_symbol(), _internal_start_symbol(nullptr), _internal_end_of_input(nullptr), - _start_rule(nullptr), _empty_table(), _first_table(), _follow_table() - { - _internal_start_symbol = add_symbol(SymbolKind::Nonterminal, "@start"); - _internal_end_of_input = add_symbol(SymbolKind::End, "@end"); - } - - const std::vector>& get_symbols() const { return _symbols; } - const std::vector>& get_rules() const { return _rules; } - - const SymbolType* get_end_of_input_symbol() const { return _internal_end_of_input; } - const RuleType* get_start_rule() const { return _start_rule; } - - std::vector get_terminal_symbols() const - { - std::vector result; - transform_if(_symbols.begin(), _symbols.end(), std::back_inserter(result), - [](const auto& s) { return s->is_terminal() || s->is_end(); }, - [](const auto& s) { return s.get(); } - ); - return result; - } - - std::vector get_nonterminal_symbols() const - { - std::vector result; - transform_if(_symbols.begin(), _symbols.end(), std::back_inserter(result), - [](const auto& s) { return s->is_nonterminal(); }, - [](const auto& s) { return s.get(); } - ); - return result; - } - - SymbolType* get_symbol(const std::string& name) const - { - auto itr = _name_to_symbol.find(name); - if (itr == _name_to_symbol.end()) - return nullptr; - - return itr->second; - } - - // TODO: return filter_view<> - std::vector get_rules_of_symbol(const SymbolType* sym) const - { - std::vector result; - transform_if(_rules.begin(), _rules.end(), std::back_inserter(result), [&](const auto& rule) { - return sym == rule->get_lhs(); - }, [](const auto& rule) { - return rule.get(); - }); - return result; - } - - // TODO: return filter_view<> - std::vector get_rules_with_symbol(const SymbolType* sym) const - { - std::vector result; - transform_if(_rules.begin(), _rules.end(), std::back_inserter(result), [&](const auto& rule) { - return std::find(rule->get_rhs().begin(), rule->get_rhs().end(), sym) != rule->get_rhs().end(); - }, [](const auto& rule) { - return rule.get(); - }); - return result; - } - - void set_start_symbol(const SymbolType* symbol) - { - auto start_rule = add_rule(_internal_start_symbol, std::vector{symbol, _internal_end_of_input}, [](Parser&, std::vector>&& args) { - return std::move(args[0].value); - }); - start_rule->set_start_rule(true); - _start_rule = start_rule; - } - - SymbolType* add_symbol(SymbolKind kind, const std::string& name) - { - if (auto itr = _name_to_symbol.find(name); itr != _name_to_symbol.end()) - return itr->second; - - _symbols.push_back(std::make_unique(static_cast(_symbols.size()), kind, name)); - _name_to_symbol.emplace(_symbols.back()->get_name(), _symbols.back().get()); - return _symbols.back().get(); - } - - template - RuleType* add_rule(const SymbolType* lhs, const std::vector& rhs, CallbackT&& action) - { - _rules.push_back(std::make_unique(static_cast(_rules.size()), lhs, rhs, std::forward(action))); - return _rules.back().get(); - } - - bool empty(const SymbolType* sym) const - { - std::unordered_set visited_lhss; - auto result = empty(sym, visited_lhss); - _empty_table[sym] = result; - return result; - } - - bool empty(const std::vector& seq) const - { - std::unordered_set visited_lhss; - auto result = empty(seq, visited_lhss); - return result; - } - - std::unordered_set first(const SymbolType* sym) const - { - std::unordered_set visited_lhss; - auto result = first(sym, visited_lhss); - _first_table[sym] = result; - return result; - } - - std::unordered_set first(const std::vector& seq) const - { - std::unordered_set visited_lhss; - auto result = first(seq, visited_lhss); - return result; - } - - std::unordered_set follow(const SymbolType* sym) - { - std::unordered_set visited; - auto result = follow(sym, visited); - _follow_table[sym] = result; - return result; - } - - bool empty(const SymbolType* sym, std::unordered_set& visited_lhss) const - { - if (auto itr = _empty_table.find(sym); itr != _empty_table.end()) - return itr->second; - - // Empty of terminal or end of input marker '$' remains the same - if (sym->is_terminal() || sym->is_end()) - return false; - - // In case of nonterminal A, there exist rules A -> ... and we need to inspect them all - auto rules = get_rules_of_symbol(sym); - for (const auto* rule : rules) - { - visited_lhss.insert(rule->get_lhs()); - if (empty(rule->get_rhs(), visited_lhss)) - return true; - } - - return false; - } - - bool empty(const std::vector& seq, std::unordered_set& visited_lhss) const - { - for (const auto* sym : seq) - { - if (auto itr = visited_lhss.find(sym); itr == visited_lhss.end()) - { - if (!empty(sym, visited_lhss)) - return false; - } - else - return false; - } - - return true; - } - - std::unordered_set first(const SymbolType* sym, std::unordered_set& visited_lhss) const - { - if (auto itr = _first_table.find(sym); itr != _first_table.end()) - return itr->second; - - if (sym->is_terminal() || sym->is_end()) - return {sym}; - else if (sym->is_nonterminal()) - { - std::unordered_set result; - - if (auto itr = visited_lhss.find(sym); itr == visited_lhss.end()) - { - visited_lhss.insert(sym); - auto rules = get_rules_of_symbol(sym); - for (const auto* rule : rules) - { - auto tmp = first(rule->get_rhs(), visited_lhss); - std::copy(tmp.begin(), tmp.end(), std::inserter(result, result.begin())); - } - } - - return result; - } - - return {}; - } - - std::unordered_set first(const std::vector& seq, std::unordered_set& visited_lhss) const - { - std::unordered_set result; - - for (const auto* sym : seq) - { - auto tmp = first(sym, visited_lhss); - std::copy(tmp.begin(), tmp.end(), std::inserter(result, result.begin())); - if (!empty(sym)) - break; - } - - return result; - } - - std::unordered_set follow(const SymbolType* sym, std::unordered_set& visited) const - { - if (auto itr = _follow_table.find(sym); itr != _follow_table.end()) - return itr->second; - - std::unordered_set result; - if (visited.find(sym) != visited.end()) - return result; - - visited.insert(sym); - auto rules = get_rules_with_symbol(sym); - for (const auto* rule : rules) - { - for (auto itr = rule->get_rhs().begin(), end = rule->get_rhs().end(); itr != end; ++itr) - { - if (*itr == sym) - { - bool can_be_last_in_production = true; - // If we have a production A -> a B b and we are doing Follow(B), we need to inspect everything - // right of B (so in this case 'b') whether there exist production b =>* eps. - // If so, B can be last in production and and therefore we need to add Follow(A) to Follow(B) - if (itr + 1 != end) - { - std::vector tail(itr + 1, end); - auto tmp = first(tail); - std::copy(tmp.begin(), tmp.end(), std::inserter(result, result.begin())); - can_be_last_in_production = empty(tail); - } - - // There exists production b =>* eps so add Follow(A) to Follow(B) - if (can_be_last_in_production) - { - auto tmp = follow(rule->get_lhs(), visited); - std::copy(tmp.begin(), tmp.end(), std::inserter(result, result.begin())); - } - } - } - } - - return result; - } - -private: - std::vector> _rules; - std::vector> _symbols; - std::unordered_map _name_to_symbol; - const SymbolType* _internal_start_symbol; - const SymbolType* _internal_end_of_input; - const RuleType* _start_rule; - - mutable std::unordered_map _empty_table; - mutable std::unordered_map> _first_table; - mutable std::unordered_map> _follow_table; -}; + template + class Grammar { + public: + using RuleType = Rule; + using SymbolType = Symbol; + using TokenType = Token; + + Grammar() + : _rules(), _symbols(), _name_to_symbol(), _internal_start_symbol(nullptr), _internal_end_of_input(nullptr), + _start_rule(nullptr), _empty_table(), _first_table(), _follow_table() { + _internal_start_symbol = add_symbol(SymbolKind::Nonterminal, "@start"); + _internal_end_of_input = add_symbol(SymbolKind::End, "@end"); + } + + const std::vector>& get_symbols() const { + return _symbols; + } + const std::vector>& get_rules() const { + return _rules; + } + + const SymbolType* get_end_of_input_symbol() const { + return _internal_end_of_input; + } + const RuleType* get_start_rule() const { + return _start_rule; + } + + std::vector get_terminal_symbols() const { + std::vector result; + transform_if(_symbols.begin(), _symbols.end(), std::back_inserter(result), [](const auto& s) { return s->is_terminal() || s->is_end(); }, [](const auto& s) { return s.get(); }); + return result; + } + + std::vector get_nonterminal_symbols() const { + std::vector result; + transform_if(_symbols.begin(), _symbols.end(), std::back_inserter(result), [](const auto& s) { return s->is_nonterminal(); }, [](const auto& s) { return s.get(); }); + return result; + } + + SymbolType* get_symbol(const std::string& name) const { + auto itr = _name_to_symbol.find(name); + if (itr == _name_to_symbol.end()) + return nullptr; + + return itr->second; + } + + // TODO: return filter_view<> + std::vector get_rules_of_symbol(const SymbolType* sym) const { + std::vector result; + transform_if(_rules.begin(), _rules.end(), std::back_inserter(result), [&](const auto& rule) { return sym == rule->get_lhs(); }, [](const auto& rule) { return rule.get(); }); + return result; + } + + // TODO: return filter_view<> + std::vector get_rules_with_symbol(const SymbolType* sym) const { + std::vector result; + transform_if(_rules.begin(), _rules.end(), std::back_inserter(result), [&](const auto& rule) { return std::find(rule->get_rhs().begin(), rule->get_rhs().end(), sym) != rule->get_rhs().end(); }, [](const auto& rule) { return rule.get(); }); + return result; + } + + void set_start_symbol(const SymbolType* symbol) { + auto start_rule = add_rule(_internal_start_symbol, std::vector{symbol, _internal_end_of_input}, [](Parser&, std::vector>&& args) { + return std::move(args[0].value); + }); + start_rule->set_start_rule(true); + _start_rule = start_rule; + } + + SymbolType* add_symbol(SymbolKind kind, const std::string& name) { + if (auto itr = _name_to_symbol.find(name); itr != _name_to_symbol.end()) + return itr->second; + + _symbols.push_back(std::make_unique(static_cast(_symbols.size()), kind, name)); + _name_to_symbol.emplace(_symbols.back()->get_name(), _symbols.back().get()); + return _symbols.back().get(); + } + + template + RuleType* add_rule(const SymbolType* lhs, const std::vector& rhs, CallbackT&& action) { + _rules.push_back(std::make_unique(static_cast(_rules.size()), lhs, rhs, std::forward(action))); + return _rules.back().get(); + } + + bool empty(const SymbolType* sym) const { + std::unordered_set visited_lhss; + auto result = empty(sym, visited_lhss); + _empty_table[sym] = result; + return result; + } + + bool empty(const std::vector& seq) const { + std::unordered_set visited_lhss; + auto result = empty(seq, visited_lhss); + return result; + } + + std::unordered_set first(const SymbolType* sym) const { + std::unordered_set visited_lhss; + auto result = first(sym, visited_lhss); + _first_table[sym] = result; + return result; + } + + std::unordered_set first(const std::vector& seq) const { + std::unordered_set visited_lhss; + auto result = first(seq, visited_lhss); + return result; + } + + std::unordered_set follow(const SymbolType* sym) { + std::unordered_set visited; + auto result = follow(sym, visited); + _follow_table[sym] = result; + return result; + } + + bool empty(const SymbolType* sym, std::unordered_set& visited_lhss) const { + if (auto itr = _empty_table.find(sym); itr != _empty_table.end()) + return itr->second; + + // Empty of terminal or end of input marker '$' remains the same + if (sym->is_terminal() || sym->is_end()) + return false; + + // In case of nonterminal A, there exist rules A -> ... and we need to inspect them all + auto rules = get_rules_of_symbol(sym); + for (const auto* rule : rules) { + visited_lhss.insert(rule->get_lhs()); + if (empty(rule->get_rhs(), visited_lhss)) + return true; + } + + return false; + } + + bool empty(const std::vector& seq, std::unordered_set& visited_lhss) const { + for (const auto* sym : seq) { + if (auto itr = visited_lhss.find(sym); itr == visited_lhss.end()) { + if (!empty(sym, visited_lhss)) + return false; + } else + return false; + } + + return true; + } + + std::unordered_set first(const SymbolType* sym, std::unordered_set& visited_lhss) const { + if (auto itr = _first_table.find(sym); itr != _first_table.end()) + return itr->second; + + if (sym->is_terminal() || sym->is_end()) + return {sym}; + else if (sym->is_nonterminal()) { + std::unordered_set result; + + if (auto itr = visited_lhss.find(sym); itr == visited_lhss.end()) { + visited_lhss.insert(sym); + auto rules = get_rules_of_symbol(sym); + for (const auto* rule : rules) { + auto tmp = first(rule->get_rhs(), visited_lhss); + std::copy(tmp.begin(), tmp.end(), std::inserter(result, result.begin())); + } + } + + return result; + } + + return {}; + } + + std::unordered_set first(const std::vector& seq, std::unordered_set& visited_lhss) const { + std::unordered_set result; + + for (const auto* sym : seq) { + auto tmp = first(sym, visited_lhss); + std::copy(tmp.begin(), tmp.end(), std::inserter(result, result.begin())); + if (!empty(sym)) + break; + } + + return result; + } + + std::unordered_set follow(const SymbolType* sym, std::unordered_set& visited) const { + if (auto itr = _follow_table.find(sym); itr != _follow_table.end()) + return itr->second; + + std::unordered_set result; + if (visited.find(sym) != visited.end()) + return result; + + visited.insert(sym); + auto rules = get_rules_with_symbol(sym); + for (const auto* rule : rules) { + for (auto itr = rule->get_rhs().begin(), end = rule->get_rhs().end(); itr != end; ++itr) { + if (*itr == sym) { + bool can_be_last_in_production = true; + // If we have a production A -> a B b and we are doing Follow(B), we need to inspect everything + // right of B (so in this case 'b') whether there exist production b =>* eps. + // If so, B can be last in production and and therefore we need to add Follow(A) to Follow(B) + if (itr + 1 != end) { + std::vector tail(itr + 1, end); + auto tmp = first(tail); + std::copy(tmp.begin(), tmp.end(), std::inserter(result, result.begin())); + can_be_last_in_production = empty(tail); + } + + // There exists production b =>* eps so add Follow(A) to Follow(B) + if (can_be_last_in_production) { + auto tmp = follow(rule->get_lhs(), visited); + std::copy(tmp.begin(), tmp.end(), std::inserter(result, result.begin())); + } + } + } + } + + return result; + } + + private: + std::vector> _rules; + std::vector> _symbols; + std::unordered_map _name_to_symbol; + const SymbolType* _internal_start_symbol; + const SymbolType* _internal_end_of_input; + const RuleType* _start_rule; + + mutable std::unordered_map _empty_table; + mutable std::unordered_map> _first_table; + mutable std::unordered_map> _follow_table; + }; } // namespace pog diff --git a/src/Pog/HTMLReport.hpp b/src/Pog/HTMLReport.hpp index 255952bf..2fe5d338 100644 --- a/src/Pog/HTMLReport.hpp +++ b/src/Pog/HTMLReport.hpp @@ -6,20 +6,20 @@ namespace pog { -template -class HtmlReport -{ -public: - using ParserType = Parser; + template + class HtmlReport { + public: + using ParserType = Parser; - using ShiftActionType = Shift; - using ReduceActionType = Reduce; + using ShiftActionType = Shift; + using ReduceActionType = Reduce; - HtmlReport(const ParserType& parser) : _parser(parser) {} + HtmlReport(const ParserType& parser) + : _parser(parser) { + } - void save(const std::string& file_path) - { - static const std::string html_page_template = R"( + void save(const std::string& file_path) { + static const std::string html_page_template = R"( @@ -72,38 +72,33 @@ var clipboard = new ClipboardJS('.btn'); )"; - using namespace fmt; - - std::ofstream file(file_path, std::ios::out | std::ios::trunc); - if (file.is_open()) - file << fmt::format(html_page_template, - "issues"_a = build_issues(), - "parsing_table"_a = build_parsing_table(), - "states"_a = build_states(), - "automaton"_a = generate_automaton_graph(), - "generated_at"_a = current_time("%Y-%m-%d %H:%M:%S %Z") - ); - file.close(); - } - -private: - std::string build_issues() - { - using namespace fmt; - - if (_parser._report) - return std::string{}; - - std::vector issues(_parser._report.number_of_issues()); - std::transform(_parser._report.begin(), _parser._report.end(), issues.begin(), [](const auto& issue) { - return fmt::format("
  • {}
    • ", visit_with(issue, - [&](const ShiftReduceConflict& sr) { return sr.to_string("→", "ε"); }, - [&](const ReduceReduceConflict& rr) { return rr.to_string("→", "ε"); } - )); - }); - - return fmt::format( - R"(
    + using namespace fmt; + + std::ofstream file(file_path, std::ios::out | std::ios::trunc); + if (file.is_open()) + file << fmt::format(html_page_template, + "issues"_a = build_issues(), + "parsing_table"_a = build_parsing_table(), + "states"_a = build_states(), + "automaton"_a = generate_automaton_graph(), + "generated_at"_a = current_time("%Y-%m-%d %H:%M:%S %Z")); + file.close(); + } + + private: + std::string build_issues() { + using namespace fmt; + + if (_parser._report) + return std::string{}; + + std::vector issues(_parser._report.number_of_issues()); + std::transform(_parser._report.begin(), _parser._report.end(), issues.begin(), [](const auto& issue) { + return fmt::format("
  • {}
    • ", visit_with(issue, [&](const ShiftReduceConflict& sr) { return sr.to_string("→", "ε"); }, [&](const ReduceReduceConflict& rr) { return rr.to_string("→", "ε"); })); + }); + + return fmt::format( + R"(

    Issues

      @@ -111,84 +106,65 @@ var clipboard = new ClipboardJS('.btn');
    )", - "issues"_a = fmt::join(issues.begin(), issues.end(), "") - ); - } - - std::string build_parsing_table() - { - using namespace fmt; - - auto terminal_symbols = _parser._grammar.get_terminal_symbols(); - auto nonterminal_symbols = _parser._grammar.get_nonterminal_symbols(); - - std::vector symbol_headers(terminal_symbols.size() + nonterminal_symbols.size()); - std::transform(terminal_symbols.begin(), terminal_symbols.end(), symbol_headers.begin(), [](const auto& s) { - return fmt::format("{}", s->get_name()); - }); - std::transform(nonterminal_symbols.begin(), nonterminal_symbols.end(), symbol_headers.begin() + terminal_symbols.size(), [](const auto& s) { - return fmt::format("{}", s->get_name()); - }); - - std::vector rows(_parser._automaton.get_states().size()); - for (const auto& state : _parser._automaton.get_states()) - { - std::vector row; - row.push_back(fmt::format( - "{}", - state->to_string("→", "ε", "•", "
    "), - state->get_index() - )); - for (const auto& sym : terminal_symbols) - { - auto action = _parser._parsing_table.get_action(state.get(), sym); - if (!action) - { - row.push_back(""); - continue; - } - - row.push_back(visit_with(action.value(), - [](const ShiftActionType& shift) { - return fmt::format( - "s{state_id}", - "state_str"_a = shift.state->to_string("→", "ε", "•", "
    "), - "state_id"_a = shift.state->get_index() - ); - }, - [](const ReduceActionType& reduce) { - return fmt::format( - "r{}", - reduce.rule->to_string("→", "ε"), - reduce.rule->get_index() - ); - }, - [](const Accept&) -> std::string { return ""; } - )); - } - - for (const auto& sym : nonterminal_symbols) - { - auto go_to = _parser._parsing_table.get_transition(state.get(), sym); - if (!go_to) - { - row.push_back(""); - continue; - } - - row.push_back(fmt::format( - "{state_id}", - "state_str"_a = go_to.value()->to_string("→", "ε", "•", "
    "), - "state_id"_a = go_to.value()->get_index() - )); - } - - row.push_back(""); - rows.push_back(fmt::format("{}", fmt::join(row.begin(), row.end(), ""))); - } - - return fmt::format( - R"(
    + "issues"_a = fmt::join(issues.begin(), issues.end(), "")); + } + + std::string build_parsing_table() { + using namespace fmt; + + auto terminal_symbols = _parser._grammar.get_terminal_symbols(); + auto nonterminal_symbols = _parser._grammar.get_nonterminal_symbols(); + + std::vector symbol_headers(terminal_symbols.size() + nonterminal_symbols.size()); + std::transform(terminal_symbols.begin(), terminal_symbols.end(), symbol_headers.begin(), [](const auto& s) { + return fmt::format("{}", s->get_name()); + }); + std::transform(nonterminal_symbols.begin(), nonterminal_symbols.end(), symbol_headers.begin() + terminal_symbols.size(), [](const auto& s) { + return fmt::format("{}", s->get_name()); + }); + + std::vector rows(_parser._automaton.get_states().size()); + for (const auto& state : _parser._automaton.get_states()) { + std::vector row; + row.push_back(fmt::format( + "{}", + state->to_string("→", "ε", "•", "
    "), + state->get_index())); + for (const auto& sym : terminal_symbols) { + auto action = _parser._parsing_table.get_action(state.get(), sym); + if (!action) { + row.push_back(""); + continue; + } + + row.push_back(visit_with(action.value(), [](const ShiftActionType& shift) { return fmt::format( + "s{state_id}", + "state_str"_a = shift.state->to_string("→", "ε", "•", "
    "), + "state_id"_a = shift.state->get_index()); }, [](const ReduceActionType& reduce) { return fmt::format( + "r{}", + reduce.rule->to_string("→", "ε"), + reduce.rule->get_index()); }, [](const Accept&) -> std::string { return ""; })); + } + + for (const auto& sym : nonterminal_symbols) { + auto go_to = _parser._parsing_table.get_transition(state.get(), sym); + if (!go_to) { + row.push_back(""); + continue; + } + + row.push_back(fmt::format( + "{state_id}", + "state_str"_a = go_to.value()->to_string("→", "ε", "•", "
    "), + "state_id"_a = go_to.value()->get_index())); + } + + row.push_back(""); + rows.push_back(fmt::format("{}", fmt::join(row.begin(), row.end(), ""))); + } + + return fmt::format( + R"(

    Parsing Table

    @@ -209,19 +185,17 @@ var clipboard = new ClipboardJS('.btn');
    )", - "number_of_terminals"_a = terminal_symbols.size(), - "number_of_nonterminals"_a = nonterminal_symbols.size(), - "symbols"_a = fmt::join(symbol_headers.begin(), symbol_headers.end(), ""), - "rows"_a = fmt::join(rows.begin(), rows.end(), "") - ); - } - - std::string build_states() - { - using namespace fmt; - - static const std::string single_state_template = - R"(
    + "number_of_terminals"_a = terminal_symbols.size(), + "number_of_nonterminals"_a = nonterminal_symbols.size(), + "symbols"_a = fmt::join(symbol_headers.begin(), symbol_headers.end(), ""), + "rows"_a = fmt::join(rows.begin(), rows.end(), "")); + } + + std::string build_states() { + using namespace fmt; + + static const std::string single_state_template = + R"(
    @@ -232,35 +206,31 @@ var clipboard = new ClipboardJS('.btn');
    State {id}
    )"; - std::vector states; - for (const auto& state : _parser._automaton.get_states()) - { - std::vector cols(state->size()); - std::transform(state->begin(), state->end(), cols.begin(), [](const auto& item) { - return fmt::format("{}", item->to_string("→", "ε", "•")); - }); - states.push_back(fmt::format( - single_state_template, - "id"_a = state->get_index(), - "rows"_a = fmt::join(cols.begin(), cols.end(), "") - )); - } - - return fmt::format( - R"(
    + std::vector states; + for (const auto& state : _parser._automaton.get_states()) { + std::vector cols(state->size()); + std::transform(state->begin(), state->end(), cols.begin(), [](const auto& item) { + return fmt::format("{}", item->to_string("→", "ε", "•")); + }); + states.push_back(fmt::format( + single_state_template, + "id"_a = state->get_index(), + "rows"_a = fmt::join(cols.begin(), cols.end(), ""))); + } + + return fmt::format( + R"(

    States

    {states}
    )", - "states"_a = fmt::join(states.begin(), states.end(), "") - ); - } + "states"_a = fmt::join(states.begin(), states.end(), "")); + } - std::string generate_automaton_graph() - { - using namespace fmt; + std::string generate_automaton_graph() { + using namespace fmt; - return fmt::format(R"(
    + return fmt::format(R"(

    Automaton (graphviz)

    @@ -271,14 +241,13 @@ var clipboard = new ClipboardJS('.btn');
    )", - "automaton"_a = _parser._automaton.generate_graph() - ); - } + "automaton"_a = _parser._automaton.generate_graph()); + } - const ParserType& _parser; -}; + const ParserType& _parser; + }; -template -HtmlReport(const Parser&) -> HtmlReport; + template + HtmlReport(const Parser&) -> HtmlReport; } // namespace pog diff --git a/src/Pog/Item.hpp b/src/Pog/Item.hpp index 7a29935a..771b0e58 100644 --- a/src/Pog/Item.hpp +++ b/src/Pog/Item.hpp @@ -8,130 +8,120 @@ namespace pog { -template -class Item -{ -public: - using RuleType = Rule; - using SymbolType = Symbol; - - Item(const RuleType* rule, std::size_t read_pos = 0) - : _rule(rule), _read_pos(read_pos) {} - Item(const Item&) = default; - Item(Item&&) noexcept = default; - - const RuleType* get_rule() const { return _rule; } - std::size_t get_read_pos() const { return _read_pos; } - - const SymbolType* get_previous_symbol() const - { - return _read_pos == 0 ? nullptr : _rule->get_rhs()[_read_pos - 1]; - } - - const SymbolType* get_read_symbol() const - { - return is_final() ? nullptr : _rule->get_rhs()[_read_pos]; - } - - std::vector get_left_side_without_read_symbol() - { - if (_read_pos == 0) - return {}; - - // TODO: return just iterator range - std::vector result(_read_pos); - std::copy(_rule->get_rhs().begin(), _rule->get_rhs().begin() + _read_pos, result.begin()); - return result; - } - - std::vector get_right_side_without_read_symbol() - { - if (is_final()) - { - assert(false && "Shouldn't call get_right_side_without_read_symbol() on final item"); - return {}; - } - - auto rest_size = _rule->get_rhs().size() - _read_pos - 1; - if (rest_size == 0) - return {}; - - // TODO: possibly just return iterator range? - std::vector result(rest_size); - std::copy(_rule->get_rhs().begin() + _read_pos + 1, _rule->get_rhs().end(), result.begin()); - return result; - } - - void step() - { - if (!is_final()) - _read_pos++; - } - - void step_back() - { - if (_read_pos > 0) - _read_pos--; - } - - bool is_kernel() const - { - return _read_pos > 0 || _rule->is_start_rule(); - } - - bool is_final() const - { - return _read_pos == _rule->get_rhs().size(); - } - - bool is_accepting() const - { - return !is_final() && get_read_symbol()->is_end(); - } - - std::string to_string(std::string_view arrow = "->", std::string_view eps = "", std::string_view sep = "<*>") const - { - const auto& rhs = _rule->get_rhs(); - std::vector left_of_read_pos(_read_pos); - std::vector right_of_read_pos(rhs.size() - _read_pos); - std::transform(rhs.begin(), rhs.begin() + _read_pos, left_of_read_pos.begin(), [](const auto* sym) { - return sym->get_name(); - }); - std::transform(rhs.begin() + _read_pos, rhs.end(), right_of_read_pos.begin(), [](const auto* sym) { - return sym->get_name(); - }); - - std::vector parts; - if (!left_of_read_pos.empty()) - parts.push_back(fmt::format("{}", fmt::join(left_of_read_pos.begin(), left_of_read_pos.end(), " "))); - parts.push_back(std::string{sep}); - if (!right_of_read_pos.empty()) - parts.push_back(fmt::format("{}", fmt::join(right_of_read_pos.begin(), right_of_read_pos.end(), " "))); - - if (parts.size() == 1) - parts.push_back(std::string{eps}); - - return fmt::format("{} {} {}", _rule->get_lhs()->get_name(), arrow, fmt::join(parts.begin(), parts.end(), " ")); - } - - bool operator==(const Item& rhs) const - { - return get_rule()->get_index() == rhs.get_rule()->get_index() && get_read_pos() == rhs.get_read_pos(); - } - - bool operator!=(const Item& rhs) const - { - return !(*this == rhs); - } - - bool operator<(const Item& rhs) const - { - return std::tuple{is_kernel() ? 0 : 1, _rule->get_index(), _read_pos} < std::tuple{rhs.is_kernel() ? 0 : 1, rhs._rule->get_index(), rhs._read_pos}; - } - -private: - const RuleType* _rule; - std::size_t _read_pos; -}; + template + class Item { + public: + using RuleType = Rule; + using SymbolType = Symbol; + + Item(const RuleType* rule, std::size_t read_pos = 0) + : _rule(rule), _read_pos(read_pos) { + } + Item(const Item&) = default; + Item(Item&&) noexcept = default; + + const RuleType* get_rule() const { + return _rule; + } + std::size_t get_read_pos() const { + return _read_pos; + } + + const SymbolType* get_previous_symbol() const { + return _read_pos == 0 ? nullptr : _rule->get_rhs()[_read_pos - 1]; + } + + const SymbolType* get_read_symbol() const { + return is_final() ? nullptr : _rule->get_rhs()[_read_pos]; + } + + std::vector get_left_side_without_read_symbol() { + if (_read_pos == 0) + return {}; + + // TODO: return just iterator range + std::vector result(_read_pos); + std::copy(_rule->get_rhs().begin(), _rule->get_rhs().begin() + _read_pos, result.begin()); + return result; + } + + std::vector get_right_side_without_read_symbol() { + if (is_final()) { + assert(false && "Shouldn't call get_right_side_without_read_symbol() on final item"); + return {}; + } + + auto rest_size = _rule->get_rhs().size() - _read_pos - 1; + if (rest_size == 0) + return {}; + + // TODO: possibly just return iterator range? + std::vector result(rest_size); + std::copy(_rule->get_rhs().begin() + _read_pos + 1, _rule->get_rhs().end(), result.begin()); + return result; + } + + void step() { + if (!is_final()) + _read_pos++; + } + + void step_back() { + if (_read_pos > 0) + _read_pos--; + } + + bool is_kernel() const { + return _read_pos > 0 || _rule->is_start_rule(); + } + + bool is_final() const { + return _read_pos == _rule->get_rhs().size(); + } + + bool is_accepting() const { + return !is_final() && get_read_symbol()->is_end(); + } + + std::string to_string(std::string_view arrow = "->", std::string_view eps = "", std::string_view sep = "<*>") const { + const auto& rhs = _rule->get_rhs(); + std::vector left_of_read_pos(_read_pos); + std::vector right_of_read_pos(rhs.size() - _read_pos); + std::transform(rhs.begin(), rhs.begin() + _read_pos, left_of_read_pos.begin(), [](const auto* sym) { + return sym->get_name(); + }); + std::transform(rhs.begin() + _read_pos, rhs.end(), right_of_read_pos.begin(), [](const auto* sym) { + return sym->get_name(); + }); + + std::vector parts; + if (!left_of_read_pos.empty()) + parts.push_back(fmt::format("{}", fmt::join(left_of_read_pos.begin(), left_of_read_pos.end(), " "))); + parts.push_back(std::string{sep}); + if (!right_of_read_pos.empty()) + parts.push_back(fmt::format("{}", fmt::join(right_of_read_pos.begin(), right_of_read_pos.end(), " "))); + + if (parts.size() == 1) + parts.push_back(std::string{eps}); + + return fmt::format("{} {} {}", _rule->get_lhs()->get_name(), arrow, fmt::join(parts.begin(), parts.end(), " ")); + } + + bool operator==(const Item& rhs) const { + return get_rule()->get_index() == rhs.get_rule()->get_index() && get_read_pos() == rhs.get_read_pos(); + } + + bool operator!=(const Item& rhs) const { + return !(*this == rhs); + } + + bool operator<(const Item& rhs) const { + return std::tuple{is_kernel() ? 0 : 1, _rule->get_index(), _read_pos} < std::tuple{rhs.is_kernel() ? 0 : 1, rhs._rule->get_index(), rhs._read_pos}; + } + + private: + const RuleType* _rule; + std::size_t _read_pos; + }; } // namespace pog diff --git a/src/Pog/LineSpecialization.hpp b/src/Pog/LineSpecialization.hpp index c8dcea80..3c665932 100644 --- a/src/Pog/LineSpecialization.hpp +++ b/src/Pog/LineSpecialization.hpp @@ -5,34 +5,34 @@ namespace HCAsm { -struct CompilerState; + struct CompilerState; } namespace pog { -struct LineSpecialization { - LineSpecialization(std::uint32_t line, std::uint16_t offset, std::uint16_t length) - : line(line) - , offset(offset) - , length(length) { } - LineSpecialization() - : line(1) - , offset(0) - , length(0) { } - - std::uint32_t line; - std::uint16_t offset; - std::uint16_t length; -}; - -template -struct TokenWithLineSpec { - TokenWithLineSpec() = default; - TokenWithLineSpec(ValueT& val, LineSpecialization spec) : value(val), line_spec(spec) { } - - ValueT value; - LineSpecialization line_spec; -}; - -} \ No newline at end of file + struct LineSpecialization { + LineSpecialization(std::uint32_t line, std::uint16_t offset, std::uint16_t length) + : line(line), offset(offset), length(length) { + } + LineSpecialization() + : line(1), offset(0), length(0) { + } + + std::uint32_t line; + std::uint16_t offset; + std::uint16_t length; + }; + + template + struct TokenWithLineSpec { + TokenWithLineSpec() = default; + TokenWithLineSpec(ValueT& val, LineSpecialization spec) + : value(val), line_spec(spec) { + } + + ValueT value; + LineSpecialization line_spec; + }; + +} // namespace pog \ No newline at end of file diff --git a/src/Pog/Operations/Follow.hpp b/src/Pog/Operations/Follow.hpp index f831b8a6..6dbed4d9 100644 --- a/src/Pog/Operations/Follow.hpp +++ b/src/Pog/Operations/Follow.hpp @@ -1,56 +1,55 @@ #pragma once -#include "Pog/Types/StateAndSymbol.hpp" +#include "Pog/DigraphAlgo.hpp" #include "Pog/Operations/Operation.hpp" -#include "Pog/Relations/Includes.hpp" #include "Pog/Operations/Read.hpp" -#include "Pog/DigraphAlgo.hpp" +#include "Pog/Relations/Includes.hpp" +#include "Pog/Types/StateAndSymbol.hpp" namespace pog { -/** - * Follow operations maps (q,x) where q is state and x is symbol to set of symbols. - * - * Formal definition for what Follow() represents is - * Follow(q, A) = Read(q, A) union (union { Follow(p, B) | (q, A) includes (p, B) }) - * So Follow(q, A) represents Read(q, A) with union of all Follow sets of (p, B) such that - * (q, A) is in include relation with (p, B). - * - * To put it simply by individual parts: - * 1. Read(q, A) means what symbols can directly follow A in state q. See Read() operation for - * more information. - * 2. Includes relation of (q, A) with (p, B) means that when we are about to read A in state q - * and everything after A can be empty string, meaning that what can follow B in state p can - * also follow A in state q. - * - * So Follow(q, A) represents what symbols can follow A while in state q. It is constructed from - * generated follow using Read(q, A) and propagated follow using include relation. - */ -template -class Follow : public Operation, const Symbol*> -{ -public: - using Parent = Operation, const Symbol*>; - - using AutomatonType = Automaton; - using GrammarType = Grammar; - - using StateAndSymbolType = StateAndSymbol; - - Follow(const AutomatonType* automaton, const GrammarType* grammar, const Includes& includes, Read& read_op) - : Parent(automaton, grammar), _includes(includes), _read_op(read_op) {} - Follow(const Follow&) = delete; - Follow(Follow&&) noexcept = default; - - virtual void calculate() override - { - // We use digraph algorithm which calculates Follow() for us. See digraph_algo() for more information. - digraph_algo(_includes, _read_op, Parent::_operation); - } - -private: - const Includes& _includes; - Read& _read_op; -}; + /** + * Follow operations maps (q,x) where q is state and x is symbol to set of symbols. + * + * Formal definition for what Follow() represents is + * Follow(q, A) = Read(q, A) union (union { Follow(p, B) | (q, A) includes (p, B) }) + * So Follow(q, A) represents Read(q, A) with union of all Follow sets of (p, B) such that + * (q, A) is in include relation with (p, B). + * + * To put it simply by individual parts: + * 1. Read(q, A) means what symbols can directly follow A in state q. See Read() operation for + * more information. + * 2. Includes relation of (q, A) with (p, B) means that when we are about to read A in state q + * and everything after A can be empty string, meaning that what can follow B in state p can + * also follow A in state q. + * + * So Follow(q, A) represents what symbols can follow A while in state q. It is constructed from + * generated follow using Read(q, A) and propagated follow using include relation. + */ + template + class Follow : public Operation, const Symbol*> { + public: + using Parent = Operation, const Symbol*>; + + using AutomatonType = Automaton; + using GrammarType = Grammar; + + using StateAndSymbolType = StateAndSymbol; + + Follow(const AutomatonType* automaton, const GrammarType* grammar, const Includes& includes, Read& read_op) + : Parent(automaton, grammar), _includes(includes), _read_op(read_op) { + } + Follow(const Follow&) = delete; + Follow(Follow&&) noexcept = default; + + virtual void calculate() override { + // We use digraph algorithm which calculates Follow() for us. See digraph_algo() for more information. + digraph_algo(_includes, _read_op, Parent::_operation); + } + + private: + const Includes& _includes; + Read& _read_op; + }; } // namespace pog diff --git a/src/Pog/Operations/Lookahead.hpp b/src/Pog/Operations/Lookahead.hpp index f2d0dbe8..15b768ed 100644 --- a/src/Pog/Operations/Lookahead.hpp +++ b/src/Pog/Operations/Lookahead.hpp @@ -1,75 +1,70 @@ #pragma once +#include "Pog/Operations/Follow.hpp" #include "Pog/Operations/Operation.hpp" -#include "Pog/Types/StateAndRule.hpp" #include "Pog/Relations/Lookback.hpp" -#include "Pog/Operations/Follow.hpp" +#include "Pog/Types/StateAndRule.hpp" namespace pog { -/** - * Lookahead operation maps (q, R), where q is state and R is rule from grammar, to set of symbols. - * - * Formal definition for Lookahead(q, A -> x) is - * Lookahead(q, A -> x) = union { Follow(p, B) | (q, A -> x) lookback (p, B) } - * So it's union of all Follow sets of state p and symbol B such that (q, A -> x) is in lookback - * relation with (p, B). - * - * To put it simply: - * 1. Follow set of (p, B) represents what symbols can follow symbol B when we are in the state B. - * 2. Lookback relation represents that in order to preform some reduction A -> x in state q, we first - * had to go through some other state p and use what follows A in B -> a A b to know when to perform - * reduction. - * So we'll take all rules A -> x and find in which state they can be reduced (there is an item A -> x <*>). - * We'll then union all Follow() sets according to lookback relation and for each state and rule, we now - * know what symbols need to follow in order to perform reductions by such rule in that particular state. - */ -template -class Lookahead : public Operation, const Symbol*> -{ -public: - using Parent = Operation, const Symbol*>; - - using AutomatonType = Automaton; - using GrammarType = Grammar; + /** + * Lookahead operation maps (q, R), where q is state and R is rule from grammar, to set of symbols. + * + * Formal definition for Lookahead(q, A -> x) is + * Lookahead(q, A -> x) = union { Follow(p, B) | (q, A -> x) lookback (p, B) } + * So it's union of all Follow sets of state p and symbol B such that (q, A -> x) is in lookback + * relation with (p, B). + * + * To put it simply: + * 1. Follow set of (p, B) represents what symbols can follow symbol B when we are in the state B. + * 2. Lookback relation represents that in order to preform some reduction A -> x in state q, we first + * had to go through some other state p and use what follows A in B -> a A b to know when to perform + * reduction. + * So we'll take all rules A -> x and find in which state they can be reduced (there is an item A -> x <*>). + * We'll then union all Follow() sets according to lookback relation and for each state and rule, we now + * know what symbols need to follow in order to perform reductions by such rule in that particular state. + */ + template + class Lookahead : public Operation, const Symbol*> { + public: + using Parent = Operation, const Symbol*>; - using StateAndRuleType = StateAndRule; + using AutomatonType = Automaton; + using GrammarType = Grammar; - // TODO: Follow<> should not be non-const but we need it for operator[] - Lookahead(const AutomatonType* automaton, const GrammarType* grammar, const Lookback& lookback, Follow& follow_op) - : Parent(automaton, grammar), _lookback(lookback), _follow_op(follow_op) {} - Lookahead(const Lookahead&) = delete; - Lookahead(Lookahead&&) noexcept = default; + using StateAndRuleType = StateAndRule; - virtual void calculate() override - { - // Iterate over all rules in grammar - for (const auto& rule : Parent::_grammar->get_rules()) - { - for (const auto& state : Parent::_automaton->get_states()) - { - // Find lookback of the current state and rule - auto sr = StateAndRuleType{state.get(), rule.get()}; - auto lookback_with = _lookback.find(sr); - if (!lookback_with) - continue; + // TODO: Follow<> should not be non-const but we need it for operator[] + Lookahead(const AutomatonType* automaton, const GrammarType* grammar, const Lookback& lookback, Follow& follow_op) + : Parent(automaton, grammar), _lookback(lookback), _follow_op(follow_op) { + } + Lookahead(const Lookahead&) = delete; + Lookahead(Lookahead&&) noexcept = default; - // Union all Follow() sets of the current state and rule to compute Lookahead() - for (const auto& ss : *lookback_with) - { - if (auto itr = Parent::_operation.find(sr); itr == Parent::_operation.end()) - Parent::_operation.emplace(std::move(sr), _follow_op[ss]); - else if (auto follow_res = _follow_op.find(ss); follow_res) - std::copy(follow_res->begin(), follow_res->end(), std::inserter(itr->second, itr->second.begin())); - } - } - } + virtual void calculate() override { + // Iterate over all rules in grammar + for (const auto& rule : Parent::_grammar->get_rules()) { + for (const auto& state : Parent::_automaton->get_states()) { + // Find lookback of the current state and rule + auto sr = StateAndRuleType{state.get(), rule.get()}; + auto lookback_with = _lookback.find(sr); + if (!lookback_with) + continue; - } + // Union all Follow() sets of the current state and rule to compute Lookahead() + for (const auto& ss : *lookback_with) { + if (auto itr = Parent::_operation.find(sr); itr == Parent::_operation.end()) + Parent::_operation.emplace(std::move(sr), _follow_op[ss]); + else if (auto follow_res = _follow_op.find(ss); follow_res) + std::copy(follow_res->begin(), follow_res->end(), std::inserter(itr->second, itr->second.begin())); + } + } + } + } -private: - const Lookback& _lookback; - Follow& _follow_op; -}; + private: + const Lookback& _lookback; + Follow& _follow_op; + }; } // namespace pog diff --git a/src/Pog/Operations/Operation.hpp b/src/Pog/Operations/Operation.hpp index beea5e21..4142ea6a 100644 --- a/src/Pog/Operations/Operation.hpp +++ b/src/Pog/Operations/Operation.hpp @@ -8,47 +8,50 @@ namespace pog { -template -class Operation -{ -public: - using AutomatonType = Automaton; - using GrammarType = Grammar; - - Operation(const AutomatonType* automaton, const GrammarType* grammar) : _automaton(automaton), _grammar(grammar) {} - Operation(const Operation&) = delete; - Operation(Operation&&) noexcept = default; - virtual ~Operation() = default; - - virtual void calculate() = 0; - - auto& operator[](const ArgT& key) { return _operation[key]; } - auto& operator[](ArgT& key) { return _operation[key]; } - - template - std::unordered_set* find(const T& key) - { - auto itr = _operation.find(key); - if (itr == _operation.end()) - return nullptr; - - return &itr->second; - } - - template - const std::unordered_set* find(const T& key) const - { - auto itr = _operation.find(key); - if (itr == _operation.end()) - return nullptr; - - return &itr->second; - } - -protected: - const AutomatonType* _automaton; - const GrammarType* _grammar; - std::unordered_map> _operation; -}; + template + class Operation { + public: + using AutomatonType = Automaton; + using GrammarType = Grammar; + + Operation(const AutomatonType* automaton, const GrammarType* grammar) + : _automaton(automaton), _grammar(grammar) { + } + Operation(const Operation&) = delete; + Operation(Operation&&) noexcept = default; + virtual ~Operation() = default; + + virtual void calculate() = 0; + + auto& operator[](const ArgT& key) { + return _operation[key]; + } + auto& operator[](ArgT& key) { + return _operation[key]; + } + + template + std::unordered_set* find(const T& key) { + auto itr = _operation.find(key); + if (itr == _operation.end()) + return nullptr; + + return &itr->second; + } + + template + const std::unordered_set* find(const T& key) const { + auto itr = _operation.find(key); + if (itr == _operation.end()) + return nullptr; + + return &itr->second; + } + + protected: + const AutomatonType* _automaton; + const GrammarType* _grammar; + std::unordered_map> _operation; + }; } // namespace pog diff --git a/src/Pog/Operations/Read.hpp b/src/Pog/Operations/Read.hpp index 13a14f7b..7aa4b94d 100644 --- a/src/Pog/Operations/Read.hpp +++ b/src/Pog/Operations/Read.hpp @@ -5,66 +5,63 @@ namespace pog { -/** - * Read operations maps (q,x) where q is state and x is symbol into set of symbols. - * - * Let's take state Q and non-final item A -> a <*> B b. Read(Q, B) represents set - * of symbols we can possibly read after reading B while in state Q. Originally, - * in all papers you see this proposed to be calculated using DirectRead() function - * and reads relation but in the end, it's the same as if we do First(b). First(b) - * incorporates situation if some symbol in sequence b can be reduced to empty string. - * - * So to put it shortly, for state Q and item A -> a <*> B b, Read(Q, B) = First(b). - */ -template -class Read : public Operation, const Symbol*> -{ -public: - using Parent = Operation, const Symbol*>; + /** + * Read operations maps (q,x) where q is state and x is symbol into set of symbols. + * + * Let's take state Q and non-final item A -> a <*> B b. Read(Q, B) represents set + * of symbols we can possibly read after reading B while in state Q. Originally, + * in all papers you see this proposed to be calculated using DirectRead() function + * and reads relation but in the end, it's the same as if we do First(b). First(b) + * incorporates situation if some symbol in sequence b can be reduced to empty string. + * + * So to put it shortly, for state Q and item A -> a <*> B b, Read(Q, B) = First(b). + */ + template + class Read : public Operation, const Symbol*> { + public: + using Parent = Operation, const Symbol*>; - using AutomatonType = Automaton; - using GrammarType = Grammar; - using SymbolType = Symbol; + using AutomatonType = Automaton; + using GrammarType = Grammar; + using SymbolType = Symbol; - using StateAndSymbolType = StateAndSymbol; + using StateAndSymbolType = StateAndSymbol; - Read(const AutomatonType* automaton, const GrammarType* grammar) : Parent(automaton, grammar) {} - Read(const Read&) = delete; - Read(Read&&) noexcept = default; + Read(const AutomatonType* automaton, const GrammarType* grammar) + : Parent(automaton, grammar) { + } + Read(const Read&) = delete; + Read(Read&&) noexcept = default; - virtual void calculate() override - { - // Iterate over all states of LR automaton - for (const auto& state : Parent::_automaton->get_states()) - { - for (const auto& item : *state.get()) - { - // We don't care about final items, only those in form A -> a <*> B b - if (item->is_final()) - continue; + virtual void calculate() override { + // Iterate over all states of LR automaton + for (const auto& state : Parent::_automaton->get_states()) { + for (const auto& item : *state.get()) { + // We don't care about final items, only those in form A -> a <*> B b + if (item->is_final()) + continue; - // Symbol right to <*> needs to be nonterminal - auto next_symbol = item->get_read_symbol(); - if (!next_symbol->is_nonterminal()) - continue; + // Symbol right to <*> needs to be nonterminal + auto next_symbol = item->get_read_symbol(); + if (!next_symbol->is_nonterminal()) + continue; - // Observe everything right of B, so in this case 'b' and calculate First() - auto right_rest = item->get_right_side_without_read_symbol(); - auto symbols = Parent::_grammar->first(right_rest); + // Observe everything right of B, so in this case 'b' and calculate First() + auto right_rest = item->get_right_side_without_read_symbol(); + auto symbols = Parent::_grammar->first(right_rest); - // Insert operation result - auto ss = StateAndSymbolType{state.get(), next_symbol}; - auto itr = Parent::_operation.find(ss); - if (itr == Parent::_operation.end()) - Parent::_operation.emplace(std::move(ss), std::move(symbols)); - else - { - // TODO: std::vector + std::set_union or std::unordered_set::extract - std::copy(symbols.begin(), symbols.end(), std::inserter(itr->second, itr->second.begin())); - } - } - } - } -}; + // Insert operation result + auto ss = StateAndSymbolType{state.get(), next_symbol}; + auto itr = Parent::_operation.find(ss); + if (itr == Parent::_operation.end()) + Parent::_operation.emplace(std::move(ss), std::move(symbols)); + else { + // TODO: std::vector + std::set_union or std::unordered_set::extract + std::copy(symbols.begin(), symbols.end(), std::inserter(itr->second, itr->second.begin())); + } + } + } + } + }; } // namespace pog diff --git a/src/Pog/Parser.hpp b/src/Pog/Parser.hpp index 9123ea15..f57ca2ce 100644 --- a/src/Pog/Parser.hpp +++ b/src/Pog/Parser.hpp @@ -1,7 +1,7 @@ #pragma once -#include #include +#include #include #include @@ -15,317 +15,283 @@ #define debug_parser(...) #endif +#include "Pog/Action.hpp" +#include "Pog/Automaton.hpp" +#include "Pog/Errors.hpp" +#include "Pog/Grammar.hpp" #include "Pog/LineSpecialization.hpp" #include "Pog/ParserReport.hpp" #include "Pog/ParsingTable.hpp" -#include "Pog/TokenBuilder.hpp" #include "Pog/RuleBuilder.hpp" -#include "Pog/Automaton.hpp" -#include "Pog/Tokenizer.hpp" -#include "Pog/Grammar.hpp" -#include "Pog/Action.hpp" -#include "Pog/Errors.hpp" -#include "Pog/Symbol.hpp" #include "Pog/State.hpp" +#include "Pog/Symbol.hpp" +#include "Pog/TokenBuilder.hpp" +#include "Pog/Tokenizer.hpp" -#include "Pog/Operations/Lookahead.hpp" #include "Pog/Operations/Follow.hpp" +#include "Pog/Operations/Lookahead.hpp" #include "Pog/Operations/Read.hpp" #include "Pog/Relations/Includes.hpp" #include "Pog/Relations/Lookback.hpp" namespace HCAsm { -class HCAsmCompiler; + class HCAsmCompiler; } namespace pog { -template -class HtmlReport; - -template -class Parser -{ -public: - friend class HtmlReport; - - using ActionType = Action; - using ShiftActionType = Shift; - using ReduceActionType = Reduce; - - using BacktrackingInfoType = BacktrackingInfo; - using ItemType = Item; - using ParserReportType = ParserReport; - using RuleBuilderType = RuleBuilder; - using RuleType = Rule; - using StateType = State; - using SymbolType = Symbol; - using StateAndRuleType = StateAndRule; - using StateAndSymbolType = StateAndSymbol; - using TokenBuilderType = TokenBuilder; - using TokenMatchType = TokenMatch; - using TokenType = Token; - using TokenizerType = Tokenizer; - - Parser() : _grammar(), _tokenizer(&_grammar), _automaton(&_grammar), _includes(&_automaton, &_grammar), - _lookback(&_automaton, &_grammar), _read_operation(&_automaton, &_grammar), _follow_operation(&_automaton, &_grammar, _includes, _read_operation), - _lookahead_operation(&_automaton, &_grammar, _lookback, _follow_operation), _parsing_table(&_automaton, &_grammar, _lookahead_operation) - { - static_assert(std::is_default_constructible_v, "Value type needs to be default constructible"); - } - - Parser(const Parser&) = delete; - Parser(Parser&&) noexcept = default; - - const ParserReportType& prepare() - { - for (auto& tb : _token_builders) - tb.done(); - for (auto& rb : _rule_builders) - rb.done(); - _automaton.construct_states(); - _includes.calculate(); - _lookback.calculate(); - _read_operation.calculate(); - _follow_operation.calculate(); - _lookahead_operation.calculate(); - _parsing_table.calculate(_report); - _tokenizer.prepare(); - return _report; - } - - TokenBuilderType& token(const std::string& pattern) - { - _token_builders.emplace_back(&_grammar, &_tokenizer, pattern); - return _token_builders.back(); - } - - TokenBuilderType& end_token() - { - _token_builders.emplace_back(&_grammar, &_tokenizer); - return _token_builders.back(); - } - - RuleBuilderType& rule(const std::string& lhs) - { - _rule_builders.emplace_back(&_grammar, lhs); - return _rule_builders.back(); - } - - void set_start_symbol(const std::string& name) - { - _grammar.set_start_symbol(_grammar.add_symbol(SymbolKind::Nonterminal, name)); - } - - void enter_tokenizer_state(const std::string& state_name) - { - _tokenizer.enter_state(state_name); - } - - void push_input_stream(std::string& input) - { - _tokenizer.push_input_stream(input); - } - - void pop_input_stream() - { - _tokenizer.pop_input_stream(); - } - - void global_tokenizer_action(typename TokenizerType::CallbackType&& global_action) - { - _tokenizer.global_action(std::move(global_action)); - } - - std::string& get_top_file() - { - return files.back(); - } - - void set_compiler_state(HCAsm::CompilerState* state) - { - _state = state; - } - - HCAsm::CompilerState* get_compiler_state() - { - return _state; - } - - void reset_line_offset() - { - _tokenizer._reset_line_offset(); - } - - std::uint32_t& get_line_counter() - { - return _tokenizer._get_line_counter(); - } - - std::uint16_t& get_line_offset() { - return _tokenizer._get_line_offset(); - } - - std::optional parse(std::string& contents) - { - files.push(contents); - - _tokenizer.enter_state(std::string{decltype(_tokenizer)::DefaultState}); - - std::optional token; - _tokenizer.clear_input_streams(); - _tokenizer.push_input_stream(contents); - - std::deque>>> stack; - stack.emplace_back(0, std::nullopt); - - while (!stack.empty()) - { - // Check if we remember token from the last iteration because we did reduction - // so the token was not "consumed" from the input. - if (!token) - { - token = _tokenizer.next_token(); - if (!token) [[unlikely]] - { - auto expected_symbols = _parsing_table.get_expected_symbols_from_state(_automaton.get_state(stack.back().first)); - throw SyntaxError(expected_symbols); - } - - debug_parser("Tokenizer returned new token with symbol \'{}\'", token.value().symbol->get_name()); - } - else { - debug_parser("Reusing old token with symbol \'{}\'", token.value().symbol->get_name()); - } - - debug_parser("Top of the stack is state {}", stack.back().first); - - const auto* next_symbol = token.value().symbol; - auto maybe_action = _parsing_table.get_action(_automaton.get_state(stack.back().first), next_symbol); - if (!maybe_action) - { - auto expected_symbols = _parsing_table.get_expected_symbols_from_state(_automaton.get_state(stack.back().first)); - throw SyntaxError(next_symbol, expected_symbols); - } - - // TODO: use visit - auto action = maybe_action.value(); - if (std::holds_alternative(action)) - { - const auto& reduce = std::get(action); - debug_parser("Reducing by rule \'{}\'", reduce.rule->to_string()); - - // Each symbol on right-hand side of the rule should have record on the stack - // We'll pop them out and put them in reverse order so user have them available - // left-to-right and not right-to-left. - std::vector> action_arg; - action_arg.reserve(reduce.rule->get_number_of_required_arguments_for_action()); - assert(stack.size() >= action_arg.capacity() && "Stack is too small"); - - for (std::size_t i = 0; i < action_arg.capacity(); ++i) - { - // Notice how std::move() is only around optional itself and not the whole expressions - // We need to do this in order to perform move together with value_or() - // See: https://en.cppreference.com/w/cpp/utility/optional/value_or - // std::move(*this) is performed only when value_or() is called from r-value - // - // Also do not pop from stack here because midrule actions can still return us arguments back - action_arg.insert(action_arg.begin(), std::move(stack[stack.size() - i - 1].second).value_or(TokenWithLineSpec{})); - } - - // What left on the stack now determines what state we get into now - // We use size of RHS to determine stack top because midrule actions might have only borrowed something from stack so the - // real stack top is not the actual top. Midrule actions have 0 RHS size even though they borrow items. Other rules - // have same size of RHS and what they take out of stack. - auto maybe_next_state = _parsing_table.get_transition(_automaton.get_state(stack[stack.size() - reduce.rule->get_rhs().size() - 1].first), reduce.rule->get_lhs()); - if (!maybe_next_state) - { - assert(false && "Reduction happened but corresponding GOTO table record is empty"); - return std::nullopt; - } - - auto action_result = reduce.rule->has_action() ? reduce.rule->perform_action(*this, std::move(action_arg)) : ValueT{}; - // Midrule actions only borrowed arguments and it is returning them back - if (reduce.rule->is_midrule()) - { - for (std::size_t i = 0; i < action_arg.size(); ++i) - stack[stack.size() - i - 1].second = std::move(action_arg[action_arg.size() - i - 1]); - } - // Non-midrule actions actually consumed those arguments so pop them out - else - { - for (std::size_t i = 0; i < action_arg.size(); ++i) - stack.pop_back(); - } - - debug_parser("Pushing state {}", maybe_next_state.value()->get_index()); - - stack.emplace_back( - maybe_next_state.value()->get_index(), - std::optional { TokenWithLineSpec { action_result, {} } } - ); - } - else if (std::holds_alternative(action)) - { - const auto& shift = std::get(action); - debug_parser("Shifting state {}", shift.state->get_index()); - - // Notice how std::move() is only around optional itself and not the whole expressions - // We need to do this in order to perform move together with value() - // See: https://en.cppreference.com/w/cpp/utility/optional/value - // Return by rvalue is performed only when value() is called from r-value - stack.emplace_back( - shift.state->get_index(), - std::optional { TokenWithLineSpec { token.value().value, token.value().line_spec } } - ); - - // We did shift so the token value is moved onto stack, "forget" the token - token.reset(); - } - else if (std::holds_alternative(action)) - { - debug_parser("Accept"); - // Notice how std::move() is only around optional itself and not the whole expressions - // We need to do this in order to perform move together with value() - // See: https://en.cppreference.com/w/cpp/utility/optional/value - // Return by rvalue is performed only when value() is called from r-value - return { std::move(stack.back().second).value().value }; - } - } - - assert(false && "Stack was emptied too early"); - return std::nullopt; - } - - std::string generate_automaton_graph() - { - return _automaton.generate_graph(); - } - - std::string generate_includes_relation_graph() - { - return _includes.generate_relation_graph(); - } - -private: - Grammar _grammar; - Tokenizer _tokenizer; - Automaton _automaton; - Includes _includes; - Lookback _lookback; - Read _read_operation; - Follow _follow_operation; - Lookahead _lookahead_operation; - ParsingTable _parsing_table; - - std::vector _rule_builders; - std::vector _token_builders; - - ParserReportType _report; - HCAsm::CompilerState* _state; - std::queue files; -}; + template + class HtmlReport; + + template + class Parser { + public: + friend class HtmlReport; + + using ActionType = Action; + using ShiftActionType = Shift; + using ReduceActionType = Reduce; + + using BacktrackingInfoType = BacktrackingInfo; + using ItemType = Item; + using ParserReportType = ParserReport; + using RuleBuilderType = RuleBuilder; + using RuleType = Rule; + using StateType = State; + using SymbolType = Symbol; + using StateAndRuleType = StateAndRule; + using StateAndSymbolType = StateAndSymbol; + using TokenBuilderType = TokenBuilder; + using TokenMatchType = TokenMatch; + using TokenType = Token; + using TokenizerType = Tokenizer; + + Parser() + : _grammar(), _tokenizer(&_grammar), _automaton(&_grammar), _includes(&_automaton, &_grammar), + _lookback(&_automaton, &_grammar), _read_operation(&_automaton, &_grammar), _follow_operation(&_automaton, &_grammar, _includes, _read_operation), + _lookahead_operation(&_automaton, &_grammar, _lookback, _follow_operation), _parsing_table(&_automaton, &_grammar, _lookahead_operation) { + static_assert(std::is_default_constructible_v, "Value type needs to be default constructible"); + } + + Parser(const Parser&) = delete; + Parser(Parser&&) noexcept = default; + + const ParserReportType& prepare() { + for (auto& tb : _token_builders) + tb.done(); + for (auto& rb : _rule_builders) + rb.done(); + _automaton.construct_states(); + _includes.calculate(); + _lookback.calculate(); + _read_operation.calculate(); + _follow_operation.calculate(); + _lookahead_operation.calculate(); + _parsing_table.calculate(_report); + _tokenizer.prepare(); + return _report; + } + + TokenBuilderType& token(const std::string& pattern) { + _token_builders.emplace_back(&_grammar, &_tokenizer, pattern); + return _token_builders.back(); + } + + TokenBuilderType& end_token() { + _token_builders.emplace_back(&_grammar, &_tokenizer); + return _token_builders.back(); + } + + RuleBuilderType& rule(const std::string& lhs) { + _rule_builders.emplace_back(&_grammar, lhs); + return _rule_builders.back(); + } + + void set_start_symbol(const std::string& name) { + _grammar.set_start_symbol(_grammar.add_symbol(SymbolKind::Nonterminal, name)); + } + + void enter_tokenizer_state(const std::string& state_name) { + _tokenizer.enter_state(state_name); + } + + void push_input_stream(std::string& input) { + _tokenizer.push_input_stream(input); + } + + void pop_input_stream() { + _tokenizer.pop_input_stream(); + } + + void global_tokenizer_action(typename TokenizerType::CallbackType&& global_action) { + _tokenizer.global_action(std::move(global_action)); + } + + std::string& get_top_file() { + return files.back(); + } + + void set_compiler_state(HCAsm::CompilerState* state) { + _state = state; + } + + HCAsm::CompilerState* get_compiler_state() { + return _state; + } + + void reset_line_offset() { + _tokenizer._reset_line_offset(); + } + + std::uint32_t& get_line_counter() { + return _tokenizer._get_line_counter(); + } + + std::uint16_t& get_line_offset() { + return _tokenizer._get_line_offset(); + } + + std::optional parse(std::string& contents) { + files.push(contents); + + _tokenizer.enter_state(std::string{decltype(_tokenizer)::DefaultState}); + + std::optional token; + _tokenizer.clear_input_streams(); + _tokenizer.push_input_stream(contents); + + std::deque>>> stack; + stack.emplace_back(0, std::nullopt); + + while (!stack.empty()) { + // Check if we remember token from the last iteration because we did reduction + // so the token was not "consumed" from the input. + if (!token) { + token = _tokenizer.next_token(); + if (!token) [[unlikely]] { + auto expected_symbols = _parsing_table.get_expected_symbols_from_state(_automaton.get_state(stack.back().first)); + throw SyntaxError(expected_symbols); + } + + debug_parser("Tokenizer returned new token with symbol \'{}\'", token.value().symbol->get_name()); + } else { + debug_parser("Reusing old token with symbol \'{}\'", token.value().symbol->get_name()); + } + + debug_parser("Top of the stack is state {}", stack.back().first); + + const auto* next_symbol = token.value().symbol; + auto maybe_action = _parsing_table.get_action(_automaton.get_state(stack.back().first), next_symbol); + if (!maybe_action) { + auto expected_symbols = _parsing_table.get_expected_symbols_from_state(_automaton.get_state(stack.back().first)); + throw SyntaxError(next_symbol, expected_symbols); + } + + // TODO: use visit + auto action = maybe_action.value(); + if (std::holds_alternative(action)) { + const auto& reduce = std::get(action); + debug_parser("Reducing by rule \'{}\'", reduce.rule->to_string()); + + // Each symbol on right-hand side of the rule should have record on the stack + // We'll pop them out and put them in reverse order so user have them available + // left-to-right and not right-to-left. + std::vector> action_arg; + action_arg.reserve(reduce.rule->get_number_of_required_arguments_for_action()); + assert(stack.size() >= action_arg.capacity() && "Stack is too small"); + + for (std::size_t i = 0; i < action_arg.capacity(); ++i) { + // Notice how std::move() is only around optional itself and not the whole expressions + // We need to do this in order to perform move together with value_or() + // See: https://en.cppreference.com/w/cpp/utility/optional/value_or + // std::move(*this) is performed only when value_or() is called from r-value + // + // Also do not pop from stack here because midrule actions can still return us arguments back + action_arg.insert(action_arg.begin(), std::move(stack[stack.size() - i - 1].second).value_or(TokenWithLineSpec{})); + } + + // What left on the stack now determines what state we get into now + // We use size of RHS to determine stack top because midrule actions might have only borrowed something from stack so the + // real stack top is not the actual top. Midrule actions have 0 RHS size even though they borrow items. Other rules + // have same size of RHS and what they take out of stack. + auto maybe_next_state = _parsing_table.get_transition(_automaton.get_state(stack[stack.size() - reduce.rule->get_rhs().size() - 1].first), reduce.rule->get_lhs()); + if (!maybe_next_state) { + assert(false && "Reduction happened but corresponding GOTO table record is empty"); + return std::nullopt; + } + + auto action_result = reduce.rule->has_action() ? reduce.rule->perform_action(*this, std::move(action_arg)) : ValueT{}; + // Midrule actions only borrowed arguments and it is returning them back + if (reduce.rule->is_midrule()) { + for (std::size_t i = 0; i < action_arg.size(); ++i) + stack[stack.size() - i - 1].second = std::move(action_arg[action_arg.size() - i - 1]); + } + // Non-midrule actions actually consumed those arguments so pop them out + else { + for (std::size_t i = 0; i < action_arg.size(); ++i) + stack.pop_back(); + } + + debug_parser("Pushing state {}", maybe_next_state.value()->get_index()); + + stack.emplace_back( + maybe_next_state.value()->get_index(), + std::optional{TokenWithLineSpec{action_result, {}}}); + } else if (std::holds_alternative(action)) { + const auto& shift = std::get(action); + debug_parser("Shifting state {}", shift.state->get_index()); + + // Notice how std::move() is only around optional itself and not the whole expressions + // We need to do this in order to perform move together with value() + // See: https://en.cppreference.com/w/cpp/utility/optional/value + // Return by rvalue is performed only when value() is called from r-value + stack.emplace_back( + shift.state->get_index(), + std::optional{TokenWithLineSpec{token.value().value, token.value().line_spec}}); + + // We did shift so the token value is moved onto stack, "forget" the token + token.reset(); + } else if (std::holds_alternative(action)) { + debug_parser("Accept"); + // Notice how std::move() is only around optional itself and not the whole expressions + // We need to do this in order to perform move together with value() + // See: https://en.cppreference.com/w/cpp/utility/optional/value + // Return by rvalue is performed only when value() is called from r-value + return {std::move(stack.back().second).value().value}; + } + } + + assert(false && "Stack was emptied too early"); + return std::nullopt; + } + + std::string generate_automaton_graph() { + return _automaton.generate_graph(); + } + + std::string generate_includes_relation_graph() { + return _includes.generate_relation_graph(); + } + + private: + Grammar _grammar; + Tokenizer _tokenizer; + Automaton _automaton; + Includes _includes; + Lookback _lookback; + Read _read_operation; + Follow _follow_operation; + Lookahead _lookahead_operation; + ParsingTable _parsing_table; + + std::vector _rule_builders; + std::vector _token_builders; + + ParserReportType _report; + HCAsm::CompilerState* _state; + std::queue files; + }; } // namespace pog diff --git a/src/Pog/ParserReport.hpp b/src/Pog/ParserReport.hpp index 821854a7..f9602c37 100644 --- a/src/Pog/ParserReport.hpp +++ b/src/Pog/ParserReport.hpp @@ -5,85 +5,88 @@ #include -#include "Pog/State.hpp" #include "Pog/Rule.hpp" +#include "Pog/State.hpp" namespace pog { -template -struct ShiftReduceConflict -{ - const State* state; - const Symbol* symbol; - const Rule* rule; - - std::string to_string(std::string_view arrow = "->", std::string_view eps = "") const - { - return fmt::format("Shift-reduce conflict of symbol \'{}\' and rule \'{}\' in state {}", symbol->get_name(), rule->to_string(arrow, eps), state->get_index()); - } -}; - -template -struct ReduceReduceConflict -{ - const State* state; - const Rule* rule1; - const Rule* rule2; - - std::string to_string(std::string_view arrow = "->", std::string_view eps = "") const - { - return fmt::format("Reduce-reduce conflict of rule \'{}\' and rule \'{}\' in state {}", rule1->to_string(arrow, eps), rule2->to_string(arrow, eps), state->get_index()); - } -}; - -template -using Issue = std::variant, ReduceReduceConflict>; - -template -class ParserReport -{ -public: - using IssueType = Issue; - using RuleType = Rule; - using StateType = State; - using SymbolType = Symbol; - - using ReduceReduceConflictType = ReduceReduceConflict; - using ShiftReduceConflictType = ShiftReduceConflict; - - bool ok() const { return _issues.empty(); } - operator bool() const { return ok(); } - - std::size_t number_of_issues() const { return _issues.size(); } - auto begin() { return _issues.begin(); } - auto end() { return _issues.end(); } - auto begin() const { return _issues.begin(); } - auto end() const { return _issues.end(); } - - void add_shift_reduce_conflict(const StateType* state, const SymbolType* symbol, const RuleType* rule) - { - _issues.push_back(ShiftReduceConflictType{state, symbol, rule}); - } - - void add_reduce_reduce_conflict(const StateType* state, const RuleType* rule1, const RuleType* rule2) - { - _issues.push_back(ReduceReduceConflictType{state, rule1, rule2}); - } - - std::string to_string(std::string_view arrow = "->", std::string_view eps = "") const - { - std::vector issues_str(_issues.size()); - std::transform(_issues.begin(), _issues.end(), issues_str.begin(), [&](const auto& issue) { - return visit_with(issue, - [&](const ShiftReduceConflictType& sr) { return sr.to_string(arrow, eps); }, - [&](const ReduceReduceConflictType& rr) { return rr.to_string(arrow, eps); } - ); - }); - return fmt::format("{}", fmt::join(issues_str.begin(), issues_str.end(), "\n")); - } - -private: - std::vector _issues; -}; + template + struct ShiftReduceConflict { + const State* state; + const Symbol* symbol; + const Rule* rule; + + std::string to_string(std::string_view arrow = "->", std::string_view eps = "") const { + return fmt::format("Shift-reduce conflict of symbol \'{}\' and rule \'{}\' in state {}", symbol->get_name(), rule->to_string(arrow, eps), state->get_index()); + } + }; + + template + struct ReduceReduceConflict { + const State* state; + const Rule* rule1; + const Rule* rule2; + + std::string to_string(std::string_view arrow = "->", std::string_view eps = "") const { + return fmt::format("Reduce-reduce conflict of rule \'{}\' and rule \'{}\' in state {}", rule1->to_string(arrow, eps), rule2->to_string(arrow, eps), state->get_index()); + } + }; + + template + using Issue = std::variant, ReduceReduceConflict>; + + template + class ParserReport { + public: + using IssueType = Issue; + using RuleType = Rule; + using StateType = State; + using SymbolType = Symbol; + + using ReduceReduceConflictType = ReduceReduceConflict; + using ShiftReduceConflictType = ShiftReduceConflict; + + bool ok() const { + return _issues.empty(); + } + operator bool() const { + return ok(); + } + + std::size_t number_of_issues() const { + return _issues.size(); + } + auto begin() { + return _issues.begin(); + } + auto end() { + return _issues.end(); + } + auto begin() const { + return _issues.begin(); + } + auto end() const { + return _issues.end(); + } + + void add_shift_reduce_conflict(const StateType* state, const SymbolType* symbol, const RuleType* rule) { + _issues.push_back(ShiftReduceConflictType{state, symbol, rule}); + } + + void add_reduce_reduce_conflict(const StateType* state, const RuleType* rule1, const RuleType* rule2) { + _issues.push_back(ReduceReduceConflictType{state, rule1, rule2}); + } + + std::string to_string(std::string_view arrow = "->", std::string_view eps = "") const { + std::vector issues_str(_issues.size()); + std::transform(_issues.begin(), _issues.end(), issues_str.begin(), [&](const auto& issue) { + return visit_with(issue, [&](const ShiftReduceConflictType& sr) { return sr.to_string(arrow, eps); }, [&](const ReduceReduceConflictType& rr) { return rr.to_string(arrow, eps); }); + }); + return fmt::format("{}", fmt::join(issues_str.begin(), issues_str.end(), "\n")); + } + + private: + std::vector _issues; + }; } // namespace pog diff --git a/src/Pog/ParsingTable.hpp b/src/Pog/ParsingTable.hpp index 7f0fd73c..354b6635 100644 --- a/src/Pog/ParsingTable.hpp +++ b/src/Pog/ParsingTable.hpp @@ -2,168 +2,148 @@ #include -#include "Pog/Operations/Lookahead.hpp" -#include "Pog/Types/StateAndSymbol.hpp" -#include "Pog/Types/StateAndRule.hpp" -#include "Pog/ParserReport.hpp" +#include "Pog/Action.hpp" #include "Pog/Automaton.hpp" #include "Pog/Grammar.hpp" -#include "Pog/Action.hpp" -#include "Pog/Symbol.hpp" +#include "Pog/Operations/Lookahead.hpp" +#include "Pog/ParserReport.hpp" #include "Pog/State.hpp" +#include "Pog/Symbol.hpp" +#include "Pog/Types/StateAndRule.hpp" +#include "Pog/Types/StateAndSymbol.hpp" namespace pog { -template -class ParsingTable -{ -public: - using ActionType = Action; - using ShiftActionType = Shift; - using ReduceActionType = Reduce; - - using AutomatonType = Automaton; - using GrammarType = Grammar; - using RuleType = Rule; - using StateType = State; - using SymbolType = Symbol; - - using StateAndRuleType = StateAndRule; - using StateAndSymbolType = StateAndSymbol; - - // TODO: Lookahead<> should be non-const but we need it for operator[] - ParsingTable(const AutomatonType* automaton, const GrammarType* grammar, Lookahead& lookahead_op) - : _automaton(automaton), _grammar(grammar), _lookahead_op(lookahead_op) {} - - void calculate(ParserReport& report) - { - for (const auto& state : _automaton->get_states()) - { - if (state->is_accepting()) - add_accept(state.get(), _grammar->get_end_of_input_symbol()); - - for (const auto& [sym, dest_state] : state->get_transitions()) - add_state_transition(report, state.get(), sym, dest_state); - - for (const auto& item : state->get_production_items()) - { - for (const auto& sym : _lookahead_op[StateAndRuleType{state.get(), item->get_rule()}]) - add_reduction(report, state.get(), sym, item->get_rule()); - } - } - } - - void add_accept(const StateType* state, const SymbolType* symbol) - { - auto ss = StateAndSymbolType{state, symbol}; - auto itr = _action_table.find(ss); - if (itr != _action_table.end()) - assert(false && "Conflict happened in placing accept but this shouldn't happen"); - - _action_table.emplace(std::move(ss), Accept{}); - } - - void add_state_transition(ParserReport& report, const StateType* src_state, const SymbolType* symbol, const StateType* dest_state) - { - auto ss = StateAndSymbolType{src_state, symbol}; - if (symbol->is_terminal()) - { - auto itr = _action_table.find(ss); - if (itr != _action_table.end()) - { - if (std::holds_alternative(itr->second)) - report.add_shift_reduce_conflict(ss.state, ss.symbol, std::get(itr->second).rule); - } - else - _action_table.emplace(std::move(ss), ShiftActionType{dest_state}); - } - else if (symbol->is_nonterminal()) - { - auto itr = _goto_table.find(ss); - if (itr != _goto_table.end()) - assert(false && "Conflict happened in filling GOTO table but this shouldn't happen"); - - _goto_table.emplace(std::move(ss), dest_state); - } - } - - void add_reduction(ParserReport& report, const StateType* state, const SymbolType* symbol, const RuleType* rule) - { - auto ss = StateAndSymbolType{state, symbol}; - auto itr = _action_table.find(ss); - if (itr != _action_table.end()) - { - std::optional stack_prec; - if (rule->has_precedence()) - stack_prec = rule->get_precedence(); - else if (auto op_symbol = rule->get_rightmost_terminal(); op_symbol && op_symbol->has_precedence()) - stack_prec = op_symbol->get_precedence(); - - if (stack_prec.has_value() && symbol->has_precedence()) - { - const auto& input_prec = symbol->get_precedence(); - // Stack symbol precedence is lower, keep shift in the table - if (stack_prec < input_prec) - { - return; - } - // Stack symbol precedence is greater, prefer reduce - else if (stack_prec > input_prec) - { - itr->second = ReduceActionType{rule}; - return; - } - } - - if (std::holds_alternative(itr->second)) - report.add_reduce_reduce_conflict(ss.state, std::get(itr->second).rule, rule); - else if (std::holds_alternative(itr->second)) - report.add_shift_reduce_conflict(ss.state, ss.symbol, rule); - } - else - _action_table.emplace(std::move(ss), ReduceActionType{rule}); - } - - std::optional get_action(const StateType* state, const SymbolType* symbol) const - { - auto action_itr = _action_table.find(StateAndSymbolType{state, symbol}); - if (action_itr == _action_table.end()) - return std::nullopt; - - return action_itr->second; - } - - std::optional get_transition(const StateType* state, const SymbolType* symbol) const - { - auto goto_itr = _goto_table.find(StateAndSymbolType{state, symbol}); - if (goto_itr == _goto_table.end()) - return std::nullopt; - - return goto_itr->second; - } - - std::vector get_expected_symbols_from_state(const StateType* state) const - { - std::vector result; - for (const auto& sym : _grammar->get_symbols()) - { - if (sym->is_nonterminal()) - continue; - - StateAndSymbolType ss{state, sym.get()}; - if (auto itr = _action_table.find(ss); itr != _action_table.end()) - result.push_back(sym.get()); - } - - return result; - } - -private: - const AutomatonType* _automaton; - const GrammarType* _grammar; - std::unordered_map _action_table; - std::unordered_map _goto_table; - Lookahead& _lookahead_op; -}; + template + class ParsingTable { + public: + using ActionType = Action; + using ShiftActionType = Shift; + using ReduceActionType = Reduce; + + using AutomatonType = Automaton; + using GrammarType = Grammar; + using RuleType = Rule; + using StateType = State; + using SymbolType = Symbol; + + using StateAndRuleType = StateAndRule; + using StateAndSymbolType = StateAndSymbol; + + // TODO: Lookahead<> should be non-const but we need it for operator[] + ParsingTable(const AutomatonType* automaton, const GrammarType* grammar, Lookahead& lookahead_op) + : _automaton(automaton), _grammar(grammar), _lookahead_op(lookahead_op) { + } + + void calculate(ParserReport& report) { + for (const auto& state : _automaton->get_states()) { + if (state->is_accepting()) + add_accept(state.get(), _grammar->get_end_of_input_symbol()); + + for (const auto& [sym, dest_state] : state->get_transitions()) + add_state_transition(report, state.get(), sym, dest_state); + + for (const auto& item : state->get_production_items()) { + for (const auto& sym : _lookahead_op[StateAndRuleType{state.get(), item->get_rule()}]) + add_reduction(report, state.get(), sym, item->get_rule()); + } + } + } + + void add_accept(const StateType* state, const SymbolType* symbol) { + auto ss = StateAndSymbolType{state, symbol}; + auto itr = _action_table.find(ss); + if (itr != _action_table.end()) + assert(false && "Conflict happened in placing accept but this shouldn't happen"); + + _action_table.emplace(std::move(ss), Accept{}); + } + + void add_state_transition(ParserReport& report, const StateType* src_state, const SymbolType* symbol, const StateType* dest_state) { + auto ss = StateAndSymbolType{src_state, symbol}; + if (symbol->is_terminal()) { + auto itr = _action_table.find(ss); + if (itr != _action_table.end()) { + if (std::holds_alternative(itr->second)) + report.add_shift_reduce_conflict(ss.state, ss.symbol, std::get(itr->second).rule); + } else + _action_table.emplace(std::move(ss), ShiftActionType{dest_state}); + } else if (symbol->is_nonterminal()) { + auto itr = _goto_table.find(ss); + if (itr != _goto_table.end()) + assert(false && "Conflict happened in filling GOTO table but this shouldn't happen"); + + _goto_table.emplace(std::move(ss), dest_state); + } + } + + void add_reduction(ParserReport& report, const StateType* state, const SymbolType* symbol, const RuleType* rule) { + auto ss = StateAndSymbolType{state, symbol}; + auto itr = _action_table.find(ss); + if (itr != _action_table.end()) { + std::optional stack_prec; + if (rule->has_precedence()) + stack_prec = rule->get_precedence(); + else if (auto op_symbol = rule->get_rightmost_terminal(); op_symbol && op_symbol->has_precedence()) + stack_prec = op_symbol->get_precedence(); + + if (stack_prec.has_value() && symbol->has_precedence()) { + const auto& input_prec = symbol->get_precedence(); + // Stack symbol precedence is lower, keep shift in the table + if (stack_prec < input_prec) { + return; + } + // Stack symbol precedence is greater, prefer reduce + else if (stack_prec > input_prec) { + itr->second = ReduceActionType{rule}; + return; + } + } + + if (std::holds_alternative(itr->second)) + report.add_reduce_reduce_conflict(ss.state, std::get(itr->second).rule, rule); + else if (std::holds_alternative(itr->second)) + report.add_shift_reduce_conflict(ss.state, ss.symbol, rule); + } else + _action_table.emplace(std::move(ss), ReduceActionType{rule}); + } + + std::optional get_action(const StateType* state, const SymbolType* symbol) const { + auto action_itr = _action_table.find(StateAndSymbolType{state, symbol}); + if (action_itr == _action_table.end()) + return std::nullopt; + + return action_itr->second; + } + + std::optional get_transition(const StateType* state, const SymbolType* symbol) const { + auto goto_itr = _goto_table.find(StateAndSymbolType{state, symbol}); + if (goto_itr == _goto_table.end()) + return std::nullopt; + + return goto_itr->second; + } + + std::vector get_expected_symbols_from_state(const StateType* state) const { + std::vector result; + for (const auto& sym : _grammar->get_symbols()) { + if (sym->is_nonterminal()) + continue; + + StateAndSymbolType ss{state, sym.get()}; + if (auto itr = _action_table.find(ss); itr != _action_table.end()) + result.push_back(sym.get()); + } + + return result; + } + + private: + const AutomatonType* _automaton; + const GrammarType* _grammar; + std::unordered_map _action_table; + std::unordered_map _goto_table; + Lookahead& _lookahead_op; + }; } // namespace pog diff --git a/src/Pog/Precedence.hpp b/src/Pog/Precedence.hpp index bd16eb1f..17745266 100644 --- a/src/Pog/Precedence.hpp +++ b/src/Pog/Precedence.hpp @@ -4,45 +4,43 @@ namespace pog { -enum class Associativity -{ - Left, - Right -}; - -struct Precedence -{ - std::uint32_t level; - Associativity assoc; - - bool operator==(const Precedence& rhs) const { return level == rhs.level && assoc == rhs.assoc; } - bool operator!=(const Precedence& rhs) const { return !(*this == rhs); } - - bool operator<(const Precedence& rhs) const - { - if (level < rhs.level) - return true; - else if (level == rhs.level) - { - if (assoc == Associativity::Right) - return true; - } - - return false; - } - - bool operator>(const Precedence& rhs) const - { - if (level > rhs.level) - return true; - else if (level == rhs.level) - { - if (assoc == Associativity::Left) - return true; - } - - return false; - } -}; + enum class Associativity { + Left, + Right + }; + + struct Precedence { + std::uint32_t level; + Associativity assoc; + + bool operator==(const Precedence& rhs) const { + return level == rhs.level && assoc == rhs.assoc; + } + bool operator!=(const Precedence& rhs) const { + return !(*this == rhs); + } + + bool operator<(const Precedence& rhs) const { + if (level < rhs.level) + return true; + else if (level == rhs.level) { + if (assoc == Associativity::Right) + return true; + } + + return false; + } + + bool operator>(const Precedence& rhs) const { + if (level > rhs.level) + return true; + else if (level == rhs.level) { + if (assoc == Associativity::Left) + return true; + } + + return false; + } + }; } // namespace pog diff --git a/src/Pog/Relations/Includes.hpp b/src/Pog/Relations/Includes.hpp index c10ad620..a4736871 100644 --- a/src/Pog/Relations/Includes.hpp +++ b/src/Pog/Relations/Includes.hpp @@ -4,145 +4,135 @@ #include -#include "Pog/Types/StateAndSymbol.hpp" #include "Pog/Relations/Relation.hpp" +#include "Pog/Types/StateAndSymbol.hpp" namespace pog { -/** - * Includes is a relation on tuples of (q,x) where q is state and x is symbol. - * Basically it's a relation on transitions over symbols coming out from states. - * - * Let's imagine that state Q contains item A -> a <*> B b where a and b are sequences - * of terminals and nonterminals. We had to get to this state Q from state P which - * contains item A -> <*> a B b. If and only if b can be reduced down to empty string (b =>* eps), - * we say that (Q, B) includes (P, A). - * - * To put this into human-friendly language, if we are in a state with item A -> a <*> B b, - * that means we are about to read B from the input. If the sequence b can possibly be empty, - * then we say that the state with item A -> a <*> B b and symbol B includes state with - * item A -> <*> a B b and symbol A. - * - * This is useful for construction of Follow sets because if b can be completely empty, then - * what can follow A can also follow B (with respect to states they are in). - */ -template -class Includes : public Relation> -{ -public: - using Parent = Relation>; - - using AutomatonType = Automaton; - using BacktrackingInfoType = BacktrackingInfo; - using GrammarType = Grammar; - using StateType = State; - using SymbolType = Symbol; - - using StateAndSymbolType = StateAndSymbol; - - Includes(const AutomatonType* automaton, const GrammarType* grammar) : Parent(automaton, grammar) {} - Includes(const Includes&) = delete; - Includes(Includes&&) noexcept = default; - - virtual void calculate() override - { - // Iterate over all states in the LR automaton - for (const auto& state : Parent::_automaton->get_states()) - { - for (const auto& item : *state.get()) - { - // We are looking for items in form A -> a <*> B b so we are not intersted in final items - if (item->is_final()) - continue; - - // Get the symbol right next to <*> in an item - auto next_symbol = item->get_read_symbol(); - - // If the next symbol is not nonterminal then we are again not interested - if (!next_symbol->is_nonterminal()) - continue; - - StateAndSymbolType src_ss{state.get(), next_symbol}; - Parent::_relation.emplace(src_ss, std::unordered_set{}); - - // Get the 'b' out of A -> a <*> B b - // If b can't be reduced down to empty string - Empty(b) - then we are not interested - auto right_rest = item->get_right_side_without_read_symbol(); - if (!right_rest.empty() && !Parent::_grammar->empty(right_rest)) - continue; - - // Now we'll start backtracking through LR automaton using backtransitions. - // We'll basically just go in the different direction of arrows in the automata. - // We know of what symbols 'a' in A -> a <*> B b is made of so we exactly know which - // backtransitions to take. There can be multiple transitions through the same symbol - // going into current state so we'll put them into queue and process until queue is empty. - std::unordered_set visited_states; - std::deque to_process; - // Let's insert the current state and item A -> a <*> B b into the queue as a starting point - to_process.push_back(BacktrackingInfoType{state.get(), *item.get()}); - while (!to_process.empty()) - { - auto backtracking_info = std::move(to_process.front()); - to_process.pop_front(); - - // If we've reached state with item A -> <*> a B b, we've reached our destination - if (backtracking_info.item.get_read_pos() == 0) - { - // Insert relation - StateAndSymbolType dest_ss{backtracking_info.state, backtracking_info.item.get_rule()->get_lhs()}; - auto itr = Parent::_relation.find(src_ss); - if (itr == Parent::_relation.end()) - assert(false && "This shouldn't happen"); - itr->second.insert(std::move(dest_ss)); - continue; - } - - // Observe backtransitions over the symbol left to the <*> in an item - const auto& back_trans = backtracking_info.state->get_back_transitions(); - auto itr = back_trans.find(backtracking_info.item.get_previous_symbol()); - if (itr == back_trans.end()) - assert(false && "This shouldn't happen"); - - // Perform step back of an item so that <*> in an item is moved one symbol to the left - backtracking_info.item.step_back(); - for (const auto& dest_state : itr->second) - { - if (visited_states.find(dest_state) == visited_states.end()) - { - // Put non-visited states from backtransitions into the queue - to_process.push_back(BacktrackingInfoType{dest_state, backtracking_info.item}); - visited_states.emplace(dest_state); - } - } - } - } - } - } - - std::string generate_relation_graph() - { - std::vector states_str, edges_str; - for (const auto& [ss, dests] : Parent::_relation) - { - states_str.push_back(fmt::format("n_{}_{} [label=\"({}, {})\"]", ss.state->get_index(), ss.symbol->get_index(), ss.state->get_index(), ss.symbol->get_name())); - for (const auto& dest_ss : dests) - { - states_str.push_back(fmt::format("n_{}_{} [label=\"({}, {})\"]", dest_ss.state->get_index(), dest_ss.symbol->get_index(), dest_ss.state->get_index(), dest_ss.symbol->get_name())); - edges_str.push_back(fmt::format("n_{}_{} -> n_{}_{}", ss.state->get_index(), ss.symbol->get_index(), dest_ss.state->get_index(), dest_ss.symbol->get_index())); - } - } - - return fmt::format(R"(digraph Includes {{ + /** + * Includes is a relation on tuples of (q,x) where q is state and x is symbol. + * Basically it's a relation on transitions over symbols coming out from states. + * + * Let's imagine that state Q contains item A -> a <*> B b where a and b are sequences + * of terminals and nonterminals. We had to get to this state Q from state P which + * contains item A -> <*> a B b. If and only if b can be reduced down to empty string (b =>* eps), + * we say that (Q, B) includes (P, A). + * + * To put this into human-friendly language, if we are in a state with item A -> a <*> B b, + * that means we are about to read B from the input. If the sequence b can possibly be empty, + * then we say that the state with item A -> a <*> B b and symbol B includes state with + * item A -> <*> a B b and symbol A. + * + * This is useful for construction of Follow sets because if b can be completely empty, then + * what can follow A can also follow B (with respect to states they are in). + */ + template + class Includes : public Relation> { + public: + using Parent = Relation>; + + using AutomatonType = Automaton; + using BacktrackingInfoType = BacktrackingInfo; + using GrammarType = Grammar; + using StateType = State; + using SymbolType = Symbol; + + using StateAndSymbolType = StateAndSymbol; + + Includes(const AutomatonType* automaton, const GrammarType* grammar) + : Parent(automaton, grammar) { + } + Includes(const Includes&) = delete; + Includes(Includes&&) noexcept = default; + + virtual void calculate() override { + // Iterate over all states in the LR automaton + for (const auto& state : Parent::_automaton->get_states()) { + for (const auto& item : *state.get()) { + // We are looking for items in form A -> a <*> B b so we are not intersted in final items + if (item->is_final()) + continue; + + // Get the symbol right next to <*> in an item + auto next_symbol = item->get_read_symbol(); + + // If the next symbol is not nonterminal then we are again not interested + if (!next_symbol->is_nonterminal()) + continue; + + StateAndSymbolType src_ss{state.get(), next_symbol}; + Parent::_relation.emplace(src_ss, std::unordered_set{}); + + // Get the 'b' out of A -> a <*> B b + // If b can't be reduced down to empty string - Empty(b) - then we are not interested + auto right_rest = item->get_right_side_without_read_symbol(); + if (!right_rest.empty() && !Parent::_grammar->empty(right_rest)) + continue; + + // Now we'll start backtracking through LR automaton using backtransitions. + // We'll basically just go in the different direction of arrows in the automata. + // We know of what symbols 'a' in A -> a <*> B b is made of so we exactly know which + // backtransitions to take. There can be multiple transitions through the same symbol + // going into current state so we'll put them into queue and process until queue is empty. + std::unordered_set visited_states; + std::deque to_process; + // Let's insert the current state and item A -> a <*> B b into the queue as a starting point + to_process.push_back(BacktrackingInfoType{state.get(), *item.get()}); + while (!to_process.empty()) { + auto backtracking_info = std::move(to_process.front()); + to_process.pop_front(); + + // If we've reached state with item A -> <*> a B b, we've reached our destination + if (backtracking_info.item.get_read_pos() == 0) { + // Insert relation + StateAndSymbolType dest_ss{backtracking_info.state, backtracking_info.item.get_rule()->get_lhs()}; + auto itr = Parent::_relation.find(src_ss); + if (itr == Parent::_relation.end()) + assert(false && "This shouldn't happen"); + itr->second.insert(std::move(dest_ss)); + continue; + } + + // Observe backtransitions over the symbol left to the <*> in an item + const auto& back_trans = backtracking_info.state->get_back_transitions(); + auto itr = back_trans.find(backtracking_info.item.get_previous_symbol()); + if (itr == back_trans.end()) + assert(false && "This shouldn't happen"); + + // Perform step back of an item so that <*> in an item is moved one symbol to the left + backtracking_info.item.step_back(); + for (const auto& dest_state : itr->second) { + if (visited_states.find(dest_state) == visited_states.end()) { + // Put non-visited states from backtransitions into the queue + to_process.push_back(BacktrackingInfoType{dest_state, backtracking_info.item}); + visited_states.emplace(dest_state); + } + } + } + } + } + } + + std::string generate_relation_graph() { + std::vector states_str, edges_str; + for (const auto& [ss, dests] : Parent::_relation) { + states_str.push_back(fmt::format("n_{}_{} [label=\"({}, {})\"]", ss.state->get_index(), ss.symbol->get_index(), ss.state->get_index(), ss.symbol->get_name())); + for (const auto& dest_ss : dests) { + states_str.push_back(fmt::format("n_{}_{} [label=\"({}, {})\"]", dest_ss.state->get_index(), dest_ss.symbol->get_index(), dest_ss.state->get_index(), dest_ss.symbol->get_name())); + edges_str.push_back(fmt::format("n_{}_{} -> n_{}_{}", ss.state->get_index(), ss.symbol->get_index(), dest_ss.state->get_index(), dest_ss.symbol->get_index())); + } + } + + return fmt::format(R"(digraph Includes {{ node [shape=circle]; {} {} }})", - fmt::join(states_str.begin(), states_str.end(), "\n"), - fmt::join(edges_str.begin(), edges_str.end(), "\n") - ); - } -}; + fmt::join(states_str.begin(), states_str.end(), "\n"), + fmt::join(edges_str.begin(), edges_str.end(), "\n")); + } + }; } // namespace pog diff --git a/src/Pog/Relations/Lookback.hpp b/src/Pog/Relations/Lookback.hpp index 3bdfe058..f3520dca 100644 --- a/src/Pog/Relations/Lookback.hpp +++ b/src/Pog/Relations/Lookback.hpp @@ -2,115 +2,109 @@ #include -#include "Pog/Types/StateAndSymbol.hpp" #include "Pog/Relations/Relation.hpp" #include "Pog/Types/StateAndRule.hpp" +#include "Pog/Types/StateAndSymbol.hpp" namespace pog { -/** - * Lookback is a relation of tuples (q,R) where q is state and R is a rule from grammar and - * tuples of (p,x) where p is state and x is symbol. Basically it's a relation on state and rule - * with state and symbol. - * - * Let's imagine that state Q contains final item A -> x <*> where x is a sequence of terminals and - * nonterminals. That means we need to perform production of rule A -> x and reduce x on the stack - * into A. That also means that there is some state P with item B -> a <*> A b through which we had to - * go into state Q. If it happens then (Q, A -> x) lookbacks (P, A). - * - * To put it simply, in order to get to state with final item A -> x <*>, we first had to go through - * state with item B -> a <*> A b. We just simply put state with item A -> x <*> and rule A -> x into relation - * with the origin state with item B -> a <*> A b and symbol A. - * - * This is useful for so-called propagation of lookaheads. If we know that rule A -> x is being used - * and it all originated in certain state where rule B -> a A b is being processed, we can use what - * can possible follow A in B -> a A b to know whether to use production of A -> x. - */ -template -class Lookback : public Relation, StateAndSymbol> -{ -public: - using Parent = Relation, StateAndSymbol>; + /** + * Lookback is a relation of tuples (q,R) where q is state and R is a rule from grammar and + * tuples of (p,x) where p is state and x is symbol. Basically it's a relation on state and rule + * with state and symbol. + * + * Let's imagine that state Q contains final item A -> x <*> where x is a sequence of terminals and + * nonterminals. That means we need to perform production of rule A -> x and reduce x on the stack + * into A. That also means that there is some state P with item B -> a <*> A b through which we had to + * go into state Q. If it happens then (Q, A -> x) lookbacks (P, A). + * + * To put it simply, in order to get to state with final item A -> x <*>, we first had to go through + * state with item B -> a <*> A b. We just simply put state with item A -> x <*> and rule A -> x into relation + * with the origin state with item B -> a <*> A b and symbol A. + * + * This is useful for so-called propagation of lookaheads. If we know that rule A -> x is being used + * and it all originated in certain state where rule B -> a A b is being processed, we can use what + * can possible follow A in B -> a A b to know whether to use production of A -> x. + */ + template + class Lookback : public Relation, StateAndSymbol> { + public: + using Parent = Relation, StateAndSymbol>; - using AutomatonType = Automaton; - using BacktrackingInfoType = BacktrackingInfo; - using GrammarType = Grammar; - using StateType = State; - using SymbolType = Symbol; + using AutomatonType = Automaton; + using BacktrackingInfoType = BacktrackingInfo; + using GrammarType = Grammar; + using StateType = State; + using SymbolType = Symbol; - using StateAndSymbolType = StateAndSymbol; - using StateAndRuleType = StateAndRule; + using StateAndSymbolType = StateAndSymbol; + using StateAndRuleType = StateAndRule; - Lookback(const AutomatonType* automaton, const GrammarType* grammar) : Parent(automaton, grammar) {} - Lookback(const Lookback&) = delete; - Lookback(Lookback&&) noexcept = default; + Lookback(const AutomatonType* automaton, const GrammarType* grammar) + : Parent(automaton, grammar) { + } + Lookback(const Lookback&) = delete; + Lookback(Lookback&&) noexcept = default; - virtual void calculate() override - { - // Iterate over all states of LR automaton - for (const auto& state : Parent::_automaton->get_states()) - { - for (const auto& item : *state.get()) - { - // We are not interested in items other than in form A -> x <*> - if (!item->is_final()) - continue; + virtual void calculate() override { + // Iterate over all states of LR automaton + for (const auto& state : Parent::_automaton->get_states()) { + for (const auto& item : *state.get()) { + // We are not interested in items other than in form A -> x <*> + if (!item->is_final()) + continue; - // Get left-hand side symbol of a rule - auto prod_symbol = item->get_rule()->get_lhs(); + // Get left-hand side symbol of a rule + auto prod_symbol = item->get_rule()->get_lhs(); - // Now we'll start backtracking through LR automaton using backtransitions. - // We'll basically just go in the different direction of arrows in the automata. - // We know that we have item A -> x <*> so we know which backtransitions to take (those contained in sequence x). - // There can be multiple transitions through the same symbol - // going into current state so we'll put them into queue and process until queue is empty. - std::unordered_set visited_states; - std::deque to_process; - // Let's insert the current state and item A -> x <*> into the queue as a starting point - to_process.push_back(BacktrackingInfoType{state.get(), *item.get()}); - while (!to_process.empty()) - { - auto backtracking_info = std::move(to_process.front()); - to_process.pop_front(); + // Now we'll start backtracking through LR automaton using backtransitions. + // We'll basically just go in the different direction of arrows in the automata. + // We know that we have item A -> x <*> so we know which backtransitions to take (those contained in sequence x). + // There can be multiple transitions through the same symbol + // going into current state so we'll put them into queue and process until queue is empty. + std::unordered_set visited_states; + std::deque to_process; + // Let's insert the current state and item A -> x <*> into the queue as a starting point + to_process.push_back(BacktrackingInfoType{state.get(), *item.get()}); + while (!to_process.empty()) { + auto backtracking_info = std::move(to_process.front()); + to_process.pop_front(); - // If the state has transition over the symbol A, that means there is an item B -> a <*> A b - if (backtracking_info.state->get_transitions().find(prod_symbol) != backtracking_info.state->get_transitions().end()) - { - // Insert relation - StateAndRuleType src_sr{state.get(), item->get_rule()}; - StateAndSymbolType dest_ss{backtracking_info.state, prod_symbol}; - auto itr = Parent::_relation.find(src_sr); - if (itr == Parent::_relation.end()) - Parent::_relation.emplace(std::move(src_sr), std::unordered_set{std::move(dest_ss)}); - else - itr->second.insert(std::move(dest_ss)); - } + // If the state has transition over the symbol A, that means there is an item B -> a <*> A b + if (backtracking_info.state->get_transitions().find(prod_symbol) != backtracking_info.state->get_transitions().end()) { + // Insert relation + StateAndRuleType src_sr{state.get(), item->get_rule()}; + StateAndSymbolType dest_ss{backtracking_info.state, prod_symbol}; + auto itr = Parent::_relation.find(src_sr); + if (itr == Parent::_relation.end()) + Parent::_relation.emplace(std::move(src_sr), std::unordered_set{std::move(dest_ss)}); + else + itr->second.insert(std::move(dest_ss)); + } - // We've reached item with <*> at the start so we are no longer interested in it - if (backtracking_info.item.get_read_pos() == 0) - continue; + // We've reached item with <*> at the start so we are no longer interested in it + if (backtracking_info.item.get_read_pos() == 0) + continue; - // Observe backtransitions over the symbol left to the <*> in an item - const auto& back_trans = backtracking_info.state->get_back_transitions(); - auto itr = back_trans.find(backtracking_info.item.get_previous_symbol()); - if (itr == back_trans.end()) - assert(false && "This shouldn't happen"); + // Observe backtransitions over the symbol left to the <*> in an item + const auto& back_trans = backtracking_info.state->get_back_transitions(); + auto itr = back_trans.find(backtracking_info.item.get_previous_symbol()); + if (itr == back_trans.end()) + assert(false && "This shouldn't happen"); - // Perform step back of an item so that <*> in an item is moved one symbol to the left - backtracking_info.item.step_back(); - for (const auto& dest_state : itr->second) - { - if (visited_states.find(dest_state) == visited_states.end()) - { - // Put non-visited states from backtransitions into the queue - to_process.push_back(BacktrackingInfoType{dest_state, backtracking_info.item}); - visited_states.emplace(dest_state); - } - } - } - } - } - } -}; + // Perform step back of an item so that <*> in an item is moved one symbol to the left + backtracking_info.item.step_back(); + for (const auto& dest_state : itr->second) { + if (visited_states.find(dest_state) == visited_states.end()) { + // Put non-visited states from backtransitions into the queue + to_process.push_back(BacktrackingInfoType{dest_state, backtracking_info.item}); + visited_states.emplace(dest_state); + } + } + } + } + } + } + }; } // namespace pog diff --git a/src/Pog/Relations/Relation.hpp b/src/Pog/Relations/Relation.hpp index fdff09b5..b8b154e2 100644 --- a/src/Pog/Relations/Relation.hpp +++ b/src/Pog/Relations/Relation.hpp @@ -8,57 +8,63 @@ namespace pog { -template -struct BacktrackingInfo -{ - const State* state; - Item item; -}; + template + struct BacktrackingInfo { + const State* state; + Item item; + }; -template -class Relation -{ -public: - using AutomatonType = Automaton; - using GrammarType = Grammar; + template + class Relation { + public: + using AutomatonType = Automaton; + using GrammarType = Grammar; - Relation(const AutomatonType* automaton, const GrammarType* grammar) : _automaton(automaton), _grammar(grammar) {} - Relation(const Relation&) = delete; - Relation(Relation&&) noexcept = default; - virtual ~Relation() = default; + Relation(const AutomatonType* automaton, const GrammarType* grammar) + : _automaton(automaton), _grammar(grammar) { + } + Relation(const Relation&) = delete; + Relation(Relation&&) noexcept = default; + virtual ~Relation() = default; - virtual void calculate() = 0; + virtual void calculate() = 0; - auto begin() { return _relation.begin(); } - auto end() { return _relation.end(); } + auto begin() { + return _relation.begin(); + } + auto end() { + return _relation.end(); + } - auto begin() const { return _relation.begin(); } - auto end() const { return _relation.end(); } + auto begin() const { + return _relation.begin(); + } + auto end() const { + return _relation.end(); + } - template - std::unordered_set* find(const T& key) - { - auto itr = _relation.find(key); - if (itr == _relation.end()) - return nullptr; + template + std::unordered_set* find(const T& key) { + auto itr = _relation.find(key); + if (itr == _relation.end()) + return nullptr; - return &itr->second; - } + return &itr->second; + } - template - const std::unordered_set* find(const T& key) const - { - auto itr = _relation.find(key); - if (itr == _relation.end()) - return nullptr; + template + const std::unordered_set* find(const T& key) const { + auto itr = _relation.find(key); + if (itr == _relation.end()) + return nullptr; - return &itr->second; - } + return &itr->second; + } -protected: - const AutomatonType* _automaton; - const GrammarType* _grammar; - std::unordered_map> _relation; -}; + protected: + const AutomatonType* _automaton; + const GrammarType* _grammar; + std::unordered_map> _relation; + }; } // namespace pog diff --git a/src/Pog/Rule.hpp b/src/Pog/Rule.hpp index b82e950c..c2368000 100644 --- a/src/Pog/Rule.hpp +++ b/src/Pog/Rule.hpp @@ -14,80 +14,108 @@ namespace pog { -template -class Parser; - -template -class Rule -{ -public: - using SymbolType = Symbol; - using CallbackType = std::function&, std::vector>&&)>; - - Rule(std::uint32_t index, const SymbolType* lhs, const std::vector& rhs) - : _index(index), _lhs(lhs), _rhs(rhs), _action(), _midrule_size(std::nullopt), _start(false) {} - - template - Rule(std::uint32_t index, const SymbolType* lhs, const std::vector& rhs, CallbackT&& action) - : _index(index), _lhs(lhs), _rhs(rhs), _action(std::forward(action)), _midrule_size(std::nullopt), _start(false) {} - - std::uint32_t get_index() const { return _index; } - const SymbolType* get_lhs() const { return _lhs; } - const std::vector& get_rhs() const { return _rhs; } - - bool has_precedence() const { return static_cast(_precedence); } - const Precedence& get_precedence() const { return _precedence.value(); } - void set_precedence(std::uint32_t level, Associativity assoc) { _precedence = Precedence{level, assoc}; } - - std::size_t get_number_of_required_arguments_for_action() const - { - return is_midrule() ? get_midrule_size() : get_rhs().size(); - } - - const SymbolType* get_rightmost_terminal() const - { - auto itr = std::find_if(_rhs.rbegin(), _rhs.rend(), [](const auto& symbol) { - return symbol->is_terminal(); - }); - - return itr != _rhs.rend() ? *itr : nullptr; - } - - std::string to_string(std::string_view arrow = "->", std::string_view eps = "") const - { - std::vector rhs_strings(_rhs.size()); - std::transform(_rhs.begin(), _rhs.end(), rhs_strings.begin(), [](const SymbolType* s) { - return s->get_name(); - }); - - if (rhs_strings.empty()) - rhs_strings.push_back(std::string{eps}); - - return fmt::format("{} {} {}", _lhs->get_name(), arrow, fmt::join(rhs_strings.begin(), rhs_strings.end(), " ")); - } - - bool has_action() const { return static_cast(_action); } - bool is_start_rule() const { return _start; } - - void set_start_rule(bool set) { _start = set; } - void set_midrule(std::size_t size) { _midrule_size = size; } - bool is_midrule() const { return static_cast(_midrule_size); } - std::size_t get_midrule_size() const { return _midrule_size.value(); } - - template - ValueT perform_action(Args&&... args) const { return _action(std::forward(args)...); } - - bool operator==(const Rule& rhs) const { return _index == rhs._index; } - bool operator!=(const Rule& rhs) const { return !(*this == rhs); } - -private: - std::uint32_t _index; - const SymbolType* _lhs; - std::vector _rhs; - CallbackType _action; - std::optional _precedence; - std::optional _midrule_size; - bool _start; -}; + template + class Parser; + + template + class Rule { + public: + using SymbolType = Symbol; + using CallbackType = std::function&, std::vector>&&)>; + + Rule(std::uint32_t index, const SymbolType* lhs, const std::vector& rhs) + : _index(index), _lhs(lhs), _rhs(rhs), _action(), _midrule_size(std::nullopt), _start(false) { + } + + template + Rule(std::uint32_t index, const SymbolType* lhs, const std::vector& rhs, CallbackT&& action) + : _index(index), _lhs(lhs), _rhs(rhs), _action(std::forward(action)), _midrule_size(std::nullopt), _start(false) { + } + + std::uint32_t get_index() const { + return _index; + } + const SymbolType* get_lhs() const { + return _lhs; + } + const std::vector& get_rhs() const { + return _rhs; + } + + bool has_precedence() const { + return static_cast(_precedence); + } + const Precedence& get_precedence() const { + return _precedence.value(); + } + void set_precedence(std::uint32_t level, Associativity assoc) { + _precedence = Precedence{level, assoc}; + } + + std::size_t get_number_of_required_arguments_for_action() const { + return is_midrule() ? get_midrule_size() : get_rhs().size(); + } + + const SymbolType* get_rightmost_terminal() const { + auto itr = std::find_if(_rhs.rbegin(), _rhs.rend(), [](const auto& symbol) { + return symbol->is_terminal(); + }); + + return itr != _rhs.rend() ? *itr : nullptr; + } + + std::string to_string(std::string_view arrow = "->", std::string_view eps = "") const { + std::vector rhs_strings(_rhs.size()); + std::transform(_rhs.begin(), _rhs.end(), rhs_strings.begin(), [](const SymbolType* s) { + return s->get_name(); + }); + + if (rhs_strings.empty()) + rhs_strings.push_back(std::string{eps}); + + return fmt::format("{} {} {}", _lhs->get_name(), arrow, fmt::join(rhs_strings.begin(), rhs_strings.end(), " ")); + } + + bool has_action() const { + return static_cast(_action); + } + bool is_start_rule() const { + return _start; + } + + void set_start_rule(bool set) { + _start = set; + } + void set_midrule(std::size_t size) { + _midrule_size = size; + } + bool is_midrule() const { + return static_cast(_midrule_size); + } + std::size_t get_midrule_size() const { + return _midrule_size.value(); + } + + template + ValueT perform_action(Args&&... args) const { + return _action(std::forward(args)...); + } + + bool operator==(const Rule& rhs) const { + return _index == rhs._index; + } + bool operator!=(const Rule& rhs) const { + return !(*this == rhs); + } + + private: + std::uint32_t _index; + const SymbolType* _lhs; + std::vector _rhs; + CallbackType _action; + std::optional _precedence; + std::optional _midrule_size; + bool _start; + }; } // namespace pog diff --git a/src/Pog/RuleBuilder.hpp b/src/Pog/RuleBuilder.hpp index c42c3b06..bb822a58 100644 --- a/src/Pog/RuleBuilder.hpp +++ b/src/Pog/RuleBuilder.hpp @@ -5,136 +5,121 @@ namespace pog { -template -class RuleBuilder -{ -public: - using GrammarType = Grammar; - using RuleType = Rule; - using SymbolType = Symbol; - - struct SymbolsAndAction - { - std::vector symbols; - typename RuleType::CallbackType action; - }; - - struct RightHandSide - { - std::vector symbols_and_action; - std::optional precedence; - }; - - RuleBuilder(GrammarType* grammar, const std::string& lhs) : _grammar(grammar), _lhs(lhs), _rhss() {} - - void done() - { - if (_rhss.empty()) - return; - - const auto* lhs_symbol = _grammar->add_symbol(SymbolKind::Nonterminal, _lhs); - - std::size_t rhs_counter = 0; - for (auto&& rhs : _rhss) - { - assert(!rhs.symbols_and_action.empty() && "No symbols and action associated to right-hand side of the rule. This shouldn't happen"); - - std::vector rhs_symbols; - for (std::size_t i = 0; i < rhs.symbols_and_action.size(); ++i) - { - auto&& symbols_and_action = rhs.symbols_and_action[i]; - - std::transform(symbols_and_action.symbols.begin(), symbols_and_action.symbols.end(), std::back_inserter(rhs_symbols), [this](const auto& sym_name) { - return _grammar->add_symbol(SymbolKind::Nonterminal, sym_name); - }); - - // There are multple actions (mid-rule actions) so we need to create new symbol and epsilon rule - // for each midrule action. Midrule symbols will be inserted into the original rule. - // - // If you have rule A -> B C D and you want to perform action after B, then we'll create rules - // A -> B X C D - // X -> - // where X -> will have assigned the midrule action. - if (i < rhs.symbols_and_action.size() - 1) - { - // Create unique nonterminal for midrule action - auto midsymbol = _grammar->add_symbol( - SymbolKind::Nonterminal, - fmt::format("_{}#{}.{}", _lhs, rhs_counter, i) - ); - - // Create rule to which midrule action can be assigned and set midrule size. - // Midrule size is number of symbols preceding the midrule symbol. It represents how many - // items from stack we need to borrow for action arguments. - auto rule = _grammar->add_rule(midsymbol, std::vector{}, std::move(symbols_and_action.action)); - rule->set_midrule(rhs_symbols.size()); - rhs_symbols.push_back(midsymbol); - } - // This is the last action so do not mark it as midrule - else - { - auto rule = _grammar->add_rule(lhs_symbol, rhs_symbols, std::move(symbols_and_action.action)); - if (rule && rhs.precedence) - { - const auto& prec = rhs.precedence.value(); - rule->set_precedence(prec.level, prec.assoc); - } - } - } - - rhs_counter++; - } - } - - template - RuleBuilder& production(Args&&... args) - { - _rhss.push_back(RightHandSide{ - std::vector{ - SymbolsAndAction{ - std::vector{}, - {} - } - }, - std::nullopt - }); - _production(_rhss.back().symbols_and_action, std::forward(args)...); - return *this; - } - - RuleBuilder& precedence(std::uint32_t level, Associativity assoc) - { - _rhss.back().precedence = Precedence{level, assoc}; - return *this; - } - -private: - void _production(std::vector&) {} - - template - void _production(std::vector& sa, const std::string& symbol, Args&&... args) - { - sa.back().symbols.push_back(symbol); - _production(sa, std::forward(args)...); - } - - template - void _production(std::vector& sa, typename RuleType::CallbackType&& action, Args&&... args) - { - sa.back().action = std::move(action); - // We have ran into action so create new record in symbols and actions vector - // but only if it isn't the very last thing in the production - if constexpr (sizeof...(args) > 0) - sa.push_back(SymbolsAndAction{ - std::vector{}, - {} - }); - _production(sa, std::forward(args)...); - } - - GrammarType* _grammar; - std::string _lhs; - std::vector _rhss; -}; + template + class RuleBuilder { + public: + using GrammarType = Grammar; + using RuleType = Rule; + using SymbolType = Symbol; + + struct SymbolsAndAction { + std::vector symbols; + typename RuleType::CallbackType action; + }; + + struct RightHandSide { + std::vector symbols_and_action; + std::optional precedence; + }; + + RuleBuilder(GrammarType* grammar, const std::string& lhs) + : _grammar(grammar), _lhs(lhs), _rhss() { + } + + void done() { + if (_rhss.empty()) + return; + + const auto* lhs_symbol = _grammar->add_symbol(SymbolKind::Nonterminal, _lhs); + + std::size_t rhs_counter = 0; + for (auto&& rhs : _rhss) { + assert(!rhs.symbols_and_action.empty() && "No symbols and action associated to right-hand side of the rule. This shouldn't happen"); + + std::vector rhs_symbols; + for (std::size_t i = 0; i < rhs.symbols_and_action.size(); ++i) { + auto&& symbols_and_action = rhs.symbols_and_action[i]; + + std::transform(symbols_and_action.symbols.begin(), symbols_and_action.symbols.end(), std::back_inserter(rhs_symbols), [this](const auto& sym_name) { + return _grammar->add_symbol(SymbolKind::Nonterminal, sym_name); + }); + + // There are multple actions (mid-rule actions) so we need to create new symbol and epsilon rule + // for each midrule action. Midrule symbols will be inserted into the original rule. + // + // If you have rule A -> B C D and you want to perform action after B, then we'll create rules + // A -> B X C D + // X -> + // where X -> will have assigned the midrule action. + if (i < rhs.symbols_and_action.size() - 1) { + // Create unique nonterminal for midrule action + auto midsymbol = _grammar->add_symbol( + SymbolKind::Nonterminal, + fmt::format("_{}#{}.{}", _lhs, rhs_counter, i)); + + // Create rule to which midrule action can be assigned and set midrule size. + // Midrule size is number of symbols preceding the midrule symbol. It represents how many + // items from stack we need to borrow for action arguments. + auto rule = _grammar->add_rule(midsymbol, std::vector{}, std::move(symbols_and_action.action)); + rule->set_midrule(rhs_symbols.size()); + rhs_symbols.push_back(midsymbol); + } + // This is the last action so do not mark it as midrule + else { + auto rule = _grammar->add_rule(lhs_symbol, rhs_symbols, std::move(symbols_and_action.action)); + if (rule && rhs.precedence) { + const auto& prec = rhs.precedence.value(); + rule->set_precedence(prec.level, prec.assoc); + } + } + } + + rhs_counter++; + } + } + + template + RuleBuilder& production(Args&&... args) { + _rhss.push_back(RightHandSide{ + std::vector{ + SymbolsAndAction{ + std::vector{}, + {}}}, + std::nullopt}); + _production(_rhss.back().symbols_and_action, std::forward(args)...); + return *this; + } + + RuleBuilder& precedence(std::uint32_t level, Associativity assoc) { + _rhss.back().precedence = Precedence{level, assoc}; + return *this; + } + + private: + void _production(std::vector&) { + } + + template + void _production(std::vector& sa, const std::string& symbol, Args&&... args) { + sa.back().symbols.push_back(symbol); + _production(sa, std::forward(args)...); + } + + template + void _production(std::vector& sa, typename RuleType::CallbackType&& action, Args&&... args) { + sa.back().action = std::move(action); + // We have ran into action so create new record in symbols and actions vector + // but only if it isn't the very last thing in the production + if constexpr (sizeof...(args) > 0) + sa.push_back(SymbolsAndAction{ + std::vector{}, + {}}); + _production(sa, std::forward(args)...); + } + + GrammarType* _grammar; + std::string _lhs; + std::vector _rhss; + }; } // namespace pog diff --git a/src/Pog/State.hpp b/src/Pog/State.hpp index e605c29d..e8f6f963 100644 --- a/src/Pog/State.hpp +++ b/src/Pog/State.hpp @@ -4,154 +4,147 @@ #include #include "Pog/FilterView.hpp" -#include "Pog/Utils.hpp" #include "Pog/Item.hpp" +#include "Pog/Utils.hpp" namespace pog { -template -class State -{ -public: - using ItemType = Item; - using SymbolType = Symbol; - - State() : _index(std::numeric_limits::max()) {} - State(std::uint32_t index) : _index(index) {} - - std::uint32_t get_index() const { return _index; } - void set_index(std::uint32_t index) { _index = index; } - - std::size_t size() const { return _items.size(); } - auto begin() const { return _items.begin(); } - auto end() const { return _items.end(); } - - template - std::pair add_item(T&& item) - { - auto itr = std::lower_bound(_items.begin(), _items.end(), item, [](const auto& left, const auto& needle) { - return *left.get() < needle; - }); - - if (itr == _items.end() || *itr->get() != item) - { - auto new_itr = _items.insert(itr, std::make_unique(std::forward(item))); - return {new_itr->get(), true}; - } - else - return {itr->get(), false}; - } - - void add_transition(const SymbolType* symbol, const State* state) - { - _transitions.emplace(symbol, state); - } - - void add_back_transition(const SymbolType* symbol, const State* state) - { - auto itr = _back_transitions.find(symbol); - if (itr == _back_transitions.end()) - { - _back_transitions.emplace(symbol, std::vector{state}); - return; - } - - auto state_itr = std::lower_bound(itr->second.begin(), itr->second.end(), state->get_index(), [](const auto& left, const auto& needle) { - return left->get_index() < needle; - }); - - if (state_itr == itr->second.end() || (*state_itr)->get_index() != state->get_index()) - itr->second.insert(state_itr, state); - } - - bool is_accepting() const - { - return std::count_if(_items.begin(), _items.end(), [](const auto& item) { - return item->is_accepting(); - }) == 1; - } - - std::string to_string(std::string_view arrow = "->", std::string_view eps = "", std::string_view sep = "<*>", const std::string& newline = "\n") const - { - std::vector item_strings(_items.size()); - std::transform(_items.begin(), _items.end(), item_strings.begin(), [&](const auto& item) { - return item->to_string(arrow, eps, sep); - }); - return fmt::format("{}", fmt::join(item_strings.begin(), item_strings.end(), newline)); - } - - std::vector get_production_items() const - { - std::vector result; - transform_if(_items.begin(), _items.end(), std::back_inserter(result), - [](const auto& item) { - return item->is_final(); - }, - [](const auto& item) { - return item.get(); - } - ); - return result; - } - - auto get_kernel() const - { - return FilterView{_items.begin(), _items.end(), [](const auto& item) { - return item->is_kernel(); - }}; - } - - bool contains(const ItemType& item) const - { - auto itr = std::lower_bound(_items.begin(), _items.end(), item, [](const auto& left, const auto& needle) { - return *left.get() < needle; - }); - return itr != _items.end() && *itr->get() == item; - } - - bool operator==(const State& rhs) const - { - auto lhs_kernel = get_kernel(); - auto rhs_kernel = rhs.get_kernel(); - return std::equal(lhs_kernel.begin(), lhs_kernel.end(), rhs_kernel.begin(), rhs_kernel.end(), [](const auto& left, const auto& right) { - return *left.get() == *right.get(); - }); - } - - bool operator !=(const State& rhs) const - { - return !(*this == rhs); - } - - const std::map>& get_transitions() const { return _transitions; } - const std::map, SymbolLess>& get_back_transitions() const { return _back_transitions; } - -private: - std::uint32_t _index; - std::vector> _items; - std::map> _transitions; - std::map, SymbolLess> _back_transitions; -}; - -template -struct StateKernelHash -{ - std::size_t operator()(const State* state) const - { - std::size_t kernel_hash = 0; - for (const auto& item : state->get_kernel()) - hash_combine(kernel_hash, item->get_rule()->get_index(), item->get_read_pos()); - return kernel_hash; - } -}; - -template -struct StateKernelEquals -{ - bool operator()(const State* state1, const State* state2) const - { - return *state1 == *state2; - } -}; + template + class State { + public: + using ItemType = Item; + using SymbolType = Symbol; + + State() + : _index(std::numeric_limits::max()) { + } + State(std::uint32_t index) + : _index(index) { + } + + std::uint32_t get_index() const { + return _index; + } + void set_index(std::uint32_t index) { + _index = index; + } + + std::size_t size() const { + return _items.size(); + } + auto begin() const { + return _items.begin(); + } + auto end() const { + return _items.end(); + } + + template + std::pair add_item(T&& item) { + auto itr = std::lower_bound(_items.begin(), _items.end(), item, [](const auto& left, const auto& needle) { + return *left.get() < needle; + }); + + if (itr == _items.end() || *itr->get() != item) { + auto new_itr = _items.insert(itr, std::make_unique(std::forward(item))); + return {new_itr->get(), true}; + } else + return {itr->get(), false}; + } + + void add_transition(const SymbolType* symbol, const State* state) { + _transitions.emplace(symbol, state); + } + + void add_back_transition(const SymbolType* symbol, const State* state) { + auto itr = _back_transitions.find(symbol); + if (itr == _back_transitions.end()) { + _back_transitions.emplace(symbol, std::vector{state}); + return; + } + + auto state_itr = std::lower_bound(itr->second.begin(), itr->second.end(), state->get_index(), [](const auto& left, const auto& needle) { + return left->get_index() < needle; + }); + + if (state_itr == itr->second.end() || (*state_itr)->get_index() != state->get_index()) + itr->second.insert(state_itr, state); + } + + bool is_accepting() const { + return std::count_if(_items.begin(), _items.end(), [](const auto& item) { + return item->is_accepting(); + }) == 1; + } + + std::string to_string(std::string_view arrow = "->", std::string_view eps = "", std::string_view sep = "<*>", const std::string& newline = "\n") const { + std::vector item_strings(_items.size()); + std::transform(_items.begin(), _items.end(), item_strings.begin(), [&](const auto& item) { + return item->to_string(arrow, eps, sep); + }); + return fmt::format("{}", fmt::join(item_strings.begin(), item_strings.end(), newline)); + } + + std::vector get_production_items() const { + std::vector result; + transform_if(_items.begin(), _items.end(), std::back_inserter(result), [](const auto& item) { return item->is_final(); }, [](const auto& item) { return item.get(); }); + return result; + } + + auto get_kernel() const { + return FilterView{_items.begin(), _items.end(), [](const auto& item) { + return item->is_kernel(); + }}; + } + + bool contains(const ItemType& item) const { + auto itr = std::lower_bound(_items.begin(), _items.end(), item, [](const auto& left, const auto& needle) { + return *left.get() < needle; + }); + return itr != _items.end() && *itr->get() == item; + } + + bool operator==(const State& rhs) const { + auto lhs_kernel = get_kernel(); + auto rhs_kernel = rhs.get_kernel(); + return std::equal(lhs_kernel.begin(), lhs_kernel.end(), rhs_kernel.begin(), rhs_kernel.end(), [](const auto& left, const auto& right) { + return *left.get() == *right.get(); + }); + } + + bool operator!=(const State& rhs) const { + return !(*this == rhs); + } + + const std::map>& get_transitions() const { + return _transitions; + } + const std::map, SymbolLess>& get_back_transitions() const { + return _back_transitions; + } + + private: + std::uint32_t _index; + std::vector> _items; + std::map> _transitions; + std::map, SymbolLess> _back_transitions; + }; + + template + struct StateKernelHash { + std::size_t operator()(const State* state) const { + std::size_t kernel_hash = 0; + for (const auto& item : state->get_kernel()) + hash_combine(kernel_hash, item->get_rule()->get_index(), item->get_read_pos()); + return kernel_hash; + } + }; + + template + struct StateKernelEquals { + bool operator()(const State* state1, const State* state2) const { + return *state1 == *state2; + } + }; } // namespace pog diff --git a/src/Pog/Symbol.hpp b/src/Pog/Symbol.hpp index 3654984f..bd10d621 100644 --- a/src/Pog/Symbol.hpp +++ b/src/Pog/Symbol.hpp @@ -7,48 +7,65 @@ namespace pog { -enum class SymbolKind -{ - End, - Nonterminal, - Terminal -}; - -template -class Symbol -{ -public: - Symbol(std::uint32_t index, SymbolKind kind, const std::string& name) : _index(index), _kind(kind), _name(name) {} - - std::uint32_t get_index() const { return _index; } - const Precedence& get_precedence() const { return _precedence.value(); } - const std::string& get_name() const { return _name; } - const std::string& get_description() const { return _description.has_value() ? *_description : _name; } - - bool has_precedence() const { return static_cast(_precedence); } - bool is_end() const { return _kind == SymbolKind::End; } - bool is_nonterminal() const { return _kind == SymbolKind::Nonterminal; } - bool is_terminal() const { return _kind == SymbolKind::Terminal; } - - void set_precedence(std::uint32_t level, Associativity assoc) { _precedence = Precedence{level, assoc}; } - void set_description(const std::string& description) { _description = description; } - -private: - std::uint32_t _index; - SymbolKind _kind; - std::string _name; - std::optional _description; - std::optional _precedence; -}; - - -template -struct SymbolLess -{ - bool operator()(const Symbol* lhs, const Symbol* rhs) const - { - return lhs->get_index() < rhs->get_index(); - } -}; + enum class SymbolKind { + End, + Nonterminal, + Terminal + }; + + template + class Symbol { + public: + Symbol(std::uint32_t index, SymbolKind kind, const std::string& name) + : _index(index), _kind(kind), _name(name) { + } + + std::uint32_t get_index() const { + return _index; + } + const Precedence& get_precedence() const { + return _precedence.value(); + } + const std::string& get_name() const { + return _name; + } + const std::string& get_description() const { + return _description.has_value() ? *_description : _name; + } + + bool has_precedence() const { + return static_cast(_precedence); + } + bool is_end() const { + return _kind == SymbolKind::End; + } + bool is_nonterminal() const { + return _kind == SymbolKind::Nonterminal; + } + bool is_terminal() const { + return _kind == SymbolKind::Terminal; + } + + void set_precedence(std::uint32_t level, Associativity assoc) { + _precedence = Precedence{level, assoc}; + } + void set_description(const std::string& description) { + _description = description; + } + + private: + std::uint32_t _index; + SymbolKind _kind; + std::string _name; + std::optional _description; + std::optional _precedence; + }; + + template + struct SymbolLess { + bool operator()(const Symbol* lhs, const Symbol* rhs) const { + return lhs->get_index() < rhs->get_index(); + } + }; } // namespace pog diff --git a/src/Pog/Token.hpp b/src/Pog/Token.hpp index 71a43ff9..239f95d7 100644 --- a/src/Pog/Token.hpp +++ b/src/Pog/Token.hpp @@ -11,71 +11,81 @@ namespace pog { -template -class Token -{ -public: - using SymbolType = Symbol; - using CallbackType = std::function; - - template - Token(std::uint32_t index, const std::string& pattern, StatesT&& active_in_states) : Token(index, pattern, std::forward(active_in_states), nullptr) {} - - template - Token(std::uint32_t index, const std::string& pattern, StatesT&& active_in_states, const SymbolType* symbol) - : _index(index), _pattern(pattern), _symbol(symbol), _regexp(std::make_unique(_pattern)), _action(), - _enter_state(), _active_in_states(std::forward(active_in_states)) {} - - std::uint32_t get_index() const { return _index; } - const std::string& get_pattern() const { return _pattern; } - const SymbolType* get_symbol() const { return _symbol; } - const re2::RE2* get_regexp() const { return _regexp.get(); } - - bool has_symbol() const { return _symbol != nullptr; } - bool has_action() const { return static_cast(_action); } - bool has_transition_to_state() const { return static_cast(_enter_state); } - - template - void set_action(CallbackT&& action) - { - _action = std::forward(action); - } - - template - ValueT perform_action(Args&&... args) const - { - return _action(std::forward(args)...); - } - - void set_transition_to_state(const std::string& state) - { - _enter_state = state; - } - - const std::string& get_transition_to_state() const - { - return _enter_state.value(); - } - - template - void add_active_in_state(StrT&& state) - { - _active_in_states.push_back(std::forward(state)); - } - - const std::vector& get_active_in_states() const - { - return _active_in_states; - } - -private: - std::uint32_t _index; - std::string _pattern; - const SymbolType* _symbol; - std::unique_ptr _regexp; - CallbackType _action; - std::optional _enter_state; - std::vector _active_in_states; -}; + template + class Token { + public: + using SymbolType = Symbol; + using CallbackType = std::function; + + template + Token(std::uint32_t index, const std::string& pattern, StatesT&& active_in_states) + : Token(index, pattern, std::forward(active_in_states), nullptr) { + } + + template + Token(std::uint32_t index, const std::string& pattern, StatesT&& active_in_states, const SymbolType* symbol) + : _index(index), _pattern(pattern), _symbol(symbol), _regexp(std::make_unique(_pattern)), _action(), + _enter_state(), _active_in_states(std::forward(active_in_states)) { + } + + std::uint32_t get_index() const { + return _index; + } + const std::string& get_pattern() const { + return _pattern; + } + const SymbolType* get_symbol() const { + return _symbol; + } + const re2::RE2* get_regexp() const { + return _regexp.get(); + } + + bool has_symbol() const { + return _symbol != nullptr; + } + bool has_action() const { + return static_cast(_action); + } + bool has_transition_to_state() const { + return static_cast(_enter_state); + } + + template + void set_action(CallbackT&& action) { + _action = std::forward(action); + } + + template + ValueT perform_action(Args&&... args) const { + return _action(std::forward(args)...); + } + + void set_transition_to_state(const std::string& state) { + _enter_state = state; + } + + const std::string& get_transition_to_state() const { + return _enter_state.value(); + } + + template + void add_active_in_state(StrT&& state) { + _active_in_states.push_back(std::forward(state)); + } + + const std::vector& get_active_in_states() const { + return _active_in_states; + } + + private: + std::uint32_t _index; + std::string _pattern; + const SymbolType* _symbol; + std::unique_ptr _regexp; + CallbackType _action; + std::optional _enter_state; + std::vector _active_in_states; + }; } // namespace pog diff --git a/src/Pog/TokenBuilder.hpp b/src/Pog/TokenBuilder.hpp index 0cbb8000..1cf37541 100644 --- a/src/Pog/TokenBuilder.hpp +++ b/src/Pog/TokenBuilder.hpp @@ -1,112 +1,103 @@ #pragma once -#include "Pog/Tokenizer.hpp" #include "Pog/Grammar.hpp" #include "Pog/Token.hpp" +#include "Pog/Tokenizer.hpp" namespace pog { -template -class TokenBuilder -{ -public: - using GrammarType = Grammar; - using SymbolType = Symbol; - using TokenType = Token; - using TokenizerType = Tokenizer; - - TokenBuilder(GrammarType* grammar, TokenizerType* tokenizer) : _grammar(grammar), _tokenizer(tokenizer), _pattern("$"), - _symbol_name(), _precedence(), _action(), _fullword(false), _end_token(true), _in_states{std::string{TokenizerType::DefaultState}}, _enter_state() {} - - TokenBuilder(GrammarType* grammar, TokenizerType* tokenizer, const std::string& pattern) : _grammar(grammar), _tokenizer(tokenizer), _pattern(pattern), - _symbol_name(), _precedence(), _action(), _fullword(false), _end_token(false), _in_states{std::string{TokenizerType::DefaultState}}, _enter_state() {} - - void done() - { - TokenType* token; - if (!_end_token) - { - auto* symbol = !_symbol_name.empty() ? _grammar->add_symbol(SymbolKind::Terminal, _symbol_name) : nullptr; - token = _tokenizer->add_token(_fullword ? fmt::format("{}(\\b|$)", _pattern) : _pattern, symbol, std::move(_in_states)); - if (symbol && _precedence) - { - const auto& prec = _precedence.value(); - symbol->set_precedence(prec.level, prec.assoc); - } - - if(symbol && _description.size() != 0) - symbol->set_description(_description); - - if (_enter_state) - token->set_transition_to_state(_enter_state.value()); - } - else - { - token = _tokenizer->get_end_token(); - for (auto&& state : _in_states) - token->add_active_in_state(std::move(state)); - } - - if (_action) - token->set_action(std::move(_action)); - } - - TokenBuilder& symbol(const std::string& symbol_name) - { - _symbol_name = symbol_name; - return *this; - } - - TokenBuilder& precedence(std::uint32_t level, Associativity assoc) - { - _precedence = Precedence{level, assoc}; - return *this; - } - - TokenBuilder& description(const std::string& text) - { - _description = text; - return *this; - } - - template - TokenBuilder& action(CallbackT&& action) - { - _action = std::forward(action); - return *this; - } - - TokenBuilder& fullword() - { - _fullword = true; - return *this; - } - - template - TokenBuilder& states(Args&&... args) - { - _in_states = {std::forward(args)...}; - return *this; - } - - TokenBuilder& enter_state(const std::string& state) - { - _enter_state = state; - return *this; - } - -private: - GrammarType* _grammar; - TokenizerType* _tokenizer; - std::string _description; - std::string _pattern; - std::string _symbol_name; - std::optional _precedence; - typename TokenType::CallbackType _action; - bool _fullword; - bool _end_token; - std::vector _in_states; - std::optional _enter_state; -}; + template + class TokenBuilder { + public: + using GrammarType = Grammar; + using SymbolType = Symbol; + using TokenType = Token; + using TokenizerType = Tokenizer; + + TokenBuilder(GrammarType* grammar, TokenizerType* tokenizer) + : _grammar(grammar), _tokenizer(tokenizer), _pattern("$"), + _symbol_name(), _precedence(), _action(), _fullword(false), _end_token(true), _in_states{std::string{TokenizerType::DefaultState}}, _enter_state() { + } + + TokenBuilder(GrammarType* grammar, TokenizerType* tokenizer, const std::string& pattern) + : _grammar(grammar), _tokenizer(tokenizer), _pattern(pattern), + _symbol_name(), _precedence(), _action(), _fullword(false), _end_token(false), _in_states{std::string{TokenizerType::DefaultState}}, _enter_state() { + } + + void done() { + TokenType* token; + if (!_end_token) { + auto* symbol = !_symbol_name.empty() ? _grammar->add_symbol(SymbolKind::Terminal, _symbol_name) : nullptr; + token = _tokenizer->add_token(_fullword ? fmt::format("{}(\\b|$)", _pattern) : _pattern, symbol, std::move(_in_states)); + if (symbol && _precedence) { + const auto& prec = _precedence.value(); + symbol->set_precedence(prec.level, prec.assoc); + } + + if (symbol && _description.size() != 0) + symbol->set_description(_description); + + if (_enter_state) + token->set_transition_to_state(_enter_state.value()); + } else { + token = _tokenizer->get_end_token(); + for (auto&& state : _in_states) + token->add_active_in_state(std::move(state)); + } + + if (_action) + token->set_action(std::move(_action)); + } + + TokenBuilder& symbol(const std::string& symbol_name) { + _symbol_name = symbol_name; + return *this; + } + + TokenBuilder& precedence(std::uint32_t level, Associativity assoc) { + _precedence = Precedence{level, assoc}; + return *this; + } + + TokenBuilder& description(const std::string& text) { + _description = text; + return *this; + } + + template + TokenBuilder& action(CallbackT&& action) { + _action = std::forward(action); + return *this; + } + + TokenBuilder& fullword() { + _fullword = true; + return *this; + } + + template + TokenBuilder& states(Args&&... args) { + _in_states = {std::forward(args)...}; + return *this; + } + + TokenBuilder& enter_state(const std::string& state) { + _enter_state = state; + return *this; + } + + private: + GrammarType* _grammar; + TokenizerType* _tokenizer; + std::string _description; + std::string _pattern; + std::string _symbol_name; + std::optional _precedence; + typename TokenType::CallbackType _action; + bool _fullword; + bool _end_token; + std::vector _in_states; + std::optional _enter_state; + }; } // namespace pog diff --git a/src/Pog/Tokenizer.hpp b/src/Pog/Tokenizer.hpp index 84c0c1c1..bebd2236 100644 --- a/src/Pog/Tokenizer.hpp +++ b/src/Pog/Tokenizer.hpp @@ -1,8 +1,8 @@ #pragma once +#include #include #include -#include #include #include @@ -17,269 +17,240 @@ #define debug_tokenizer(...) #endif -#include "Pog/LineSpecialization.hpp" #include "Pog/Grammar.hpp" +#include "Pog/LineSpecialization.hpp" #include "Pog/Token.hpp" namespace pog { -template -struct TokenMatch -{ - TokenMatch(const Symbol* sym) : symbol(sym), value(), match_length(0) {} - template - TokenMatch(const Symbol* sym, T&& v, std::size_t len, LineSpecialization spec) : symbol(sym), line_spec(spec), value(std::forward(v)), match_length(len) {} - TokenMatch(const TokenMatch&) = default; - TokenMatch(TokenMatch&&) noexcept = default; - - TokenMatch& operator=(const TokenMatch&) = default; - TokenMatch& operator=(TokenMatch&&) noexcept = default; - - const Symbol* symbol; - LineSpecialization line_spec; - ValueT value; - std::size_t match_length; -}; - -struct InputStream -{ - std::unique_ptr content; - re2::StringPiece stream; - bool at_end; -}; - -template -struct StateInfo -{ - std::string name; - std::unique_ptr re_set; - std::vector*> tokens; -}; - -template -class Tokenizer -{ -public: - using CallbackType = std::function; - - static constexpr std::string_view DefaultState = "@default"; - - using GrammarType = Grammar; - using StateInfoType = StateInfo; - using SymbolType = Symbol; - using TokenType = Token; - using TokenMatchType = TokenMatch; - - Tokenizer(const GrammarType* grammar) : _grammar(grammar), _tokens(), _state_info(), _input_stack(), _current_state(nullptr), _global_action() - { - _current_line = 1; - _current_offset = 0; - _current_state = get_or_make_state_info(std::string{DefaultState}); - add_token("$", nullptr, std::vector{std::string{DefaultState}}); - } - - void prepare() - { - std::string error; - - for (const auto& token : _tokens) - { - for (const auto& state : token->get_active_in_states()) - { - error.clear(); - auto* state_info = get_or_make_state_info(state); - state_info->re_set->Add(token->get_pattern(), &error); - state_info->tokens.push_back(token.get()); - assert(1); - assert(error.empty() && "Error when compiling token regexp"); - } - } - - for (auto&& [name, info] : _state_info) - info.re_set->Compile(); - } - - const std::vector>& get_tokens() const - { - return _tokens; - } - - TokenType* get_end_token() const - { - return _tokens[0].get(); - } - - TokenType* add_token(const std::string& pattern, const SymbolType* symbol, const std::vector& states) - { - _tokens.push_back(std::make_unique(static_cast(_tokens.size()), pattern, states, symbol)); - return _tokens.back().get(); - } - - void push_input_stream(std::string& stream) - { - _input_stack.emplace_back(InputStream{std::make_unique(std::move(stream)), re2::StringPiece{}, false}); - _input_stack.back().stream = re2::StringPiece{_input_stack.back().content->c_str()}; - } - - void pop_input_stream() - { - _input_stack.pop_back(); - } - - void clear_input_streams() - { - _input_stack.clear(); - } - - void global_action(CallbackType&& global_action) - { - _global_action = std::move(global_action); - } - - void _reset_line_offset() - { - _current_offset = 0; - } - - std::uint32_t& _get_line_counter() - { - return _current_line; - } - - std::uint16_t& _get_line_offset() { - return _current_offset; - } - - std::optional next_token() - { - bool repeat = true; - while (repeat) - { - // We've emptied the stack so that means return end symbol to parser - if (_input_stack.empty()) - { - debug_tokenizer("Input stack empty - returing end of input"); - return _grammar->get_end_of_input_symbol(); - } - - auto& current_input = _input_stack.back(); - if (!current_input.at_end) - { - // Matched patterns doesn't have to be sorted (used to be in older re2 versions) but we shouldn't count on that - std::vector matched_patterns; - _current_state->re_set->Match(current_input.stream, &matched_patterns); - - // Haven't matched anything, tokenization failure, we will get into endless loop - if (matched_patterns.empty()) [[unlikely]] - { - debug_tokenizer("Nothing matched on the current input"); - return std::nullopt; - } - - re2::StringPiece submatch; - const TokenType* best_match = nullptr; - int longest_match = -1; - for (auto pattern_index : matched_patterns) - { - _current_state->tokens[pattern_index]->get_regexp()->Match(current_input.stream, 0, current_input.stream.size(), re2::RE2::Anchor::ANCHOR_START, &submatch, 1); - if (longest_match < static_cast(submatch.size())) - { - best_match = _current_state->tokens[pattern_index]; - longest_match = static_cast(submatch.size()); - } - // In case of equal matches, index of tokens chooses which one is it (lower index has higher priority) - else if (longest_match == static_cast(submatch.size())) - { - if (!best_match || best_match->get_index() > static_cast(pattern_index)) - best_match = _current_state->tokens[pattern_index]; - } - } - - if (current_input.stream.size() == 0) - { - debug_tokenizer("Reached end of input"); - current_input.at_end = true; - } - - if (best_match->has_transition_to_state()) - { - enter_state(best_match->get_transition_to_state()); - debug_tokenizer("Entered state \'{}\'", best_match->get_transition_to_state()); - } - - std::string_view token_str{current_input.stream.data(), static_cast(longest_match)}; - _current_offset += longest_match; - current_input.stream.remove_prefix(longest_match); - debug_tokenizer("Matched \'{}\' with token \'{}\' (index {})", token_str, best_match->get_pattern(), best_match->get_index()); - - if (_global_action) - _global_action(token_str); - - ValueT value{}; - if (best_match->has_action()) - value = best_match->perform_action(token_str); - - if (!best_match->has_symbol()) - continue; - - return TokenMatchType { - best_match->get_symbol(), - std::move(value), - static_cast(longest_match), - LineSpecialization { - _current_line, - static_cast(_current_offset - longest_match), - static_cast(longest_match) + template + struct TokenMatch { + TokenMatch(const Symbol* sym) + : symbol(sym), value(), match_length(0) { + } + template + TokenMatch(const Symbol* sym, T&& v, std::size_t len, LineSpecialization spec) + : symbol(sym), line_spec(spec), value(std::forward(v)), match_length(len) { + } + TokenMatch(const TokenMatch&) = default; + TokenMatch(TokenMatch&&) noexcept = default; + + TokenMatch& operator=(const TokenMatch&) = default; + TokenMatch& operator=(TokenMatch&&) noexcept = default; + + const Symbol* symbol; + LineSpecialization line_spec; + ValueT value; + std::size_t match_length; + }; + + struct InputStream { + std::unique_ptr content; + re2::StringPiece stream; + bool at_end; + }; + + template + struct StateInfo { + std::string name; + std::unique_ptr re_set; + std::vector*> tokens; + }; + + template + class Tokenizer { + public: + using CallbackType = std::function; + + static constexpr std::string_view DefaultState = "@default"; + + using GrammarType = Grammar; + using StateInfoType = StateInfo; + using SymbolType = Symbol; + using TokenType = Token; + using TokenMatchType = TokenMatch; + + Tokenizer(const GrammarType* grammar) + : _grammar(grammar), _tokens(), _state_info(), _input_stack(), _current_state(nullptr), _global_action() { + _current_line = 1; + _current_offset = 0; + _current_state = get_or_make_state_info(std::string{DefaultState}); + add_token("$", nullptr, std::vector{std::string{DefaultState}}); + } + + void prepare() { + std::string error; + + for (const auto& token : _tokens) { + for (const auto& state : token->get_active_in_states()) { + error.clear(); + auto* state_info = get_or_make_state_info(state); + state_info->re_set->Add(token->get_pattern(), &error); + state_info->tokens.push_back(token.get()); + assert(1); + assert(error.empty() && "Error when compiling token regexp"); + } + } + + for (auto&& [name, info] : _state_info) + info.re_set->Compile(); + } + + const std::vector>& get_tokens() const { + return _tokens; + } + + TokenType* get_end_token() const { + return _tokens[0].get(); + } + + TokenType* add_token(const std::string& pattern, const SymbolType* symbol, const std::vector& states) { + _tokens.push_back(std::make_unique(static_cast(_tokens.size()), pattern, states, symbol)); + return _tokens.back().get(); + } + + void push_input_stream(std::string& stream) { + _input_stack.emplace_back(InputStream{std::make_unique(std::move(stream)), re2::StringPiece{}, false}); + _input_stack.back().stream = re2::StringPiece{_input_stack.back().content->c_str()}; + } + + void pop_input_stream() { + _input_stack.pop_back(); + } + + void clear_input_streams() { + _input_stack.clear(); + } + + void global_action(CallbackType&& global_action) { + _global_action = std::move(global_action); + } + + void _reset_line_offset() { + _current_offset = 0; + } + + std::uint32_t& _get_line_counter() { + return _current_line; + } + + std::uint16_t& _get_line_offset() { + return _current_offset; + } + + std::optional next_token() { + bool repeat = true; + while (repeat) { + // We've emptied the stack so that means return end symbol to parser + if (_input_stack.empty()) { + debug_tokenizer("Input stack empty - returing end of input"); + return _grammar->get_end_of_input_symbol(); + } + + auto& current_input = _input_stack.back(); + if (!current_input.at_end) { + // Matched patterns doesn't have to be sorted (used to be in older re2 versions) but we shouldn't count on that + std::vector matched_patterns; + _current_state->re_set->Match(current_input.stream, &matched_patterns); + + // Haven't matched anything, tokenization failure, we will get into endless loop + if (matched_patterns.empty()) [[unlikely]] { + debug_tokenizer("Nothing matched on the current input"); + return std::nullopt; + } + + re2::StringPiece submatch; + const TokenType* best_match = nullptr; + int longest_match = -1; + for (auto pattern_index : matched_patterns) { + _current_state->tokens[pattern_index]->get_regexp()->Match(current_input.stream, 0, current_input.stream.size(), re2::RE2::Anchor::ANCHOR_START, &submatch, 1); + if (longest_match < static_cast(submatch.size())) { + best_match = _current_state->tokens[pattern_index]; + longest_match = static_cast(submatch.size()); + } + // In case of equal matches, index of tokens chooses which one is it (lower index has higher priority) + else if (longest_match == static_cast(submatch.size())) { + if (!best_match || best_match->get_index() > static_cast(pattern_index)) + best_match = _current_state->tokens[pattern_index]; + } } - }; - } - else { - debug_tokenizer("At the end of input"); - } - - // There is still something on stack but we've reached the end and noone popped it so return end symbol to parser - return _grammar->get_end_of_input_symbol(); - } - - return std::nullopt; - } - - void enter_state(const std::string& state) - { - _current_state = get_state_info(state); - assert(_current_state && "Transition to unknown state in tokenizer"); - } - -private: - StateInfoType* get_or_make_state_info(const std::string& name) - { - auto itr = _state_info.find(name); - if (itr == _state_info.end()) - std::tie(itr, std::ignore) = _state_info.emplace(name, StateInfoType{ - name, - std::make_unique(re2::RE2::DefaultOptions, re2::RE2::Anchor::ANCHOR_START), - std::vector{} - }); - return &itr->second; - } - - StateInfoType* get_state_info(const std::string& name) - { - auto itr = _state_info.find(name); - if (itr == _state_info.end()) - return nullptr; - return &itr->second; - } - - const GrammarType* _grammar; - std::vector> _tokens; - - std::unordered_map _state_info; - std::vector _input_stack; - StateInfoType* _current_state; - CallbackType _global_action; - std::uint32_t _current_line; - std::uint16_t _current_offset; -}; + + if (current_input.stream.size() == 0) { + debug_tokenizer("Reached end of input"); + current_input.at_end = true; + } + + if (best_match->has_transition_to_state()) { + enter_state(best_match->get_transition_to_state()); + debug_tokenizer("Entered state \'{}\'", best_match->get_transition_to_state()); + } + + std::string_view token_str{current_input.stream.data(), static_cast(longest_match)}; + _current_offset += longest_match; + current_input.stream.remove_prefix(longest_match); + debug_tokenizer("Matched \'{}\' with token \'{}\' (index {})", token_str, best_match->get_pattern(), best_match->get_index()); + + if (_global_action) + _global_action(token_str); + + ValueT value{}; + if (best_match->has_action()) + value = best_match->perform_action(token_str); + + if (!best_match->has_symbol()) + continue; + + return TokenMatchType{ + best_match->get_symbol(), + std::move(value), + static_cast(longest_match), + LineSpecialization{ + _current_line, + static_cast(_current_offset - longest_match), + static_cast(longest_match)}}; + } else { + debug_tokenizer("At the end of input"); + } + + // There is still something on stack but we've reached the end and noone popped it so return end symbol to parser + return _grammar->get_end_of_input_symbol(); + } + + return std::nullopt; + } + + void enter_state(const std::string& state) { + _current_state = get_state_info(state); + assert(_current_state && "Transition to unknown state in tokenizer"); + } + + private: + StateInfoType* get_or_make_state_info(const std::string& name) { + auto itr = _state_info.find(name); + if (itr == _state_info.end()) + std::tie(itr, std::ignore) = _state_info.emplace(name, StateInfoType{ + name, + std::make_unique(re2::RE2::DefaultOptions, re2::RE2::Anchor::ANCHOR_START), + std::vector{}}); + return &itr->second; + } + + StateInfoType* get_state_info(const std::string& name) { + auto itr = _state_info.find(name); + if (itr == _state_info.end()) + return nullptr; + return &itr->second; + } + + const GrammarType* _grammar; + std::vector> _tokens; + + std::unordered_map _state_info; + std::vector _input_stack; + StateInfoType* _current_state; + CallbackType _global_action; + std::uint32_t _current_line; + std::uint16_t _current_offset; + }; } // namespace pog diff --git a/src/Pog/Types/StateAndRule.hpp b/src/Pog/Types/StateAndRule.hpp index 3b7a5f36..051fc755 100644 --- a/src/Pog/Types/StateAndRule.hpp +++ b/src/Pog/Types/StateAndRule.hpp @@ -1,38 +1,33 @@ #pragma once -#include "Pog/State.hpp" #include "Pog/Rule.hpp" +#include "Pog/State.hpp" namespace pog { -template -struct StateAndRule -{ - const State* state; - const Rule* rule; + template + struct StateAndRule { + const State* state; + const Rule* rule; - bool operator==(const StateAndRule& rhs) const - { - return state->get_index() == rhs.state->get_index() && rule->get_index() == rhs.rule->get_index(); - } + bool operator==(const StateAndRule& rhs) const { + return state->get_index() == rhs.state->get_index() && rule->get_index() == rhs.rule->get_index(); + } - bool operator!=(const StateAndRule& rhs) const - { - return !(*this == rhs); - } -}; + bool operator!=(const StateAndRule& rhs) const { + return !(*this == rhs); + } + }; } // namespace pog namespace std { -template -struct hash> -{ - std::size_t operator()(const pog::StateAndRule& sr) const - { - return pog::hash_combine(sr.state->get_index(), sr.rule->get_index()); - } -}; + template + struct hash> { + std::size_t operator()(const pog::StateAndRule& sr) const { + return pog::hash_combine(sr.state->get_index(), sr.rule->get_index()); + } + }; -} +} // namespace std diff --git a/src/Pog/Types/StateAndSymbol.hpp b/src/Pog/Types/StateAndSymbol.hpp index 325b6df8..a59b9716 100644 --- a/src/Pog/Types/StateAndSymbol.hpp +++ b/src/Pog/Types/StateAndSymbol.hpp @@ -1,38 +1,33 @@ #pragma once -#include "Pog/Symbol.hpp" #include "Pog/State.hpp" +#include "Pog/Symbol.hpp" namespace pog { -template -struct StateAndSymbol -{ - const State* state; - const Symbol* symbol; + template + struct StateAndSymbol { + const State* state; + const Symbol* symbol; - bool operator==(const StateAndSymbol& rhs) const - { - return state->get_index() == rhs.state->get_index() && symbol->get_index() == rhs.symbol->get_index(); - } + bool operator==(const StateAndSymbol& rhs) const { + return state->get_index() == rhs.state->get_index() && symbol->get_index() == rhs.symbol->get_index(); + } - bool operator!=(const StateAndSymbol& rhs) const - { - return !(*this == rhs); - } -}; + bool operator!=(const StateAndSymbol& rhs) const { + return !(*this == rhs); + } + }; } // namespace pog namespace std { -template -struct hash> -{ - std::size_t operator()(const pog::StateAndSymbol& ss) const - { - return pog::hash_combine(ss.state->get_index(), ss.symbol->get_index()); - } -}; + template + struct hash> { + std::size_t operator()(const pog::StateAndSymbol& ss) const { + return pog::hash_combine(ss.state->get_index(), ss.symbol->get_index()); + } + }; -} +} // namespace std diff --git a/src/Pog/Utils.hpp b/src/Pog/Utils.hpp index f637ba17..a6581a88 100644 --- a/src/Pog/Utils.hpp +++ b/src/Pog/Utils.hpp @@ -4,72 +4,70 @@ #include #include #include -#include #include +#include namespace pog { -template -OutputIterator transform_if(InputIterator first1, InputIterator last1, OutputIterator result, Pred pred, UnaryOperator op) -{ - while (first1 != last1) - { - if (pred(*first1)) { - *result = op(*first1); - ++result; - } - ++first1; - } - return result; -} + template + OutputIterator transform_if(InputIterator first1, InputIterator last1, OutputIterator result, Pred pred, UnaryOperator op) { + while (first1 != last1) { + if (pred(*first1)) { + *result = op(*first1); + ++result; + } + ++first1; + } + return result; + } -template -T accumulate_if(InputIterator first, InputIterator last, T init, Pred pred, BinaryOperation op) -{ - for (; first != last; ++first) - { - if (pred(*first)) - init = op(std::move(init), *first); - } - return init; -} + template + T accumulate_if(InputIterator first, InputIterator last, T init, Pred pred, BinaryOperation op) { + for (; first != last; ++first) { + if (pred(*first)) + init = op(std::move(init), *first); + } + return init; + } -inline void hash_combine(std::size_t&) { } + inline void hash_combine(std::size_t&) { + } -template -inline void hash_combine(std::size_t& seed, const T& v, const Rest&... rest) { - seed ^= std::hash{}(v) + 0x9e3779b9 + (seed<<6) + (seed>>2); - hash_combine(seed, rest...); -} + template + inline void hash_combine(std::size_t& seed, const T& v, const Rest&... rest) { + seed ^= std::hash{}(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2); + hash_combine(seed, rest...); + } -template -inline std::size_t hash_combine(const Rest&... rest) -{ - std::size_t seed = 0; - hash_combine(seed, rest...); - return seed; -} + template + inline std::size_t hash_combine(const Rest&... rest) { + std::size_t seed = 0; + hash_combine(seed, rest...); + return seed; + } -template struct overloaded : Ts... { using Ts::operator()...; }; -template overloaded(Ts...) -> overloaded; + template + struct overloaded : Ts... { + using Ts::operator()...; + }; + template + overloaded(Ts...) -> overloaded; -template -auto visit_with(Variant& v, Fs&&... fs) -{ - return std::visit(overloaded{ - std::forward(fs)... - }, v); -} + template + auto visit_with(Variant& v, Fs&&... fs) { + return std::visit(overloaded{ + std::forward(fs)...}, + v); + } -template -inline std::string current_time(FormatT&& format) -{ - auto now = std::time(nullptr); - auto tm = std::localtime(&now); + template + inline std::string current_time(FormatT&& format) { + auto now = std::time(nullptr); + auto tm = std::localtime(&now); - std::ostringstream ss; - ss << std::put_time(tm, std::forward(format)); - return ss.str(); -} + std::ostringstream ss; + ss << std::put_time(tm, std::forward(format)); + return ss.str(); + } } // namespace pog diff --git a/tests/Integration/AssemblerCore/AssemblerFail.cpp b/tests/Integration/AssemblerCore/AssemblerFail.cpp index 665ff840..1427f95d 100644 --- a/tests/Integration/AssemblerCore/AssemblerFail.cpp +++ b/tests/Integration/AssemblerCore/AssemblerFail.cpp @@ -3,79 +3,70 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(ASSEMBLER, ASM_INVALID_INSTRUCTION_TWO_OPERANDS) { std::string data = "miv xlll0, xlll1;"; HCPU_ASSERT_EXIT({ auto state(compiler.TransformToIR(data)); - auto binary = compiler.TransformToBinary(state); - }, ::testing::ExitedWithCode(1), ".*"); + auto binary = compiler.TransformToBinary(state); }, ::testing::ExitedWithCode(1), ".*"); } TEST_F(ASSEMBLER, ASM_INVALID_INSTRUCTION_ONE_OPERAND) { std::string data = "miv xlll0;"; HCPU_ASSERT_EXIT({ auto state(compiler.TransformToIR(data)); - auto binary = compiler.TransformToBinary(state); - }, ::testing::ExitedWithCode(1), ".*"); + auto binary = compiler.TransformToBinary(state); }, ::testing::ExitedWithCode(1), ".*"); } TEST_F(ASSEMBLER, ASM_INVALID_INSTRUCTION_NO_OPERANDS) { std::string data = "miv;"; HCPU_ASSERT_EXIT({ auto state(compiler.TransformToIR(data)); - auto binary = compiler.TransformToBinary(state); - }, ::testing::ExitedWithCode(1), ".*"); + auto binary = compiler.TransformToBinary(state); }, ::testing::ExitedWithCode(1), ".*"); } TEST_F(ASSEMBLER, ASM_CANT_USE_RESERVED_IDENT_AS_LABEL) { std::string data = "mov:"; HCPU_ASSERT_EXIT({ auto state(compiler.TransformToIR(data)); - auto binary = compiler.TransformToBinary(state); - }, ::testing::ExitedWithCode(1), ".*"); + auto binary = compiler.TransformToBinary(state); }, ::testing::ExitedWithCode(1), ".*"); } TEST_F(ASSEMBLER, ASM_LABEL_REDEFINITION) { std::string data = "foo:\nfoo:"; HCPU_ASSERT_EXIT({ auto state(compiler.TransformToIR(data)); - auto binary = compiler.TransformToBinary(state); - }, ::testing::ExitedWithCode(1), ".*"); + auto binary = compiler.TransformToBinary(state); }, ::testing::ExitedWithCode(1), ".*"); } TEST_F(ASSEMBLER, ASM_ENTRY_LABEL_REDEFINITION) { std::string data = "foo:\n.attr(entry) foo:"; HCPU_ASSERT_EXIT({ auto state(compiler.TransformToIR(data)); - auto binary = compiler.TransformToBinary(state); - }, ::testing::ExitedWithCode(1), ".*"); + auto binary = compiler.TransformToBinary(state); }, ::testing::ExitedWithCode(1), ".*"); } TEST_F(ASSEMBLER, RAWVALUEb8_CANT_USE_LABEL) { std::string data = ".b8 foo;"; HCPU_ASSERT_EXIT({ auto state(compiler.TransformToIR(data)); - auto binary = compiler.TransformToBinary(state); - }, ::testing::ExitedWithCode(1), ".*"); + auto binary = compiler.TransformToBinary(state); }, ::testing::ExitedWithCode(1), ".*"); } TEST_F(ASSEMBLER, RAWVALUEb16_CANT_USE_LABEL) { std::string data = ".b16 foo;"; HCPU_ASSERT_EXIT({ auto state(compiler.TransformToIR(data)); - auto binary = compiler.TransformToBinary(state); - }, ::testing::ExitedWithCode(1), ".*"); + auto binary = compiler.TransformToBinary(state); }, ::testing::ExitedWithCode(1), ".*"); } TEST_F(ASSEMBLER, RAWVALUEb32_CANT_USE_LABEL) { std::string data = ".b32 foo;"; HCPU_ASSERT_EXIT({ auto state(compiler.TransformToIR(data)); - auto binary = compiler.TransformToBinary(state); - }, ::testing::ExitedWithCode(1), ".*"); + auto binary = compiler.TransformToBinary(state); }, ::testing::ExitedWithCode(1), ".*"); } diff --git a/tests/Integration/AssemblerCore/AssemblerSuccess.cpp b/tests/Integration/AssemblerCore/AssemblerSuccess.cpp index 049cf5cc..88d832be 100644 --- a/tests/Integration/AssemblerCore/AssemblerSuccess.cpp +++ b/tests/Integration/AssemblerCore/AssemblerSuccess.cpp @@ -1,6 +1,6 @@ -#include -#include #include +#include +#include #include #include @@ -22,7 +22,7 @@ TEST_F(ASSEMBLER, ASM_R_R_b8) { std::memcpy(®2, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_R); @@ -48,7 +48,7 @@ TEST_F(ASSEMBLER, ASM_R_R_b16) { std::memcpy(®2, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_R); @@ -74,7 +74,7 @@ TEST_F(ASSEMBLER, ASM_R_R_b32) { std::memcpy(®2, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_R); @@ -100,7 +100,7 @@ TEST_F(ASSEMBLER, ASM_R_R_b64) { std::memcpy(®2, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_R); @@ -126,7 +126,7 @@ TEST_F(ASSEMBLER, ASM_R_RM_b8) { std::memcpy(®2, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_RM); @@ -152,7 +152,7 @@ TEST_F(ASSEMBLER, ASM_R_RM_b16) { std::memcpy(®2, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_RM); @@ -178,7 +178,7 @@ TEST_F(ASSEMBLER, ASM_R_RM_b32) { std::memcpy(®2, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_RM); @@ -204,7 +204,7 @@ TEST_F(ASSEMBLER, ASM_R_RM_b64) { std::memcpy(®2, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_RM); @@ -230,7 +230,7 @@ TEST_F(ASSEMBLER, ASM_R_M_b8) { std::memcpy(&addr, binary.binary + 4, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_M); @@ -256,7 +256,7 @@ TEST_F(ASSEMBLER, ASM_R_M_b16) { std::memcpy(&addr, binary.binary + 4, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_M); @@ -282,7 +282,7 @@ TEST_F(ASSEMBLER, ASM_R_M_b32) { std::memcpy(&addr, binary.binary + 4, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_M); @@ -308,7 +308,7 @@ TEST_F(ASSEMBLER, ASM_R_M_b64) { std::memcpy(&addr, binary.binary + 4, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_M); @@ -334,7 +334,7 @@ TEST_F(ASSEMBLER, ASM_R_IMM_b8) { std::memcpy(&num, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); @@ -360,7 +360,7 @@ TEST_F(ASSEMBLER, ASM_R_IMM_b16) { std::memcpy(&num, binary.binary + 4, sizeof(std::uint16_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); @@ -386,7 +386,7 @@ TEST_F(ASSEMBLER, ASM_R_IMM_b32) { std::memcpy(&num, binary.binary + 4, sizeof(std::uint32_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); @@ -412,7 +412,7 @@ TEST_F(ASSEMBLER, ASM_R_IMM_b64) { std::memcpy(&num, binary.binary + 4, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); @@ -438,7 +438,7 @@ TEST_F(ASSEMBLER, ASM_RM_R_b8) { std::memcpy(®2, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_R); @@ -464,7 +464,7 @@ TEST_F(ASSEMBLER, ASM_RM_R_b16) { std::memcpy(®2, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_R); @@ -490,7 +490,7 @@ TEST_F(ASSEMBLER, ASM_RM_R_b32) { std::memcpy(®2, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_R); @@ -516,7 +516,7 @@ TEST_F(ASSEMBLER, ASM_RM_R_b64) { std::memcpy(®2, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_R); @@ -542,7 +542,7 @@ TEST_F(ASSEMBLER, ASM_RM_M_b8) { std::memcpy(&addr, binary.binary + 4, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_M); @@ -568,7 +568,7 @@ TEST_F(ASSEMBLER, ASM_RM_M_b16) { std::memcpy(&addr, binary.binary + 4, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_M); @@ -594,7 +594,7 @@ TEST_F(ASSEMBLER, ASM_RM_M_b32) { std::memcpy(&addr, binary.binary + 4, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_M); @@ -620,7 +620,7 @@ TEST_F(ASSEMBLER, ASM_RM_M_b64) { std::memcpy(&addr, binary.binary + 4, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_M); @@ -646,7 +646,7 @@ TEST_F(ASSEMBLER, ASM_RM_IMM_b8) { std::memcpy(&num, binary.binary + 4, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_IMM); @@ -672,7 +672,7 @@ TEST_F(ASSEMBLER, ASM_RM_IMM_b16) { std::memcpy(&num, binary.binary + 4, sizeof(std::uint16_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_IMM); @@ -698,7 +698,7 @@ TEST_F(ASSEMBLER, ASM_RM_IMM_b32) { std::memcpy(&num, binary.binary + 4, sizeof(std::uint32_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_IMM); @@ -724,7 +724,7 @@ TEST_F(ASSEMBLER, ASM_RM_IMM_b64) { std::memcpy(&num, binary.binary + 4, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_IMM); @@ -747,10 +747,10 @@ TEST_F(ASSEMBLER, ASM_M_R_b8) { std::memcpy(&opcode, binary.binary, sizeof(std::uint16_t)); std::memcpy(&flags, binary.binary + 2, sizeof(std::uint8_t)); std::memcpy(&addr, binary.binary + 3, sizeof(std::uint64_t)); - std::memcpy(®, binary.binary + 11, sizeof(std::uint8_t)); + std::memcpy(®, binary.binary + 11, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::M_R); @@ -773,10 +773,10 @@ TEST_F(ASSEMBLER, ASM_M_R_b16) { std::memcpy(&opcode, binary.binary, sizeof(std::uint16_t)); std::memcpy(&flags, binary.binary + 2, sizeof(std::uint8_t)); std::memcpy(&addr, binary.binary + 3, sizeof(std::uint64_t)); - std::memcpy(®, binary.binary + 11, sizeof(std::uint8_t)); + std::memcpy(®, binary.binary + 11, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::M_R); @@ -799,10 +799,10 @@ TEST_F(ASSEMBLER, ASM_M_R_b32) { std::memcpy(&opcode, binary.binary, sizeof(std::uint16_t)); std::memcpy(&flags, binary.binary + 2, sizeof(std::uint8_t)); std::memcpy(&addr, binary.binary + 3, sizeof(std::uint64_t)); - std::memcpy(®, binary.binary + 11, sizeof(std::uint8_t)); + std::memcpy(®, binary.binary + 11, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::M_R); @@ -825,10 +825,10 @@ TEST_F(ASSEMBLER, ASM_M_R_b64) { std::memcpy(&opcode, binary.binary, sizeof(std::uint16_t)); std::memcpy(&flags, binary.binary + 2, sizeof(std::uint8_t)); std::memcpy(&addr, binary.binary + 3, sizeof(std::uint64_t)); - std::memcpy(®, binary.binary + 11, sizeof(std::uint8_t)); + std::memcpy(®, binary.binary + 11, sizeof(std::uint8_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::M_R); @@ -852,7 +852,7 @@ TEST_F(ASSEMBLER, ASM_IMM_b64) { std::memcpy(&addr, binary.binary + 3, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::CALL); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::IMM); @@ -877,7 +877,7 @@ TEST_F(ASSEMBLER, ASM_REFERENCE_LABEL) { std::memcpy(&num, binary.binary + 9, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); @@ -903,7 +903,7 @@ TEST_F(ASSEMBLER, ASM_REFERENCE_ENTRY_LABEL) { std::memcpy(&num, binary.binary + 9, sizeof(std::uint64_t)); EXPECT_EQ(static_cast(opcode), HyperCPU::Opcode::MOV); - + EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); diff --git a/tests/Integration/AssemblerCore/FullAssembler.cpp b/tests/Integration/AssemblerCore/FullAssembler.cpp index 5bc8b438..538df6a5 100644 --- a/tests/Integration/AssemblerCore/FullAssembler.cpp +++ b/tests/Integration/AssemblerCore/FullAssembler.cpp @@ -1,7 +1,7 @@ -#include #include "Main/Main.hpp" #include "Misc/bit_cast.hpp" #include "pch.hpp" +#include TEST_F(FULL_ASSEMBLER, MULTUPLE_INSTRUCTIONS) { std::string data = "_start:\n\tmov x0, 0u1;\n\tmov x1, 0u2;\n\tadd x0, x1;"; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp b/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp index 7d514a5b..58672e59 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; static constexpr std::uint8_t BYTE_SUM = BYTE_DATA1 + BYTE_DATA2 + 1; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp b/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp index a32356b9..dffe8859 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; static constexpr std::uint8_t BYTE_SUM = BYTE_DATA1 + BYTE_DATA2; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_AND.cpp b/tests/Integration/EmulatorCore/CPU/CPU_AND.cpp index f43802e5..90337e53 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_AND.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_AND.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; static constexpr std::uint8_t BYTE_SUM = BYTE_DATA1 & BYTE_DATA2; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_ANDN.cpp b/tests/Integration/EmulatorCore/CPU/CPU_ANDN.cpp index 7a8c538e..300e9207 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ANDN.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ANDN.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; static constexpr std::uint8_t BYTE_SUM = ~BYTE_DATA1 & BYTE_DATA2; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_BSWAP.cpp b/tests/Integration/EmulatorCore/CPU/CPU_BSWAP.cpp index 556581a9..fca3ebaf 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_BSWAP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_BSWAP.cpp @@ -1,12 +1,11 @@ #include -#include #include +#include #include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x12; static constexpr std::uint8_t BYTE_RESULT = BYTE_DATA1; static constexpr std::uint16_t WORD_DATA1 = 0x1234; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp index 32b4eef2..58c3f9d7 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_CALL_R) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALL); cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CALLE.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CALLE.cpp index ba8194a8..a6b6da3e 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALLE.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALLE.cpp @@ -4,65 +4,65 @@ #include TEST_F(CPU_TEST, INSTR_CALLE_R_TRUE) { - cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLE); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); - cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); - *cpu.xbp = 512; - *cpu.xsp = *cpu.xbp; - *cpu.x0 = 1536; - cpu.zrf = 1; + cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLE); + cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); + cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); + *cpu.xbp = 512; + *cpu.xsp = *cpu.xbp; + *cpu.x0 = 1536; + cpu.zrf = 1; - cpu.Run(); + cpu.Run(); - ASSERT_EQ(*cpu.xip, 1539); + ASSERT_EQ(*cpu.xip, 1539); } TEST_F(CPU_TEST, INSTR_CALLE_R_FALSE) { - cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLE); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); - cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); - cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); - cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); - *cpu.xbp = 512; - *cpu.xsp = *cpu.xbp; - *cpu.x0 = 1536; + cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLE); + cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); + cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); + cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); + cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); + *cpu.xbp = 512; + *cpu.xsp = *cpu.xbp; + *cpu.x0 = 1536; - cpu.Run(); + cpu.Run(); - ASSERT_EQ(*cpu.xip, 7); + ASSERT_EQ(*cpu.xip, 7); } TEST_F(CPU_TEST, INSTR_CALLE_IMM_TRUE) { - cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLE); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); - cpu.mem_controller->Load64(*cpu.xip + 3, 1536); - cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); - cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); - *cpu.xbp = 512; - *cpu.xsp = *cpu.xbp; - cpu.zrf = 1; + cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLE); + cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load64(*cpu.xip + 3, 1536); + cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); + cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); + *cpu.xbp = 512; + *cpu.xsp = *cpu.xbp; + cpu.zrf = 1; - cpu.Run(); + cpu.Run(); - ASSERT_EQ(*cpu.xip, 1539); + ASSERT_EQ(*cpu.xip, 1539); } TEST_F(CPU_TEST, INSTR_CALLE_IMM_FALSE) { - cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLE); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); - cpu.mem_controller->Load64(*cpu.xip + 3, 1536); - cpu.mem_controller->Load16(*cpu.xip + 11, HyperCPU::Opcode::HALT); - cpu.mem_controller->Load8(*cpu.xip + 13, HyperCPU::OperandTypes::NONE); - cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); - cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); - *cpu.xbp = 512; - *cpu.xsp = *cpu.xbp; + cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLE); + cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load64(*cpu.xip + 3, 1536); + cpu.mem_controller->Load16(*cpu.xip + 11, HyperCPU::Opcode::HALT); + cpu.mem_controller->Load8(*cpu.xip + 13, HyperCPU::OperandTypes::NONE); + cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); + cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); + *cpu.xbp = 512; + *cpu.xsp = *cpu.xbp; - cpu.Run(); + cpu.Run(); - ASSERT_EQ(*cpu.xip, 14); + ASSERT_EQ(*cpu.xip, 14); } \ No newline at end of file diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CALLGR.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CALLGR.cpp index 63e746d8..be3a3890 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALLGR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALLGR.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_CALLGR_R_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLGR); cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); @@ -14,7 +13,6 @@ TEST_F(CPU_TEST, INSTR_CALLGR_R_TRUE) { *cpu.xsp = *cpu.xbp; *cpu.x0 = 1536; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -33,7 +31,6 @@ TEST_F(CPU_TEST, INSTR_CALLGR_R_FALSE) { *cpu.x0 = 1536; cpu.zrf = 1; - cpu.Run(); ASSERT_EQ(*cpu.xip, 7); @@ -48,7 +45,6 @@ TEST_F(CPU_TEST, INSTR_CALLGR_IMM_TRUE) { *cpu.xbp = 512; *cpu.xsp = *cpu.xbp; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -66,7 +62,6 @@ TEST_F(CPU_TEST, INSTR_CALLGR_IMM_FALSE) { *cpu.xsp = *cpu.xbp; cpu.zrf = 1; - cpu.Run(); ASSERT_EQ(*cpu.xip, 14); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CALLL.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CALLL.cpp index 54ff3b43..c3b2c9e2 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALLL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALLL.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_CALLL_R_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLL); cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); @@ -15,7 +14,6 @@ TEST_F(CPU_TEST, INSTR_CALLL_R_TRUE) { *cpu.x0 = 1536; cpu.crf = 1; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -33,7 +31,6 @@ TEST_F(CPU_TEST, INSTR_CALLL_R_FALSE) { *cpu.xsp = *cpu.xbp; *cpu.x0 = 1536; - cpu.Run(); ASSERT_EQ(*cpu.xip, 7); @@ -49,7 +46,6 @@ TEST_F(CPU_TEST, INSTR_CALLL_IMM_TRUE) { *cpu.xsp = *cpu.xbp; cpu.crf = 1; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -66,7 +62,6 @@ TEST_F(CPU_TEST, INSTR_CALLL_IMM_FALSE) { *cpu.xbp = 512; *cpu.xsp = *cpu.xbp; - cpu.Run(); ASSERT_EQ(*cpu.xip, 14); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CCRF.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CCRF.cpp index 300409c9..8c3d36d4 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CCRF.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CCRF.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_CCRF_SET) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CCRF); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CMP.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CMP.cpp index 27289628..3270560b 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CMP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CMP.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_CMP_R_R_b8_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); @@ -40,7 +39,7 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b8_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = 0x1F; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_COVF.cpp b/tests/Integration/EmulatorCore/CPU/CPU_COVF.cpp index 5fa1e63c..022bcb70 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_COVF.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_COVF.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_COVF_SET) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::COVF); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CUDF.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CUDF.cpp index d8627354..53b67e89 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CUDF.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CUDF.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_CUDF_SET) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CUDF); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp b/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp index 49c3e030..18ba0d7c 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_RESULT = BYTE_DATA1 - 1; static constexpr std::uint16_t WORD_DATA1 = 0x5555; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp b/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp index 42360aa9..851ab938 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DIVIDER = 0x5; static constexpr std::uint8_t BYTE_RESULT = BYTE_DATA1 / BYTE_DIVIDER; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_HID.cpp b/tests/Integration/EmulatorCore/CPU/CPU_HID.cpp index d4aafeaa..2be0163e 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_HID.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_HID.cpp @@ -1,10 +1,9 @@ -#include #include +#include #include #include - TEST_F(CPU_TEST, INSTR_HID_0) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::HID); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp b/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp index 251604a5..f3da00e5 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_RESULT = BYTE_DATA1 + 1; static constexpr std::uint16_t WORD_DATA1 = 0x5555; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_INTR.cpp b/tests/Integration/EmulatorCore/CPU/CPU_INTR.cpp index 3405dd32..5ff0a59c 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_INTR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_INTR.cpp @@ -1,15 +1,14 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_INTR_R_b64) { // Setup stack *cpu.xbp = 512; *cpu.xsp = 512; // Setup IVT - cpu.mem_controller->Load64(2048, 1536); // First IVT entry + cpu.mem_controller->Load64(2048, 1536); // First IVT entry cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); // Code for interrupt handler cpu.mem_controller->Load16(1538, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::LOIVT); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_IRET.cpp b/tests/Integration/EmulatorCore/CPU/CPU_IRET.cpp index c8d0fabc..6dbbc931 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_IRET.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_IRET.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_IRET_NONE) { *cpu.xbp = 512; *cpu.xsp = 512; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_JME.cpp b/tests/Integration/EmulatorCore/CPU/CPU_JME.cpp index aaa25822..a4a6001c 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_JME.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_JME.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_JME_R_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JME); cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); @@ -13,7 +12,6 @@ TEST_F(CPU_TEST, INSTR_JME_R_TRUE) { *cpu.x0 = 1536; cpu.zrf = 1; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -29,7 +27,6 @@ TEST_F(CPU_TEST, INSTR_JME_R_FALSE) { cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1536; - cpu.Run(); ASSERT_EQ(*cpu.xip, 7); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_JMGR.cpp b/tests/Integration/EmulatorCore/CPU/CPU_JMGR.cpp index 776a15b4..c328bb54 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_JMGR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_JMGR.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_JMGR_R_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JMGR); cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); @@ -12,7 +11,6 @@ TEST_F(CPU_TEST, INSTR_JMGR_R_TRUE) { cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1536; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -29,7 +27,6 @@ TEST_F(CPU_TEST, INSTR_JMGR_R_FALSE) { *cpu.x0 = 1536; cpu.zrf = 1; - cpu.Run(); ASSERT_EQ(*cpu.xip, 7); @@ -42,7 +39,6 @@ TEST_F(CPU_TEST, INSTR_JMGR_IMM_TRUE) { cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -58,7 +54,6 @@ TEST_F(CPU_TEST, INSTR_JMGR_IMM_FALSE) { cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); cpu.zrf = 1; - cpu.Run(); ASSERT_EQ(*cpu.xip, 14); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_JML.cpp b/tests/Integration/EmulatorCore/CPU/CPU_JML.cpp index 290b8bf2..2c2869af 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_JML.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_JML.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_JML_R_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JML); cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); @@ -13,7 +12,6 @@ TEST_F(CPU_TEST, INSTR_JML_R_TRUE) { *cpu.x0 = 1536; cpu.crf = 1; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -29,7 +27,6 @@ TEST_F(CPU_TEST, INSTR_JML_R_FALSE) { cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1536; - cpu.Run(); ASSERT_EQ(*cpu.xip, 7); @@ -43,7 +40,6 @@ TEST_F(CPU_TEST, INSTR_JML_IMM_TRUE) { cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); cpu.crf = 1; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -58,7 +54,6 @@ TEST_F(CPU_TEST, INSTR_JML_IMM_FALSE) { cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); - cpu.Run(); ASSERT_EQ(*cpu.xip, 14); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_JMP.cpp b/tests/Integration/EmulatorCore/CPU/CPU_JMP.cpp index 28637e6f..20ad92b9 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_JMP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_JMP.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_JMP_R) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JMP); cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp b/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp index 49a45896..d0917422 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(CPU_TEST, INSTR_LOIVT_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::LOIVT); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp b/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp index d948bf8e..6bf3ea92 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA = 0x55; static constexpr std::uint16_t WORD_DATA = 0x5555; static constexpr std::uint32_t DWORD_DATA = 0x55555555; @@ -347,7 +346,7 @@ TEST_F(CPU_TEST, INSTR_MOV_RM_M_b64) { cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); - cpu.mem_controller->Load64(1536, QWORD_DATA); + cpu.mem_controller->Load64(1536, QWORD_DATA); *cpu.x0 = 1024; cpu.Run(); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_MUL.cpp b/tests/Integration/EmulatorCore/CPU/CPU_MUL.cpp index a65bc03a..3b286cf7 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_MUL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_MUL.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x2; static constexpr std::uint8_t BYTE_DATA2 = 0x60; static constexpr std::uint8_t BYTE_SUM = BYTE_DATA1 * BYTE_DATA2; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_OR.cpp b/tests/Integration/EmulatorCore/CPU/CPU_OR.cpp index d0657921..5cc1a2d9 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_OR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_OR.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; static constexpr std::uint8_t BYTE_SUM = BYTE_DATA1 | BYTE_DATA2; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp b/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp index 8e3d612a..03ca14c8 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp @@ -1,8 +1,8 @@ #include "Core/CPU/Instructions/Registers.hpp" -#include -#include #include "pch.hpp" #include +#include +#include // TODO: fix include order // TODO: fix constexpr naming diff --git a/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp b/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp index 9ed83142..ffb4f0cd 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp @@ -1,8 +1,8 @@ #include "Core/CPU/Instructions/Registers.hpp" -#include -#include #include "pch.hpp" #include +#include +#include // TODO: fix include order // TODO: fix constexpr naming diff --git a/tests/Integration/EmulatorCore/CPU/CPU_READ.cpp b/tests/Integration/EmulatorCore/CPU/CPU_READ.cpp index 92159fb7..ae0fc62a 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_READ.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_READ.cpp @@ -1,6 +1,6 @@ #include "Core/CPU/Instructions/Flags.hpp" -#include #include "pch.hpp" +#include TEST_F(CPU_TEST, INSTR_READ) { cpu.read_io_handlers[1] = []() -> std::uint8_t { diff --git a/tests/Integration/EmulatorCore/CPU/CPU_SHFL.cpp b/tests/Integration/EmulatorCore/CPU/CPU_SHFL.cpp index 7b5d500c..9e2dbe42 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_SHFL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_SHFL.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x4; static constexpr std::uint8_t BYTE_SUM = static_cast(BYTE_DATA1 << BYTE_DATA2); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_SHFR.cpp b/tests/Integration/EmulatorCore/CPU/CPU_SHFR.cpp index a32049aa..cea64726 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_SHFR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_SHFR.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x4; static constexpr std::uint8_t BYTE_SUM = static_cast(BYTE_DATA1 >> BYTE_DATA2); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_SUB.cpp b/tests/Integration/EmulatorCore/CPU/CPU_SUB.cpp index 43670814..bfb178b2 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_SUB.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_SUB.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - static constexpr std::uint8_t BYTE_DATA1 = 0x60; static constexpr std::uint8_t BYTE_DATA2 = 0x55; static constexpr std::uint8_t BYTE_RESULT = BYTE_DATA1 - BYTE_DATA2; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_WRITE.cpp b/tests/Integration/EmulatorCore/CPU/CPU_WRITE.cpp index b7a4ba2a..8679dbc4 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_WRITE.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_WRITE.cpp @@ -1,7 +1,7 @@ #include "Core/CPU/Instructions/Registers.hpp" +#include "pch.hpp" #include #include -#include "pch.hpp" TEST_F(CPU_TEST, INSTR_WRITE) { std::uint8_t t = 0; diff --git a/tests/Integration/EmulatorCore/CPU/OperandsEvaluation.cpp b/tests/Integration/EmulatorCore/CPU/OperandsEvaluation.cpp index 8c69565f..3491436d 100644 --- a/tests/Integration/EmulatorCore/CPU/OperandsEvaluation.cpp +++ b/tests/Integration/EmulatorCore/CPU/OperandsEvaluation.cpp @@ -3,11 +3,10 @@ #include - TEST_F(OPERAND_EVAL_TEST, PROPER_REGISTERS_EVALUATION) { HyperCPU::OperandContainer arg = 0; HyperCPU::Registers reg; - + reg = HyperCPU::Registers::X0; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.x0); @@ -171,8 +170,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_R_EVALUATION) { arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg2)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::R_R, - HyperCPU::Mode::b8, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::R_R, + HyperCPU::Mode::b8, arg1, arg2); ASSERT_EQ(result.first.ptr(), cpu.x0); ASSERT_EQ(result.second.ptr(), cpu.x1); @@ -184,8 +183,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_RM_EVALUATION) { arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg2)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::R_RM, - HyperCPU::Mode::b8, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::R_RM, + HyperCPU::Mode::b8, arg1, arg2); ASSERT_EQ(result.first.ptr(), cpu.x0); ASSERT_EQ(result.second.ptr(), cpu.x1); @@ -197,8 +196,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_RM_R_EVALUATION) { arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg2)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::RM_R, - HyperCPU::Mode::b8, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::RM_R, + HyperCPU::Mode::b8, arg1, arg2); ASSERT_EQ(result.first.ptr(), cpu.x0); ASSERT_EQ(result.second.ptr(), cpu.x1); @@ -209,8 +208,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_RM_M_EVALUATION) { HyperCPU::Registers reg1 = HyperCPU::Registers::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::RM_M, - HyperCPU::Mode::b8, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::RM_M, + HyperCPU::Mode::b8, arg1, arg2); ASSERT_EQ(result.first.ptr(), cpu.x0); ASSERT_EQ(result.second.ref(), arg2.ref()); @@ -221,8 +220,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_M_EVALUATION) { HyperCPU::Registers reg1 = HyperCPU::Registers::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::R_M, - HyperCPU::Mode::b8, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::R_M, + HyperCPU::Mode::b8, arg1, arg2); ASSERT_EQ(result.first.ptr(), cpu.x0); ASSERT_EQ(result.second.ref(), arg2.ref()); @@ -235,8 +234,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_RM_IMM_B8_EVALUATION) { arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::RM_IMM, - HyperCPU::Mode::b8, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::RM_IMM, + HyperCPU::Mode::b8, arg1, arg2); std::memcpy(&imm, &result.second, sizeof(std::uint8_t)); ASSERT_EQ(result.first.ptr(), cpu.x0); @@ -249,8 +248,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_RM_IMM_B16_EVALUATION) { HyperCPU::Registers reg1 = HyperCPU::Registers::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::RM_IMM, - HyperCPU::Mode::b16, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::RM_IMM, + HyperCPU::Mode::b16, arg1, arg2); std::memcpy(&imm, &result.second, sizeof(std::uint16_t)); ASSERT_EQ(result.first.ptr(), cpu.x0); @@ -264,8 +263,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_RM_IMM_B32_EVALUATION) { arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::RM_IMM, - HyperCPU::Mode::b32, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::RM_IMM, + HyperCPU::Mode::b32, arg1, arg2); std::memcpy(&imm, &result.second, sizeof(std::uint32_t)); ASSERT_EQ(result.first.ptr(), cpu.x0); @@ -279,8 +278,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_RM_IMM_B64_EVALUATION) { arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::RM_IMM, - HyperCPU::Mode::b64, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::RM_IMM, + HyperCPU::Mode::b64, arg1, arg2); std::memcpy(&imm, &result.second, sizeof(std::uint64_t)); ASSERT_EQ(result.first.ptr(), cpu.x0); @@ -294,8 +293,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_IMM_B8_EVALUATION) { arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::R_IMM, - HyperCPU::Mode::b8, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::R_IMM, + HyperCPU::Mode::b8, arg1, arg2); std::memcpy(&imm, &result.second, sizeof(std::uint8_t)); ASSERT_EQ(result.first.ptr(), cpu.x0); @@ -309,8 +308,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_IMM_B16_EVALUATION) { arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::R_IMM, - HyperCPU::Mode::b16, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::R_IMM, + HyperCPU::Mode::b16, arg1, arg2); std::memcpy(&imm, &result.second, sizeof(std::uint16_t)); ASSERT_EQ(result.first.ptr(), cpu.x0); @@ -324,8 +323,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_IMM_B32_EVALUATION) { arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::R_IMM, - HyperCPU::Mode::b32, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::R_IMM, + HyperCPU::Mode::b32, arg1, arg2); std::memcpy(&imm, &result.second, sizeof(std::uint32_t)); ASSERT_EQ(result.first.ptr(), cpu.x0); @@ -339,8 +338,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_IMM_B64_EVALUATION) { arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::R_IMM, - HyperCPU::Mode::b64, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::R_IMM, + HyperCPU::Mode::b64, arg1, arg2); std::memcpy(&imm, &result.second, sizeof(std::uint64_t)); ASSERT_EQ(result.first.ptr(), cpu.x0); @@ -352,8 +351,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_M_R_EVALUATION) { HyperCPU::Registers reg2 = HyperCPU::Registers::X0; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg2)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::M_R, - HyperCPU::Mode::b8, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::M_R, + HyperCPU::Mode::b8, arg1, arg2); ASSERT_EQ(result.first.ref(), arg1.ref()); ASSERT_EQ(result.second.ptr(), cpu.x0); @@ -364,8 +363,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_EVALUATION) { HyperCPU::Registers reg1 = HyperCPU::Registers::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; - result = cpu.GetOperands(HyperCPU::OperandTypes::R, - HyperCPU::Mode::b8, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::R, + HyperCPU::Mode::b8, arg1, arg2); ASSERT_EQ(result.first.ptr(), cpu.x0); ASSERT_EQ(result.second.ptr(), nullptr); @@ -374,8 +373,8 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_M_EVALUATION) { HyperCPU::OperandContainer arg1 = HyperCPU::OperandContainer{1024}, arg2; - result = cpu.GetOperands(HyperCPU::OperandTypes::M, - HyperCPU::Mode::b8, arg1, arg2); + result = cpu.GetOperands(HyperCPU::OperandTypes::M, + HyperCPU::Mode::b8, arg1, arg2); ASSERT_EQ(result.first.ref(), arg1.ref()); ASSERT_EQ(result.second.ptr(), nullptr); @@ -385,7 +384,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_NONE_EVALUATION) { HyperCPU::OperandContainer arg1, arg2; result = cpu.GetOperands(HyperCPU::OperandTypes::NONE, - HyperCPU::Mode::b8, arg1, arg2); + HyperCPU::Mode::b8, arg1, arg2); ASSERT_EQ(result.first.ptr(), nullptr); ASSERT_EQ(result.second.ptr(), nullptr); diff --git a/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp b/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp index e791b13e..c5480ca0 100644 --- a/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp +++ b/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp @@ -1,9 +1,8 @@ -#include #include +#include #include - TEST_F(EXCEPTION_TEST, CPU_EXCEPTION_IO) { cpu.mem_controller->Load16(*cpu.xip, 8273); diff --git a/tests/Modular/AssemblerCore/Parser/Operands.cpp b/tests/Modular/AssemblerCore/Parser/Operands.cpp index 755023a9..c11463e4 100644 --- a/tests/Modular/AssemblerCore/Parser/Operands.cpp +++ b/tests/Modular/AssemblerCore/Parser/Operands.cpp @@ -1,186 +1,186 @@ #include TEST_F(ASM_PARSER_TEST, OPERAND1) { - std::string data = "[0x15FA]"; - parser.set_start_symbol("operand"); + std::string data = "[0x15FA]"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::memaddr_int); - EXPECT_EQ(std::get(operand.variant), static_cast(0x15FA)); + EXPECT_EQ(operand.type, HCAsm::OperandType::memaddr_int); + EXPECT_EQ(std::get(operand.variant), static_cast(0x15FA)); } TEST_F(ASM_PARSER_TEST, OPERAND2) { - std::string data = "[x0]"; - parser.set_start_symbol("operand"); + std::string data = "[x0]"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::memaddr_reg); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.type, HCAsm::OperandType::memaddr_reg); + EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); } TEST_F(ASM_PARSER_TEST, OPERAND3_1) { - std::string data = "[x0 + 0u15]"; - parser.set_start_symbol("operand"); + std::string data = "[x0 + 0u15]"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); - EXPECT_EQ(std::get(operand.variant), static_cast(15)); + EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); + EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(std::get(operand.variant), static_cast(15)); } TEST_F(ASM_PARSER_TEST, OPERAND3_2) { - std::string data = "[x0 + 0x15]"; - parser.set_start_symbol("operand"); + std::string data = "[x0 + 0x15]"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); - EXPECT_EQ(std::get(operand.variant), static_cast(0x15)); + EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); + EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(std::get(operand.variant), static_cast(0x15)); } TEST_F(ASM_PARSER_TEST, OPERAND3_3) { - std::string data = "[x0 + 0b00110101]"; - parser.set_start_symbol("operand"); + std::string data = "[x0 + 0b00110101]"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); - EXPECT_EQ(std::get(operand.variant), static_cast(0b00110101)); + EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); + EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(std::get(operand.variant), static_cast(0b00110101)); } TEST_F(ASM_PARSER_TEST, OPERAND4) { - std::string data = "b8 ptr [0x15FA]"; - parser.set_start_symbol("operand"); + std::string data = "b8 ptr [0x15FA]"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::memaddr_int); - EXPECT_EQ(operand.mode, HCAsm::Mode::b8); - EXPECT_EQ(std::get(operand.variant), static_cast(0x15FA)); + EXPECT_EQ(operand.type, HCAsm::OperandType::memaddr_int); + EXPECT_EQ(operand.mode, HCAsm::Mode::b8); + EXPECT_EQ(std::get(operand.variant), static_cast(0x15FA)); } TEST_F(ASM_PARSER_TEST, OPERAND5) { - std::string data = "b16 ptr [x0]"; - parser.set_start_symbol("operand"); + std::string data = "b16 ptr [x0]"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::memaddr_reg); - EXPECT_EQ(operand.mode, HCAsm::Mode::b16); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.type, HCAsm::OperandType::memaddr_reg); + EXPECT_EQ(operand.mode, HCAsm::Mode::b16); + EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); } TEST_F(ASM_PARSER_TEST, OPERAND6_1) { - std::string data = "b32 ptr [x0 + 0u15]"; - parser.set_start_symbol("operand"); + std::string data = "b32 ptr [x0 + 0u15]"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); - EXPECT_EQ(operand.mode, HCAsm::Mode::b32); - EXPECT_EQ(std::get(operand.variant), static_cast(15)); + EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); + EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.mode, HCAsm::Mode::b32); + EXPECT_EQ(std::get(operand.variant), static_cast(15)); } TEST_F(ASM_PARSER_TEST, OPERAND6_2) { - std::string data = "b8 ptr [x0 + 0x15]"; - parser.set_start_symbol("operand"); + std::string data = "b8 ptr [x0 + 0x15]"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); - EXPECT_EQ(operand.mode, HCAsm::Mode::b8); - EXPECT_EQ(std::get(operand.variant), static_cast(0x15)); + EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); + EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.mode, HCAsm::Mode::b8); + EXPECT_EQ(std::get(operand.variant), static_cast(0x15)); } TEST_F(ASM_PARSER_TEST, OPERAND6_3) { - std::string data = "b32 ptr [x0 + 0b00110101]"; - parser.set_start_symbol("operand"); + std::string data = "b32 ptr [x0 + 0b00110101]"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); - EXPECT_EQ(operand.mode, HCAsm::Mode::b32); - EXPECT_EQ(std::get(operand.variant), static_cast(0b00110101)); + EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); + EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.mode, HCAsm::Mode::b32); + EXPECT_EQ(std::get(operand.variant), static_cast(0b00110101)); } TEST_F(ASM_PARSER_TEST, OPERAND7) { - std::string data = "0s15"; - parser.set_start_symbol("operand"); + std::string data = "0s15"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::sint); - EXPECT_EQ(operand.mode, HCAsm::Mode::none); - EXPECT_EQ(std::get(operand.variant), static_cast(15)); + EXPECT_EQ(operand.type, HCAsm::OperandType::sint); + EXPECT_EQ(operand.mode, HCAsm::Mode::none); + EXPECT_EQ(std::get(operand.variant), static_cast(15)); } TEST_F(ASM_PARSER_TEST, OPERAND8_1) { - std::string data = "0u15"; - parser.set_start_symbol("operand"); + std::string data = "0u15"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::uint); - EXPECT_EQ(operand.mode, HCAsm::Mode::none); - EXPECT_EQ(std::get(operand.variant), static_cast(15)); + EXPECT_EQ(operand.type, HCAsm::OperandType::uint); + EXPECT_EQ(operand.mode, HCAsm::Mode::none); + EXPECT_EQ(std::get(operand.variant), static_cast(15)); } TEST_F(ASM_PARSER_TEST, OPERAND8_2) { - std::string data = "0x15"; - parser.set_start_symbol("operand"); + std::string data = "0x15"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::uint); - EXPECT_EQ(operand.mode, HCAsm::Mode::none); - EXPECT_EQ(std::get(operand.variant), static_cast(0x15)); + EXPECT_EQ(operand.type, HCAsm::OperandType::uint); + EXPECT_EQ(operand.mode, HCAsm::Mode::none); + EXPECT_EQ(std::get(operand.variant), static_cast(0x15)); } TEST_F(ASM_PARSER_TEST, OPERAND8_3) { - std::string data = "0b00110101"; - parser.set_start_symbol("operand"); + std::string data = "0b00110101"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::uint); - EXPECT_EQ(operand.mode, HCAsm::Mode::none); - EXPECT_EQ(std::get(operand.variant), static_cast(0b00110101)); + EXPECT_EQ(operand.type, HCAsm::OperandType::uint); + EXPECT_EQ(operand.mode, HCAsm::Mode::none); + EXPECT_EQ(std::get(operand.variant), static_cast(0b00110101)); } TEST_F(ASM_PARSER_TEST, OPERAND8_4) { @@ -197,16 +197,16 @@ TEST_F(ASM_PARSER_TEST, OPERAND8_4) { } TEST_F(ASM_PARSER_TEST, OPERAND9) { - std::string data = "x0"; - parser.set_start_symbol("operand"); + std::string data = "x0"; + parser.set_start_symbol("operand"); - parser.prepare(); + parser.prepare(); - auto operand = std::get(parser.parse(data)->val); + auto operand = std::get(parser.parse(data)->val); - EXPECT_EQ(operand.type, HCAsm::OperandType::reg); - EXPECT_EQ(operand.mode, HCAsm::Mode::b64); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.type, HCAsm::OperandType::reg); + EXPECT_EQ(operand.mode, HCAsm::Mode::b64); + EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); } TEST_F(ASM_PARSER_TEST, OPERAND10) { diff --git a/tests/Modular/AssemblerCore/Parser/Statements.cpp b/tests/Modular/AssemblerCore/Parser/Statements.cpp index 3e2f4452..dd50ba19 100644 --- a/tests/Modular/AssemblerCore/Parser/Statements.cpp +++ b/tests/Modular/AssemblerCore/Parser/Statements.cpp @@ -11,7 +11,7 @@ TEST_F(ASM_PARSER_STMT_TEST, STMT1) { auto& instr = std::get(state.ir[0]); EXPECT_EQ(instr.opcode, HyperCPU::Opcode::ADC); - + EXPECT_EQ(instr.op1.type, HCAsm::OperandType::reg); EXPECT_EQ(instr.op1.reg, HyperCPU::Registers::X0); @@ -28,7 +28,7 @@ TEST_F(ASM_PARSER_STMT_TEST, STMT2) { auto& instr = std::get(state.ir[0]); EXPECT_EQ(instr.opcode, HyperCPU::Opcode::ADC); - + EXPECT_EQ(instr.op1.type, HCAsm::OperandType::reg); EXPECT_EQ(instr.op1.reg, HyperCPU::Registers::X0); @@ -44,7 +44,7 @@ TEST_F(ASM_PARSER_STMT_TEST, STMT3) { auto& instr = std::get(state.ir[0]); EXPECT_EQ(instr.opcode, HyperCPU::Opcode::ADC); - + EXPECT_EQ(instr.op1.type, HCAsm::OperandType::none); EXPECT_EQ(instr.op2.type, HCAsm::OperandType::none); diff --git a/tests/Modular/AssemblerCore/Parser/Tokens.cpp b/tests/Modular/AssemblerCore/Parser/Tokens.cpp index 9e3cfbd2..e947670c 100644 --- a/tests/Modular/AssemblerCore/Parser/Tokens.cpp +++ b/tests/Modular/AssemblerCore/Parser/Tokens.cpp @@ -2,94 +2,94 @@ #include TEST_F(ASM_PARSER_TEST, TOKEN_STRING) { - std::string str = "this is a string to test parser\\n\\r\\\"\\\'\\a\\\\"; - std::string data = fmt::format("\"{}\" \\", str); - - // Token, created only for testing - parser.token("\\\\") - .symbol("\\"); - - parser.set_start_symbol("string_test"); - parser.rule("string_test") - .production("string", "\\", [](pog::Parser&, std::vector> args) -> HCAsm::Value { - return std::move(args[0].value); - }); - - parser.prepare(); - - EXPECT_EQ(std::get(parser.parse(data).value().val), "this is a string to test parser\n\r\"\'a\\"); + std::string str = "this is a string to test parser\\n\\r\\\"\\\'\\a\\\\"; + std::string data = fmt::format("\"{}\" \\", str); + + // Token, created only for testing + parser.token("\\\\") + .symbol("\\"); + + parser.set_start_symbol("string_test"); + parser.rule("string_test") + .production("string", "\\", [](pog::Parser&, std::vector> args) -> HCAsm::Value { + return std::move(args[0].value); + }); + + parser.prepare(); + + EXPECT_EQ(std::get(parser.parse(data).value().val), "this is a string to test parser\n\r\"\'a\\"); } TEST_F(ASM_PARSER_TEST, TOKEN_SINT) { - std::string data = "0s1234 \\"; - - // Token, created only for testing - parser.token("\\\\") - .symbol("\\"); - - parser.set_start_symbol("sint_test"); - parser.rule("sint_test") - .production("sint", "\\", [](pog::Parser&, std::vector> args) -> HCAsm::Value { - return std::move(args[0].value); - }); - - parser.prepare(); - - EXPECT_EQ(std::get(parser.parse(data).value().val), static_cast(1234)); + std::string data = "0s1234 \\"; + + // Token, created only for testing + parser.token("\\\\") + .symbol("\\"); + + parser.set_start_symbol("sint_test"); + parser.rule("sint_test") + .production("sint", "\\", [](pog::Parser&, std::vector> args) -> HCAsm::Value { + return std::move(args[0].value); + }); + + parser.prepare(); + + EXPECT_EQ(std::get(parser.parse(data).value().val), static_cast(1234)); } TEST_F(ASM_PARSER_TEST, TOKEN_UINT) { - std::string data = "0u1234 \\"; - - // Token, created only for testing - parser.token("\\\\") - .symbol("\\"); - - parser.set_start_symbol("uint_test"); - parser.rule("uint_test") - .production("uint", "\\", [](pog::Parser&, std::vector> args) -> HCAsm::Value { - return std::move(args[0].value); - }); - - parser.prepare(); - - EXPECT_EQ(std::get(parser.parse(data).value().val), static_cast(1234)); + std::string data = "0u1234 \\"; + + // Token, created only for testing + parser.token("\\\\") + .symbol("\\"); + + parser.set_start_symbol("uint_test"); + parser.rule("uint_test") + .production("uint", "\\", [](pog::Parser&, std::vector> args) -> HCAsm::Value { + return std::move(args[0].value); + }); + + parser.prepare(); + + EXPECT_EQ(std::get(parser.parse(data).value().val), static_cast(1234)); } TEST_F(ASM_PARSER_TEST, TOKEN_HEX) { - std::string data = "0x15FA \\"; - - // Token, created only for testing - parser.token("\\\\") - .symbol("\\"); - - parser.set_start_symbol("hex_test"); - parser.rule("hex_test") - .production("hex", "\\", [](pog::Parser&, std::vector> args) -> HCAsm::Value { - return std::move(args[0].value); - }); - - parser.prepare(); - - EXPECT_EQ(std::get(parser.parse(data).value().val), static_cast(0x15FA)); + std::string data = "0x15FA \\"; + + // Token, created only for testing + parser.token("\\\\") + .symbol("\\"); + + parser.set_start_symbol("hex_test"); + parser.rule("hex_test") + .production("hex", "\\", [](pog::Parser&, std::vector> args) -> HCAsm::Value { + return std::move(args[0].value); + }); + + parser.prepare(); + + EXPECT_EQ(std::get(parser.parse(data).value().val), static_cast(0x15FA)); } TEST_F(ASM_PARSER_TEST, TOKEN_BINARY) { - std::string data = "0b0001010111111010 \\"; - - // Token, created only for testing - parser.token("\\\\") - .symbol("\\"); - - parser.set_start_symbol("binary_test"); - parser.rule("binary_test") - .production("binary", "\\", [](pog::Parser&, std::vector> args) -> HCAsm::Value { - return std::move(args[0].value); - }); - - parser.prepare(); - - EXPECT_EQ(std::get(parser.parse(data).value().val), static_cast(0b0001010111111010)); + std::string data = "0b0001010111111010 \\"; + + // Token, created only for testing + parser.token("\\\\") + .symbol("\\"); + + parser.set_start_symbol("binary_test"); + parser.rule("binary_test") + .production("binary", "\\", [](pog::Parser&, std::vector> args) -> HCAsm::Value { + return std::move(args[0].value); + }); + + parser.prepare(); + + EXPECT_EQ(std::get(parser.parse(data).value().val), static_cast(0b0001010111111010)); } TEST_F(ASM_PARSER_TEST, TOKEN_CHAR) { @@ -98,14 +98,14 @@ TEST_F(ASM_PARSER_TEST, TOKEN_CHAR) { // Token, created only for testing parser.token("\\\\") .symbol("\\"); - + parser.set_start_symbol("char_test"); parser.rule("char_test") .production("char", "\\", [](pog::Parser&, std::vector> args) -> HCAsm::Value { - return std::move(args[0].value); + return std::move(args[0].value); }); parser.prepare(); - + EXPECT_EQ(std::get(parser.parse(data).value().val), static_cast('c')); } diff --git a/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp index 004754c6..0107e2e1 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, ADC_INSTR_M_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp index 0d6990f9..1a73862c 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, ADD_INSTR_M_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp index 73f3e375..9ef3c183 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, AND_INSTR_M_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp index e13c883e..fc89f117 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, ANDN_INSTR_M_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp index 0edc8c44..66342711 100644 --- a/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, BSWAP_INSTR_R_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp index 2bd23ccb..115eab63 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, CALLE_INSTR_R_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp index f77d2f13..db9493b6 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, CALLGR_INSTR_R_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp index adca0567..62b673ba 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, CALL_INSTR_R_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp index 13ea24ef..c187018c 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, CALLL_INSTR_R_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp index 6ada6df0..060794ea 100644 --- a/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, CCRF_INSTR_R_R_B8) { @@ -528,7 +528,6 @@ TEST_F(DECODER_TEST, CCRF_INSTR_M_B64) { HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } - TEST_F(DECODER_TEST, CCRF_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::CCRF); counter += 2; diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp index d5f86f54..90a9f4fd 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp @@ -6,9 +6,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, CMP_INSTR_R) { diff --git a/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp index 06f23f58..c8b8098b 100644 --- a/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, COVF_INSTR_R_R_B8) { @@ -528,7 +528,6 @@ TEST_F(DECODER_TEST, COVF_INSTR_M_B64) { HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } - TEST_F(DECODER_TEST, COVF_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::COVF); counter += 2; diff --git a/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp index 82dca347..e671a18c 100644 --- a/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, CUDF_INSTR_R_R_B8) { @@ -528,7 +528,6 @@ TEST_F(DECODER_TEST, CUDF_INSTR_M_B64) { HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } - TEST_F(DECODER_TEST, CUDF_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::CUDF); counter += 2; diff --git a/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp index b2a28019..981cf89f 100644 --- a/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, DEC_INSTR_R_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp index 84ae67e5..9ce1955c 100644 --- a/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, DIV_INSTR_IMM_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp index be8d0624..9b9e15f8 100644 --- a/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, HALT_INSTR_R_R_B8) { @@ -528,7 +528,6 @@ TEST_F(DECODER_TEST, HALT_INSTR_M_B64) { HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } - TEST_F(DECODER_TEST, HALT_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::HALT); counter += 2; diff --git a/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp index 50d368f1..43a5f98c 100644 --- a/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, HID_INSTR_R_R_B8) { @@ -528,7 +528,6 @@ TEST_F(DECODER_TEST, HID_INSTR_M_B64) { HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } - TEST_F(DECODER_TEST, HID_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::HID); counter += 2; diff --git a/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp index 8fdc6bac..045a4203 100644 --- a/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, INC_INSTR_R_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp index 505d516b..c24a3f9d 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, JME_INSTR_R_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp index ffe83fbe..5fa19a3c 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, JMGR_INSTR_R_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp index 49677b95..483315cc 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, JML_INSTR_R_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp index 913e1afd..830b6076 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, JMP_INSTR_R_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp index 0375ae2f..8c68f070 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, MOV_INSTR_R) { diff --git a/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp index 32fc0b1b..493ea1c1 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, MUL_INSTR_M_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp index 14709d67..569525e6 100644 --- a/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, OR_INSTR_M_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/READInstr/IMM.cpp b/tests/Modular/EmulatorCore/Decoding/READInstr/IMM.cpp index be1b58cf..948fbf1b 100644 --- a/tests/Modular/EmulatorCore/Decoding/READInstr/IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/READInstr/IMM.cpp @@ -10,7 +10,7 @@ TEST_F(DECODER_TEST, READ_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::READ); @@ -21,7 +21,8 @@ TEST_F(DECODER_TEST, READ_INSTR_IMM) { } TEST_F(DECODER_TEST, READ_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); counter += 2; + decoder.mem_controller->Load16(counter, HyperCPU::READ); + counter += 2; decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R); ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::XLLL0); diff --git a/tests/Modular/EmulatorCore/Decoding/READInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/READInstr/Unsupported.cpp index b8fe8edc..200d7cce 100644 --- a/tests/Modular/EmulatorCore/Decoding/READInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/READInstr/Unsupported.cpp @@ -1,9 +1,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, READ_INSTR_R_IMM_B8) { @@ -41,7 +41,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -67,7 +67,7 @@ TEST_F(DECODER_TEST, READ_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -80,7 +80,7 @@ TEST_F(DECODER_TEST, READ_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -93,7 +93,7 @@ TEST_F(DECODER_TEST, READ_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -106,7 +106,7 @@ TEST_F(DECODER_TEST, READ_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -119,7 +119,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -132,7 +132,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -145,7 +145,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -158,7 +158,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -169,7 +169,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -182,7 +182,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -195,7 +195,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -208,7 +208,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -221,7 +221,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -234,7 +234,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -247,7 +247,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -260,7 +260,7 @@ TEST_F(DECODER_TEST, READ_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -273,7 +273,7 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -286,7 +286,7 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -299,7 +299,7 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -312,7 +312,7 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -325,7 +325,7 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -338,7 +338,7 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -351,7 +351,7 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -364,7 +364,7 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -377,7 +377,7 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -390,7 +390,7 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -403,7 +403,7 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -416,7 +416,7 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -429,7 +429,7 @@ TEST_F(DECODER_TEST, READ_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -442,6 +442,6 @@ TEST_F(DECODER_TEST, READ_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } diff --git a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp index cfff7dda..97298360 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp index 393a3cf9..a7b129d7 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp index d33f52ed..6b96d723 100644 --- a/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp @@ -5,9 +5,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, SUB_INSTR_M_R_B8) { diff --git a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp index be89f195..d3b7f304 100644 --- a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp @@ -9,7 +9,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HyperCPU::Registers reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -23,4 +23,3 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B8) { ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(data, 0x55); } - diff --git a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_R.cpp index 7930565f..21ab0327 100644 --- a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_R.cpp @@ -10,7 +10,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X1); counter = 0; - + HyperCPU::Registers reg1; HyperCPU::Registers reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -24,4 +24,3 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_R_B8) { ASSERT_EQ(reg1, HyperCPU::Registers::X3); ASSERT_EQ(reg2, HyperCPU::Registers::X1); } - diff --git a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/Unsupported.cpp index 57748c82..65fdcbd4 100644 --- a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/Unsupported.cpp @@ -1,9 +1,9 @@ #include #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #endif TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B16) { @@ -28,7 +28,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -54,7 +54,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_M_R_B8) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -67,7 +67,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_M_R_B16) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -80,7 +80,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_M_R_B32) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -93,7 +93,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_M_R_B64) { counter += 8; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -106,7 +106,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -119,7 +119,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -132,7 +132,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -145,7 +145,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -158,7 +158,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -171,7 +171,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -184,7 +184,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -197,7 +197,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_RM_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -210,7 +210,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_RM_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -223,7 +223,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_RM_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -236,7 +236,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_RM_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -249,7 +249,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_IMM_B8) { ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -262,7 +262,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_IMM_B16) { ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -275,7 +275,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_IMM_B32) { ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -288,7 +288,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_IMM_B64) { ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -301,7 +301,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_M_B8) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -314,7 +314,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_M_B16) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -327,7 +327,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_M_B32) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -340,7 +340,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_M_B64) { ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -353,7 +353,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_R_B8) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -366,7 +366,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_R_B16) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -379,7 +379,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_R_B32) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -392,7 +392,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_R_B64) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -405,7 +405,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -418,7 +418,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_M) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -431,7 +431,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_IMM) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } @@ -444,6 +444,6 @@ TEST_F(DECODER_TEST, WRITE_INSTR_NONE) { ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); counter = 0; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } diff --git a/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp b/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp index b7f756c7..497a1dbb 100644 --- a/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp +++ b/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp @@ -5,23 +5,22 @@ #define private public #include - static constexpr std::uint8_t BYTE = 0x55; static constexpr std::uint16_t WORD = 0x5555; static constexpr std::uint32_t DWORD = 0x55555555; static constexpr std::uint64_t QWORD = 0x5555555555555555; #ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) #else -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #endif TEST_F(MC_ST_TEST, LOAD8) { for (std::size_t i = 0; i < MEM_FIXTURE_MEM_SIZE; ++i, ++counter) mcmt.Load8(counter, BYTE); - ASSERT_TRUE(std::memcmp(mcmt.memory,&tmp_buffer, MEM_FIXTURE_MEM_SIZE) == 0); + ASSERT_TRUE(std::memcmp(mcmt.memory, &tmp_buffer, MEM_FIXTURE_MEM_SIZE) == 0); } TEST_F(MC_ST_TEST, LOAD16) { diff --git a/tests/Modular/EmulatorCore/Stack/Stack.cpp b/tests/Modular/EmulatorCore/Stack/Stack.cpp index 1b7fdf04..59e4309e 100644 --- a/tests/Modular/EmulatorCore/Stack/Stack.cpp +++ b/tests/Modular/EmulatorCore/Stack/Stack.cpp @@ -1,6 +1,5 @@ #include - static constexpr std::uint8_t BYTE_DATA = 0x55; static constexpr std::uint16_t WORD_DATA = 0x5555; static constexpr std::uint32_t DWORD_DATA = 0x55555555; diff --git a/tests/Pog/Automaton.cpp b/tests/Pog/Automaton.cpp index 02eaca91..1796ed9b 100644 --- a/tests/Pog/Automaton.cpp +++ b/tests/Pog/Automaton.cpp @@ -6,175 +6,160 @@ using namespace pog; -class TestAutomaton : public ::testing::Test -{ +class TestAutomaton : public ::testing::Test { public: - using SetupGrammarTuple = std::tuple; - - TestAutomaton() : grammar() {} - - template - State new_state(const Args&... args) - { - State state; - _new_state(state, args...); - return state; - } - - void _new_state(State& state, const std::string& lhs, const std::vector& left_rhs, const std::vector& right_rhs) - { - _add_item_to_state(state, lhs, left_rhs, right_rhs); - } - - template - void _new_state(State& state, const std::string& lhs, const std::vector& left_rhs, const std::vector& right_rhs, const Args&... args) - { - _add_item_to_state(state, lhs, left_rhs, right_rhs); - _new_state(state, args...); - } - - void _add_item_to_state(State& state, const std::string& lhs, const std::vector& left_rhs, const std::vector& right_rhs) - { - auto lhs_sym = grammar.add_symbol(SymbolKind::Nonterminal, lhs); - auto sym_transform = [this](const auto& name) { - return grammar.add_symbol(std::islower(name[0]) ? SymbolKind::Terminal : SymbolKind::Nonterminal, name); - }; - - std::vector*> left_rhs_syms(left_rhs.size()); - std::vector*> right_rhs_syms(right_rhs.size()); - std::vector*> rhs_syms(left_rhs.size() + right_rhs.size()); - - std::transform(left_rhs.begin(), left_rhs.end(), left_rhs_syms.begin(), sym_transform); - std::transform(right_rhs.begin(), right_rhs.end(), right_rhs_syms.begin(), sym_transform); - std::copy(left_rhs_syms.begin(), left_rhs_syms.end(), rhs_syms.begin()); - std::copy(right_rhs_syms.begin(), right_rhs_syms.end(), rhs_syms.begin() + left_rhs.size()); - - Rule* rule = nullptr; - for (auto& r : grammar.get_rules()) - { - bool rhs_equal = std::equal(r->get_rhs().begin(), r->get_rhs().end(), rhs_syms.begin(), rhs_syms.end(), [](const auto* sym1, const auto* sym2) { - return sym1->get_index() == sym2->get_index(); - }); - if (r->get_lhs() == lhs_sym && rhs_equal) - { - rule = r.get(); - break; - } - } - - if (!rule) - rule = grammar.add_rule(lhs_sym, rhs_syms, [](auto&&...) -> int { return 0; }); - - state.add_item(Item{rule, left_rhs.size()}); - } - - Grammar grammar; + using SetupGrammarTuple = std::tuple; + + TestAutomaton() + : grammar() { + } + + template + State new_state(const Args&... args) { + State state; + _new_state(state, args...); + return state; + } + + void _new_state(State& state, const std::string& lhs, const std::vector& left_rhs, const std::vector& right_rhs) { + _add_item_to_state(state, lhs, left_rhs, right_rhs); + } + + template + void _new_state(State& state, const std::string& lhs, const std::vector& left_rhs, const std::vector& right_rhs, const Args&... args) { + _add_item_to_state(state, lhs, left_rhs, right_rhs); + _new_state(state, args...); + } + + void _add_item_to_state(State& state, const std::string& lhs, const std::vector& left_rhs, const std::vector& right_rhs) { + auto lhs_sym = grammar.add_symbol(SymbolKind::Nonterminal, lhs); + auto sym_transform = [this](const auto& name) { + return grammar.add_symbol(std::islower(name[0]) ? SymbolKind::Terminal : SymbolKind::Nonterminal, name); + }; + + std::vector*> left_rhs_syms(left_rhs.size()); + std::vector*> right_rhs_syms(right_rhs.size()); + std::vector*> rhs_syms(left_rhs.size() + right_rhs.size()); + + std::transform(left_rhs.begin(), left_rhs.end(), left_rhs_syms.begin(), sym_transform); + std::transform(right_rhs.begin(), right_rhs.end(), right_rhs_syms.begin(), sym_transform); + std::copy(left_rhs_syms.begin(), left_rhs_syms.end(), rhs_syms.begin()); + std::copy(right_rhs_syms.begin(), right_rhs_syms.end(), rhs_syms.begin() + left_rhs.size()); + + Rule* rule = nullptr; + for (auto& r : grammar.get_rules()) { + bool rhs_equal = std::equal(r->get_rhs().begin(), r->get_rhs().end(), rhs_syms.begin(), rhs_syms.end(), [](const auto* sym1, const auto* sym2) { + return sym1->get_index() == sym2->get_index(); + }); + if (r->get_lhs() == lhs_sym && rhs_equal) { + rule = r.get(); + break; + } + } + + if (!rule) + rule = grammar.add_rule(lhs_sym, rhs_syms, [](auto&&...) -> int { return 0; }); + + state.add_item(Item{rule, left_rhs.size()}); + } + + Grammar grammar; }; TEST_F(TestAutomaton, -AddState) { - auto state = new_state( - "S", std::vector{}, std::vector{"a", "S", "b"}, - "S", std::vector{}, std::vector{} - ); + AddState) { + auto state = new_state( + "S", std::vector{}, std::vector{"a", "S", "b"}, + "S", std::vector{}, std::vector{}); - Automaton a(&grammar); - auto result = a.add_state(std::move(state)); + Automaton a(&grammar); + auto result = a.add_state(std::move(state)); - EXPECT_TRUE(result.second); - EXPECT_EQ(result.first->to_string(), "S -> <*> a S b\nS -> <*> "); + EXPECT_TRUE(result.second); + EXPECT_EQ(result.first->to_string(), "S -> <*> a S b\nS -> <*> "); } TEST_F(TestAutomaton, -AddStateUnique) { - auto state1 = new_state( - "S", std::vector{}, std::vector{"a", "S", "b"}, - "S", std::vector{}, std::vector{} - ); - auto state2 = new_state( - "S", std::vector{"a"}, std::vector{"S", "b"} - ); - - Automaton a(&grammar); - auto result1 = a.add_state(std::move(state1)); - auto result2 = a.add_state(std::move(state2)); - - EXPECT_TRUE(result1.second); - EXPECT_EQ(result1.first->to_string(), "S -> <*> a S b\nS -> <*> "); - EXPECT_TRUE(result2.second); - EXPECT_EQ(result2.first->to_string(), "S -> a <*> S b"); + AddStateUnique) { + auto state1 = new_state( + "S", std::vector{}, std::vector{"a", "S", "b"}, + "S", std::vector{}, std::vector{}); + auto state2 = new_state( + "S", std::vector{"a"}, std::vector{"S", "b"}); + + Automaton a(&grammar); + auto result1 = a.add_state(std::move(state1)); + auto result2 = a.add_state(std::move(state2)); + + EXPECT_TRUE(result1.second); + EXPECT_EQ(result1.first->to_string(), "S -> <*> a S b\nS -> <*> "); + EXPECT_TRUE(result2.second); + EXPECT_EQ(result2.first->to_string(), "S -> a <*> S b"); } TEST_F(TestAutomaton, -AddStateDuplicate) { - auto state1 = new_state( - "S", std::vector{}, std::vector{"a", "S", "b"}, - "S", std::vector{}, std::vector{} - ); - auto state2 = new_state( - "S", std::vector{}, std::vector{"a", "S", "b"}, - "S", std::vector{}, std::vector{} - ); - - Automaton a(&grammar); - auto result1 = a.add_state(std::move(state1)); - auto result2 = a.add_state(std::move(state2)); - - EXPECT_TRUE(result1.second); - EXPECT_EQ(result1.first->to_string(), "S -> <*> a S b\nS -> <*> "); - EXPECT_FALSE(result2.second); - EXPECT_EQ(result1.first, result2.first); + AddStateDuplicate) { + auto state1 = new_state( + "S", std::vector{}, std::vector{"a", "S", "b"}, + "S", std::vector{}, std::vector{}); + auto state2 = new_state( + "S", std::vector{}, std::vector{"a", "S", "b"}, + "S", std::vector{}, std::vector{}); + + Automaton a(&grammar); + auto result1 = a.add_state(std::move(state1)); + auto result2 = a.add_state(std::move(state2)); + + EXPECT_TRUE(result1.second); + EXPECT_EQ(result1.first->to_string(), "S -> <*> a S b\nS -> <*> "); + EXPECT_FALSE(result2.second); + EXPECT_EQ(result1.first, result2.first); } TEST_F(TestAutomaton, -GetState) { - auto state = new_state( - "S", std::vector{}, std::vector{"a", "S", "b"}, - "S", std::vector{}, std::vector{} - ); + GetState) { + auto state = new_state( + "S", std::vector{}, std::vector{"a", "S", "b"}, + "S", std::vector{}, std::vector{}); - Automaton a(&grammar); - a.add_state(std::move(state)); + Automaton a(&grammar); + a.add_state(std::move(state)); - state = new_state( - "S", std::vector{}, std::vector{"a", "S", "b"}, - "S", std::vector{}, std::vector{} - ); + state = new_state( + "S", std::vector{}, std::vector{"a", "S", "b"}, + "S", std::vector{}, std::vector{}); - EXPECT_EQ(*a.get_state(0), state); + EXPECT_EQ(*a.get_state(0), state); } TEST_F(TestAutomaton, -Closure) { - auto state = new_state( - "S", std::vector{"A"}, std::vector{"S", "b"} - ); - new_state( - "A", std::vector{"a"}, std::vector{"A"}, - "A", std::vector{}, std::vector{} - ); - - Automaton a(&grammar); - a.closure(state); - - EXPECT_EQ(state.to_string(), "S -> A <*> S b\nS -> <*> A S b\nA -> <*> a A\nA -> <*> "); + Closure) { + auto state = new_state( + "S", std::vector{"A"}, std::vector{"S", "b"}); + new_state( + "A", std::vector{"a"}, std::vector{"A"}, + "A", std::vector{}, std::vector{}); + + Automaton a(&grammar); + a.closure(state); + + EXPECT_EQ(state.to_string(), "S -> A <*> S b\nS -> <*> A S b\nA -> <*> a A\nA -> <*> "); } TEST_F(TestAutomaton, -ConstructStates) { - grammar.set_start_symbol(grammar.add_symbol(SymbolKind::Nonterminal, "S")); - new_state( - "S", std::vector{}, std::vector{"a", "S", "b"}, - "S", std::vector{}, std::vector{} - ); - - Automaton a(&grammar); - a.construct_states(); - - EXPECT_EQ(a.get_states().size(), 5u); - EXPECT_EQ(a.get_states()[0]->to_string(), "@start -> <*> S @end\nS -> <*> a S b\nS -> <*> "); - EXPECT_EQ(a.get_states()[1]->to_string(), "@start -> S <*> @end"); - EXPECT_EQ(a.get_states()[2]->to_string(), "S -> a <*> S b\nS -> <*> a S b\nS -> <*> "); - EXPECT_EQ(a.get_states()[3]->to_string(), "S -> a S <*> b"); - EXPECT_EQ(a.get_states()[4]->to_string(), "S -> a S b <*>"); + ConstructStates) { + grammar.set_start_symbol(grammar.add_symbol(SymbolKind::Nonterminal, "S")); + new_state( + "S", std::vector{}, std::vector{"a", "S", "b"}, + "S", std::vector{}, std::vector{}); + + Automaton a(&grammar); + a.construct_states(); + + EXPECT_EQ(a.get_states().size(), 5u); + EXPECT_EQ(a.get_states()[0]->to_string(), "@start -> <*> S @end\nS -> <*> a S b\nS -> <*> "); + EXPECT_EQ(a.get_states()[1]->to_string(), "@start -> S <*> @end"); + EXPECT_EQ(a.get_states()[2]->to_string(), "S -> a <*> S b\nS -> <*> a S b\nS -> <*> "); + EXPECT_EQ(a.get_states()[3]->to_string(), "S -> a S <*> b"); + EXPECT_EQ(a.get_states()[4]->to_string(), "S -> a S b <*>"); } diff --git a/tests/Pog/FilterView.cpp b/tests/Pog/FilterView.cpp index 5791d4de..88624ac5 100644 --- a/tests/Pog/FilterView.cpp +++ b/tests/Pog/FilterView.cpp @@ -5,79 +5,79 @@ class TestFilterView : public ::testing::Test {}; TEST_F(TestFilterView, -EmptyContainer) { - std::vector v; + EmptyContainer) { + std::vector v; - FilterView fv(v.begin(), v.end(), [](int x) { return x & 1; }); + FilterView fv(v.begin(), v.end(), [](int x) { return x & 1; }); - std::vector actual; - for (auto x : fv) - actual.push_back(x); + std::vector actual; + for (auto x : fv) + actual.push_back(x); - EXPECT_EQ(actual, (std::vector{})); + EXPECT_EQ(actual, (std::vector{})); } TEST_F(TestFilterView, -BasicFilter) { - std::vector v = {0, 1, 2, 3, 4, 5, 6}; + BasicFilter) { + std::vector v = {0, 1, 2, 3, 4, 5, 6}; - FilterView fv(v.begin(), v.end(), [](int x) { return x & 1; }); + FilterView fv(v.begin(), v.end(), [](int x) { return x & 1; }); - std::vector actual; - for (auto x : fv) - actual.push_back(x); + std::vector actual; + for (auto x : fv) + actual.push_back(x); - EXPECT_EQ(actual, (std::vector{1, 3, 5})); + EXPECT_EQ(actual, (std::vector{1, 3, 5})); } TEST_F(TestFilterView, -SharedEnd) { - std::vector v = {0, 1, 2, 3, 4, 5}; + SharedEnd) { + std::vector v = {0, 1, 2, 3, 4, 5}; - FilterView fv(v.begin(), v.end(), [](int x) { return x & 1; }); + FilterView fv(v.begin(), v.end(), [](int x) { return x & 1; }); - std::vector actual; - for (auto x : fv) - actual.push_back(x); + std::vector actual; + for (auto x : fv) + actual.push_back(x); - EXPECT_EQ(actual, (std::vector{1, 3, 5})); + EXPECT_EQ(actual, (std::vector{1, 3, 5})); } TEST_F(TestFilterView, -SharedBegin) { - std::vector v = {1, 2, 3, 4, 5, 6}; + SharedBegin) { + std::vector v = {1, 2, 3, 4, 5, 6}; - FilterView fv(v.begin(), v.end(), [](int x) { return x & 1; }); + FilterView fv(v.begin(), v.end(), [](int x) { return x & 1; }); - std::vector actual; - for (auto x : fv) - actual.push_back(x); + std::vector actual; + for (auto x : fv) + actual.push_back(x); - EXPECT_EQ(actual, (std::vector{1, 3, 5})); + EXPECT_EQ(actual, (std::vector{1, 3, 5})); } TEST_F(TestFilterView, -SharedBeginAndEnd) { - std::vector v = {1, 2, 3, 4, 5}; + SharedBeginAndEnd) { + std::vector v = {1, 2, 3, 4, 5}; - FilterView fv(v.begin(), v.end(), [](int x) { return x & 1; }); + FilterView fv(v.begin(), v.end(), [](int x) { return x & 1; }); - std::vector actual; - for (auto x : fv) - actual.push_back(x); + std::vector actual; + for (auto x : fv) + actual.push_back(x); - EXPECT_EQ(actual, (std::vector{1, 3, 5})); + EXPECT_EQ(actual, (std::vector{1, 3, 5})); } TEST_F(TestFilterView, -NoElements) { - std::vector v = {0, 1, 2, 3, 4, 5, 6}; + NoElements) { + std::vector v = {0, 1, 2, 3, 4, 5, 6}; - FilterView fv(v.begin(), v.end(), [](int x) { return x > 10; }); + FilterView fv(v.begin(), v.end(), [](int x) { return x > 10; }); - std::vector actual; - for (auto x : fv) - actual.push_back(x); + std::vector actual; + for (auto x : fv) + actual.push_back(x); - EXPECT_EQ(actual, (std::vector{})); + EXPECT_EQ(actual, (std::vector{})); } diff --git a/tests/Pog/Grammar.cpp b/tests/Pog/Grammar.cpp index 0c1239e9..3fb1d576 100644 --- a/tests/Pog/Grammar.cpp +++ b/tests/Pog/Grammar.cpp @@ -7,181 +7,181 @@ using namespace pog; class TestGrammar : public ::testing::Test {}; TEST_F(TestGrammar, -DefaultGrammar) { - Grammar g; + DefaultGrammar) { + Grammar g; - EXPECT_EQ(g.get_symbols().size(), 2u); - EXPECT_EQ(g.get_rules().size(), 0u); + EXPECT_EQ(g.get_symbols().size(), 2u); + EXPECT_EQ(g.get_rules().size(), 0u); - EXPECT_TRUE(g.get_symbols()[0]->is_nonterminal()); - EXPECT_EQ(g.get_symbols()[0]->get_name(), "@start"); + EXPECT_TRUE(g.get_symbols()[0]->is_nonterminal()); + EXPECT_EQ(g.get_symbols()[0]->get_name(), "@start"); - EXPECT_TRUE(g.get_symbols()[1]->is_end()); - EXPECT_EQ(g.get_symbols()[1]->get_name(), "@end"); + EXPECT_TRUE(g.get_symbols()[1]->is_end()); + EXPECT_EQ(g.get_symbols()[1]->get_name(), "@end"); - EXPECT_EQ(g.get_end_of_input_symbol(), g.get_symbols()[1].get()); - EXPECT_EQ(g.get_start_rule(), nullptr); + EXPECT_EQ(g.get_end_of_input_symbol(), g.get_symbols()[1].get()); + EXPECT_EQ(g.get_start_rule(), nullptr); } TEST_F(TestGrammar, -AddSymbol) { - Grammar g; + AddSymbol) { + Grammar g; - g.add_symbol(SymbolKind::Nonterminal, "A"); - g.add_symbol(SymbolKind::Nonterminal, "B"); + g.add_symbol(SymbolKind::Nonterminal, "A"); + g.add_symbol(SymbolKind::Nonterminal, "B"); - EXPECT_EQ(g.get_symbols().size(), 4u); + EXPECT_EQ(g.get_symbols().size(), 4u); } TEST_F(TestGrammar, -AddSymbolDuplicate) { - Grammar g; + AddSymbolDuplicate) { + Grammar g; - g.add_symbol(SymbolKind::Nonterminal, "A"); - g.add_symbol(SymbolKind::Terminal, "A"); + g.add_symbol(SymbolKind::Nonterminal, "A"); + g.add_symbol(SymbolKind::Terminal, "A"); - EXPECT_EQ(g.get_symbols().size(), 3u); + EXPECT_EQ(g.get_symbols().size(), 3u); } TEST_F(TestGrammar, -GetSymbol) { - Grammar g; + GetSymbol) { + Grammar g; - auto sym = g.add_symbol(SymbolKind::Nonterminal, "A"); - EXPECT_EQ(g.get_symbol("A"), sym); - EXPECT_EQ(g.get_symbol("B"), nullptr); + auto sym = g.add_symbol(SymbolKind::Nonterminal, "A"); + EXPECT_EQ(g.get_symbol("A"), sym); + EXPECT_EQ(g.get_symbol("B"), nullptr); } TEST_F(TestGrammar, -AddRule) { - Grammar g; + AddRule) { + Grammar g; - auto s1 = g.add_symbol(SymbolKind::Nonterminal, "A"); - auto s2 = g.add_symbol(SymbolKind::Nonterminal, "B"); - auto s3 = g.add_symbol(SymbolKind::Nonterminal, "C"); + auto s1 = g.add_symbol(SymbolKind::Nonterminal, "A"); + auto s2 = g.add_symbol(SymbolKind::Nonterminal, "B"); + auto s3 = g.add_symbol(SymbolKind::Nonterminal, "C"); - auto result = g.add_rule(s1, std::vector*>{s2, s3}, [](auto&&...) -> int { return 0; }); - EXPECT_EQ(g.get_rules().size(), 1u); - EXPECT_EQ(result->get_lhs(), s1); - EXPECT_EQ(result->get_rhs(), (std::vector*>{s2, s3})); + auto result = g.add_rule(s1, std::vector*>{s2, s3}, [](auto&&...) -> int { return 0; }); + EXPECT_EQ(g.get_rules().size(), 1u); + EXPECT_EQ(result->get_lhs(), s1); + EXPECT_EQ(result->get_rhs(), (std::vector*>{s2, s3})); } TEST_F(TestGrammar, -GetRulesOfSymbol) { - Grammar g; + GetRulesOfSymbol) { + Grammar g; - auto s1 = g.add_symbol(SymbolKind::Nonterminal, "A"); - auto s2 = g.add_symbol(SymbolKind::Nonterminal, "B"); - auto s3 = g.add_symbol(SymbolKind::Nonterminal, "C"); + auto s1 = g.add_symbol(SymbolKind::Nonterminal, "A"); + auto s2 = g.add_symbol(SymbolKind::Nonterminal, "B"); + auto s3 = g.add_symbol(SymbolKind::Nonterminal, "C"); - auto r1 = g.add_rule(s1, std::vector*>{s2, s3}, [](auto&&...) -> int { return 0; }); - auto r2 = g.add_rule(s1, std::vector*>{}, [](auto&&...) -> int { return 0; }); - auto r3 = g.add_rule(s2, std::vector*>{s1, s3}, [](auto&&...) -> int { return 0; }); + auto r1 = g.add_rule(s1, std::vector*>{s2, s3}, [](auto&&...) -> int { return 0; }); + auto r2 = g.add_rule(s1, std::vector*>{}, [](auto&&...) -> int { return 0; }); + auto r3 = g.add_rule(s2, std::vector*>{s1, s3}, [](auto&&...) -> int { return 0; }); - EXPECT_EQ(g.get_rules().size(), 3u); - EXPECT_EQ(g.get_rules_of_symbol(s1), (std::vector*>{r1, r2})); - EXPECT_EQ(g.get_rules_of_symbol(s2), (std::vector*>{r3})); - EXPECT_EQ(g.get_rules_of_symbol(s3), (std::vector*>{})); + EXPECT_EQ(g.get_rules().size(), 3u); + EXPECT_EQ(g.get_rules_of_symbol(s1), (std::vector*>{r1, r2})); + EXPECT_EQ(g.get_rules_of_symbol(s2), (std::vector*>{r3})); + EXPECT_EQ(g.get_rules_of_symbol(s3), (std::vector*>{})); } TEST_F(TestGrammar, -GetRulesWithSymbol) { - Grammar g; - - auto s1 = g.add_symbol(SymbolKind::Nonterminal, "A"); - auto s2 = g.add_symbol(SymbolKind::Nonterminal, "B"); - auto s3 = g.add_symbol(SymbolKind::Nonterminal, "C"); - - auto r1 = g.add_rule(s1, std::vector*>{s2, s3}, [](auto&&...) -> int { return 0; }); - auto r2 = g.add_rule(s1, std::vector*>{}, [](auto&&...) -> int { return 0; }); - auto r3 = g.add_rule(s2, std::vector*>{s1, s3}, [](auto&&...) -> int { return 0; }); - static_cast(r2); - - EXPECT_EQ(g.get_rules().size(), 3u); - EXPECT_EQ(g.get_rules_with_symbol(s1), (std::vector*>{r3})); - EXPECT_EQ(g.get_rules_with_symbol(s2), (std::vector*>{r1})); - EXPECT_EQ(g.get_rules_with_symbol(s3), (std::vector*>{r1, r3})); + GetRulesWithSymbol) { + Grammar g; + + auto s1 = g.add_symbol(SymbolKind::Nonterminal, "A"); + auto s2 = g.add_symbol(SymbolKind::Nonterminal, "B"); + auto s3 = g.add_symbol(SymbolKind::Nonterminal, "C"); + + auto r1 = g.add_rule(s1, std::vector*>{s2, s3}, [](auto&&...) -> int { return 0; }); + auto r2 = g.add_rule(s1, std::vector*>{}, [](auto&&...) -> int { return 0; }); + auto r3 = g.add_rule(s2, std::vector*>{s1, s3}, [](auto&&...) -> int { return 0; }); + static_cast(r2); + + EXPECT_EQ(g.get_rules().size(), 3u); + EXPECT_EQ(g.get_rules_with_symbol(s1), (std::vector*>{r3})); + EXPECT_EQ(g.get_rules_with_symbol(s2), (std::vector*>{r1})); + EXPECT_EQ(g.get_rules_with_symbol(s3), (std::vector*>{r1, r3})); } TEST_F(TestGrammar, -StartSymbol) { - Grammar g; + StartSymbol) { + Grammar g; - auto s = g.add_symbol(SymbolKind::Nonterminal, "A"); - g.set_start_symbol(s); + auto s = g.add_symbol(SymbolKind::Nonterminal, "A"); + g.set_start_symbol(s); - EXPECT_EQ(g.get_rules().size(), 1u); - EXPECT_EQ(g.get_rules()[0]->to_string(), "@start -> A @end"); - EXPECT_EQ(g.get_rules()[0].get(), g.get_start_rule()); + EXPECT_EQ(g.get_rules().size(), 1u); + EXPECT_EQ(g.get_rules()[0]->to_string(), "@start -> A @end"); + EXPECT_EQ(g.get_rules()[0].get(), g.get_start_rule()); } TEST_F(TestGrammar, -Empty) { - Grammar g; - - auto a = g.add_symbol(SymbolKind::Terminal, "a"); - auto b = g.add_symbol(SymbolKind::Terminal, "b"); - auto S = g.add_symbol(SymbolKind::Nonterminal, "S"); - auto A = g.add_symbol(SymbolKind::Nonterminal, "A"); - - g.add_rule(S, std::vector*>{a, S, b}, [](auto&&...) -> int { return 0; }); - g.add_rule(S, std::vector*>{a, b}, [](auto&&...) -> int { return 0; }); - g.add_rule(A, std::vector*>{a}, [](auto&&...) -> int { return 0; }); - g.add_rule(A, std::vector*>{}, [](auto&&...) -> int { return 0; }); - - EXPECT_FALSE(g.empty(a)); - EXPECT_FALSE(g.empty(b)); - EXPECT_FALSE(g.empty(S)); - EXPECT_TRUE(g.empty(A)); - - EXPECT_TRUE(g.empty(std::vector*>{A, A, A})); - EXPECT_FALSE(g.empty(std::vector*>{A, A, A, S})); + Empty) { + Grammar g; + + auto a = g.add_symbol(SymbolKind::Terminal, "a"); + auto b = g.add_symbol(SymbolKind::Terminal, "b"); + auto S = g.add_symbol(SymbolKind::Nonterminal, "S"); + auto A = g.add_symbol(SymbolKind::Nonterminal, "A"); + + g.add_rule(S, std::vector*>{a, S, b}, [](auto&&...) -> int { return 0; }); + g.add_rule(S, std::vector*>{a, b}, [](auto&&...) -> int { return 0; }); + g.add_rule(A, std::vector*>{a}, [](auto&&...) -> int { return 0; }); + g.add_rule(A, std::vector*>{}, [](auto&&...) -> int { return 0; }); + + EXPECT_FALSE(g.empty(a)); + EXPECT_FALSE(g.empty(b)); + EXPECT_FALSE(g.empty(S)); + EXPECT_TRUE(g.empty(A)); + + EXPECT_TRUE(g.empty(std::vector*>{A, A, A})); + EXPECT_FALSE(g.empty(std::vector*>{A, A, A, S})); } TEST_F(TestGrammar, -First) { - Grammar g; - - auto a = g.add_symbol(SymbolKind::Terminal, "a"); - auto b = g.add_symbol(SymbolKind::Terminal, "b"); - auto S = g.add_symbol(SymbolKind::Nonterminal, "S"); - auto A = g.add_symbol(SymbolKind::Nonterminal, "A"); - - g.add_rule(S, std::vector*>{a, S, b}, [](auto&&...) -> int { return 0; }); - g.add_rule(S, std::vector*>{a, b}, [](auto&&...) -> int { return 0; }); - g.add_rule(S, std::vector*>{b}, [](auto&&...) -> int { return 0; }); - g.add_rule(A, std::vector*>{a}, [](auto&&...) -> int { return 0; }); - g.add_rule(A, std::vector*>{}, [](auto&&...) -> int { return 0; }); - - EXPECT_EQ(g.first(a), (std::unordered_set*>{a})); - EXPECT_EQ(g.first(b), (std::unordered_set*>{b})); - EXPECT_EQ(g.first(S), (std::unordered_set*>{a, b})); - EXPECT_EQ(g.first(A), (std::unordered_set*>{a})); - - EXPECT_EQ(g.first(std::vector*>{A, A, A}), (std::unordered_set*>{a})); - EXPECT_EQ(g.first(std::vector*>{A, A, A, S}), (std::unordered_set*>{a, b})); - EXPECT_EQ(g.first(std::vector*>{b, A, A, S}), (std::unordered_set*>{b})); + First) { + Grammar g; + + auto a = g.add_symbol(SymbolKind::Terminal, "a"); + auto b = g.add_symbol(SymbolKind::Terminal, "b"); + auto S = g.add_symbol(SymbolKind::Nonterminal, "S"); + auto A = g.add_symbol(SymbolKind::Nonterminal, "A"); + + g.add_rule(S, std::vector*>{a, S, b}, [](auto&&...) -> int { return 0; }); + g.add_rule(S, std::vector*>{a, b}, [](auto&&...) -> int { return 0; }); + g.add_rule(S, std::vector*>{b}, [](auto&&...) -> int { return 0; }); + g.add_rule(A, std::vector*>{a}, [](auto&&...) -> int { return 0; }); + g.add_rule(A, std::vector*>{}, [](auto&&...) -> int { return 0; }); + + EXPECT_EQ(g.first(a), (std::unordered_set*>{a})); + EXPECT_EQ(g.first(b), (std::unordered_set*>{b})); + EXPECT_EQ(g.first(S), (std::unordered_set*>{a, b})); + EXPECT_EQ(g.first(A), (std::unordered_set*>{a})); + + EXPECT_EQ(g.first(std::vector*>{A, A, A}), (std::unordered_set*>{a})); + EXPECT_EQ(g.first(std::vector*>{A, A, A, S}), (std::unordered_set*>{a, b})); + EXPECT_EQ(g.first(std::vector*>{b, A, A, S}), (std::unordered_set*>{b})); } TEST_F(TestGrammar, -Follow) { - Grammar g; - - auto a = g.add_symbol(SymbolKind::Terminal, "a"); - auto b = g.add_symbol(SymbolKind::Terminal, "b"); - auto S = g.add_symbol(SymbolKind::Nonterminal, "S"); - auto A = g.add_symbol(SymbolKind::Nonterminal, "A"); - - g.add_rule(S, std::vector*>{a, S, b}, [](auto&&...) -> int { return 0; }); - g.add_rule(S, std::vector*>{a, b}, [](auto&&...) -> int { return 0; }); - g.add_rule(S, std::vector*>{b}, [](auto&&...) -> int { return 0; }); - g.add_rule(A, std::vector*>{a, A}, [](auto&&...) -> int { return 0; }); - g.add_rule(A, std::vector*>{}, [](auto&&...) -> int { return 0; }); - - EXPECT_EQ(g.follow(S), (std::unordered_set*>{b})); - EXPECT_EQ(g.follow(A), (std::unordered_set*>{})); - - // To test out caching - EXPECT_EQ(g.follow(S), (std::unordered_set*>{b})); - EXPECT_EQ(g.follow(A), (std::unordered_set*>{})); + Follow) { + Grammar g; + + auto a = g.add_symbol(SymbolKind::Terminal, "a"); + auto b = g.add_symbol(SymbolKind::Terminal, "b"); + auto S = g.add_symbol(SymbolKind::Nonterminal, "S"); + auto A = g.add_symbol(SymbolKind::Nonterminal, "A"); + + g.add_rule(S, std::vector*>{a, S, b}, [](auto&&...) -> int { return 0; }); + g.add_rule(S, std::vector*>{a, b}, [](auto&&...) -> int { return 0; }); + g.add_rule(S, std::vector*>{b}, [](auto&&...) -> int { return 0; }); + g.add_rule(A, std::vector*>{a, A}, [](auto&&...) -> int { return 0; }); + g.add_rule(A, std::vector*>{}, [](auto&&...) -> int { return 0; }); + + EXPECT_EQ(g.follow(S), (std::unordered_set*>{b})); + EXPECT_EQ(g.follow(A), (std::unordered_set*>{})); + + // To test out caching + EXPECT_EQ(g.follow(S), (std::unordered_set*>{b})); + EXPECT_EQ(g.follow(A), (std::unordered_set*>{})); } diff --git a/tests/Pog/Item.cpp b/tests/Pog/Item.cpp index ea16c301..b1251bef 100644 --- a/tests/Pog/Item.cpp +++ b/tests/Pog/Item.cpp @@ -7,230 +7,230 @@ using namespace pog; class TestItem : public ::testing::Test {}; TEST_F(TestItem, -SimpleItem) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item(&rule); + SimpleItem) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item(&rule); - EXPECT_EQ(item.get_rule(), &rule); - EXPECT_EQ(item.get_read_pos(), 0u); - EXPECT_EQ(item.get_previous_symbol(), nullptr); - EXPECT_EQ(item.get_read_symbol(), &s2); + EXPECT_EQ(item.get_rule(), &rule); + EXPECT_EQ(item.get_read_pos(), 0u); + EXPECT_EQ(item.get_previous_symbol(), nullptr); + EXPECT_EQ(item.get_read_symbol(), &s2); - EXPECT_FALSE(item.is_kernel()); - EXPECT_FALSE(item.is_final()); - EXPECT_FALSE(item.is_accepting()); + EXPECT_FALSE(item.is_kernel()); + EXPECT_FALSE(item.is_final()); + EXPECT_FALSE(item.is_accepting()); } TEST_F(TestItem, -SimpleItemWithReadPosShifted) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item(&rule, 1); + SimpleItemWithReadPosShifted) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item(&rule, 1); - EXPECT_EQ(item.get_rule(), &rule); - EXPECT_EQ(item.get_read_pos(), 1u); - EXPECT_EQ(item.get_previous_symbol(), &s2); - EXPECT_EQ(item.get_read_symbol(), &s3); + EXPECT_EQ(item.get_rule(), &rule); + EXPECT_EQ(item.get_read_pos(), 1u); + EXPECT_EQ(item.get_previous_symbol(), &s2); + EXPECT_EQ(item.get_read_symbol(), &s3); - EXPECT_TRUE(item.is_kernel()); - EXPECT_FALSE(item.is_final()); - EXPECT_FALSE(item.is_accepting()); + EXPECT_TRUE(item.is_kernel()); + EXPECT_FALSE(item.is_final()); + EXPECT_FALSE(item.is_accepting()); } TEST_F(TestItem, -SimpleItemWithReadPosAtTheEnd) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item(&rule, 2); + SimpleItemWithReadPosAtTheEnd) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item(&rule, 2); - EXPECT_EQ(item.get_rule(), &rule); - EXPECT_EQ(item.get_read_pos(), 2u); - EXPECT_EQ(item.get_previous_symbol(), &s3); - EXPECT_EQ(item.get_read_symbol(), nullptr); + EXPECT_EQ(item.get_rule(), &rule); + EXPECT_EQ(item.get_read_pos(), 2u); + EXPECT_EQ(item.get_previous_symbol(), &s3); + EXPECT_EQ(item.get_read_symbol(), nullptr); - EXPECT_TRUE(item.is_kernel()); - EXPECT_TRUE(item.is_final()); - EXPECT_FALSE(item.is_accepting()); + EXPECT_TRUE(item.is_kernel()); + EXPECT_TRUE(item.is_final()); + EXPECT_FALSE(item.is_accepting()); } TEST_F(TestItem, -SimpleAcceptingItem) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::End, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item(&rule, 1); + SimpleAcceptingItem) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::End, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item(&rule, 1); - EXPECT_EQ(item.get_rule(), &rule); - EXPECT_EQ(item.get_read_pos(), 1u); - EXPECT_EQ(item.get_previous_symbol(), &s2); - EXPECT_EQ(item.get_read_symbol(), &s3); + EXPECT_EQ(item.get_rule(), &rule); + EXPECT_EQ(item.get_read_pos(), 1u); + EXPECT_EQ(item.get_previous_symbol(), &s2); + EXPECT_EQ(item.get_read_symbol(), &s3); - EXPECT_TRUE(item.is_kernel()); - EXPECT_FALSE(item.is_final()); - EXPECT_TRUE(item.is_accepting()); + EXPECT_TRUE(item.is_kernel()); + EXPECT_FALSE(item.is_final()); + EXPECT_TRUE(item.is_accepting()); } TEST_F(TestItem, -LeftSideWithoutReadSymbol) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item(&rule, 1); + LeftSideWithoutReadSymbol) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item(&rule, 1); - EXPECT_EQ(item.get_left_side_without_read_symbol(), std::vector*>{&s2}); + EXPECT_EQ(item.get_left_side_without_read_symbol(), std::vector*>{&s2}); } TEST_F(TestItem, -LeftSideWithoutReadSymbolWhenReadPosAtStart) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item(&rule, 0); + LeftSideWithoutReadSymbolWhenReadPosAtStart) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item(&rule, 0); - EXPECT_EQ(item.get_left_side_without_read_symbol(), std::vector*>{}); + EXPECT_EQ(item.get_left_side_without_read_symbol(), std::vector*>{}); } TEST_F(TestItem, -RightSideWithoutReadSymbol) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item(&rule, 0); + RightSideWithoutReadSymbol) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item(&rule, 0); - EXPECT_EQ(item.get_right_side_without_read_symbol(), std::vector*>{&s3}); + EXPECT_EQ(item.get_right_side_without_read_symbol(), std::vector*>{&s3}); } TEST_F(TestItem, -RightSideWithoutReadSymbolWhenNothingIsReturned) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item(&rule, 1); + RightSideWithoutReadSymbolWhenNothingIsReturned) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item(&rule, 1); - EXPECT_EQ(item.get_right_side_without_read_symbol(), std::vector*>{}); + EXPECT_EQ(item.get_right_side_without_read_symbol(), std::vector*>{}); } TEST_F(TestItem, -Step) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item(&rule, 0); + Step) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item(&rule, 0); - item.step(); - EXPECT_EQ(item.get_read_pos(), 1u); - item.step(); - EXPECT_EQ(item.get_read_pos(), 2u); - item.step(); - EXPECT_EQ(item.get_read_pos(), 2u); + item.step(); + EXPECT_EQ(item.get_read_pos(), 1u); + item.step(); + EXPECT_EQ(item.get_read_pos(), 2u); + item.step(); + EXPECT_EQ(item.get_read_pos(), 2u); } TEST_F(TestItem, -StepBack) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item(&rule, 2); + StepBack) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item(&rule, 2); - item.step_back(); - EXPECT_EQ(item.get_read_pos(), 1u); - item.step_back(); - EXPECT_EQ(item.get_read_pos(), 0u); - item.step_back(); - EXPECT_EQ(item.get_read_pos(), 0u); + item.step_back(); + EXPECT_EQ(item.get_read_pos(), 1u); + item.step_back(); + EXPECT_EQ(item.get_read_pos(), 0u); + item.step_back(); + EXPECT_EQ(item.get_read_pos(), 0u); } TEST_F(TestItem, -ToString) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item(&rule, 1); + ToString) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item(&rule, 1); - EXPECT_EQ(item.to_string(), "1 -> 2 <*> 3"); + EXPECT_EQ(item.to_string(), "1 -> 2 <*> 3"); } TEST_F(TestItem, -EpsilonToString) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Rule rule(42, &s1, std::vector*>{}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item(&rule, 0); + EpsilonToString) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Rule rule(42, &s1, std::vector*>{}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item(&rule, 0); - EXPECT_EQ(item.to_string(), "1 -> <*> "); + EXPECT_EQ(item.to_string(), "1 -> <*> "); } TEST_F(TestItem, -Equality) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule1(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Rule rule2(42, &s1, std::vector*>{&s2}, [](Parser&, std::vector>&&) -> int { return 0; }); - Rule rule3(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item1(&rule1, 1); - Item item2(&rule2, 1); - Item item3(&rule3, 1); + Equality) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule1(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Rule rule2(42, &s1, std::vector*>{&s2}, [](Parser&, std::vector>&&) -> int { return 0; }); + Rule rule3(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item1(&rule1, 1); + Item item2(&rule2, 1); + Item item3(&rule3, 1); - EXPECT_TRUE(item1 == item2); - EXPECT_FALSE(item1 == item3); + EXPECT_TRUE(item1 == item2); + EXPECT_FALSE(item1 == item3); - EXPECT_FALSE(item1 != item2); - EXPECT_TRUE(item1 != item3); + EXPECT_FALSE(item1 != item2); + EXPECT_TRUE(item1 != item3); - item1.step(); - EXPECT_FALSE(item1 == item2); + item1.step(); + EXPECT_FALSE(item1 == item2); } TEST_F(TestItem, -LessThanDifferentRule) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule1(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Rule rule2(41, &s1, std::vector*>{&s2}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item1(&rule1, 0); - Item item2(&rule2, 0); + LessThanDifferentRule) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule1(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Rule rule2(41, &s1, std::vector*>{&s2}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item1(&rule1, 0); + Item item2(&rule2, 0); - EXPECT_FALSE(item1 < item2); + EXPECT_FALSE(item1 < item2); } TEST_F(TestItem, -LessThanDifferentReadPos) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule1(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Rule rule2(42, &s1, std::vector*>{&s2}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item1(&rule1, 0); - Item item2(&rule2, 1); + LessThanDifferentReadPos) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule1(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Rule rule2(42, &s1, std::vector*>{&s2}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item1(&rule1, 0); + Item item2(&rule2, 1); - EXPECT_FALSE(item1 < item2); + EXPECT_FALSE(item1 < item2); } TEST_F(TestItem, -LessThanWithKernelItemPriority) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule1(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); - Rule rule2(41, &s1, std::vector*>{&s2}, [](Parser&, std::vector>&&) -> int { return 0; }); - Item item1(&rule1, 1); - Item item2(&rule2, 0); + LessThanWithKernelItemPriority) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule1(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, std::vector>&&) -> int { return 0; }); + Rule rule2(41, &s1, std::vector*>{&s2}, [](Parser&, std::vector>&&) -> int { return 0; }); + Item item1(&rule1, 1); + Item item2(&rule2, 0); - EXPECT_TRUE(item1 < item2); + EXPECT_TRUE(item1 < item2); } diff --git a/tests/Pog/Parser.cpp b/tests/Pog/Parser.cpp index ed119afe..cdc6922b 100644 --- a/tests/Pog/Parser.cpp +++ b/tests/Pog/Parser.cpp @@ -8,912 +8,869 @@ using namespace ::testing; class TestParser : public ::testing::Test {}; TEST_F(TestParser, -RepeatingAs) { - Parser p; - - p.token("a").symbol("a"); - - p.set_start_symbol("A"); - p.rule("A") - .production("A", "a", [](Parser&, auto&& args) { - return 1 + args[0].value; - }) - .production("a", [](Parser&, auto&&) { - return 1; - }); - EXPECT_TRUE(p.prepare()); - - std::string input1("a"); - auto result = p.parse(input1); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 1); - - std::string input2("aaaa"); - result = p.parse(input2); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 4); - - try - { - std::string input3("aa aaa"); - p.parse(input3); - FAIL() << "Expected syntax error"; - } - catch (const SyntaxError& e) - { - EXPECT_STREQ(e.what(), "Syntax error: Unknown symbol on input, expected one of @end, a"); - } + RepeatingAs) { + Parser p; + + p.token("a").symbol("a"); + + p.set_start_symbol("A"); + p.rule("A") + .production("A", "a", [](Parser&, auto&& args) { + return 1 + args[0].value; + }) + .production("a", [](Parser&, auto&&) { + return 1; + }); + EXPECT_TRUE(p.prepare()); + + std::string input1("a"); + auto result = p.parse(input1); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 1); + + std::string input2("aaaa"); + result = p.parse(input2); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 4); + + try { + std::string input3("aa aaa"); + p.parse(input3); + FAIL() << "Expected syntax error"; + } catch (const SyntaxError& e) { + EXPECT_STREQ(e.what(), "Syntax error: Unknown symbol on input, expected one of @end, a"); + } } TEST_F(TestParser, -RepeatingAsWithIgnoringWhitespaces) { - Parser p; - - p.token(R"(\s+)"); - p.token("a").symbol("a"); - - p.set_start_symbol("A"); - p.rule("A") - .production("A", "a", [](Parser&, auto&& args) { - return 1 + args[0].value; - }) - .production("a", [](Parser&, auto&&) { - return 1; - }); - EXPECT_TRUE(p.prepare()); - - std::string input1("a"); - auto result = p.parse(input1); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 1); - - std::string input2("aaaa"); - result = p.parse(input2); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 4); - - std::string input3("aa aaa"); - result = p.parse(input3); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 5); + RepeatingAsWithIgnoringWhitespaces) { + Parser p; + + p.token(R"(\s+)"); + p.token("a").symbol("a"); + + p.set_start_symbol("A"); + p.rule("A") + .production("A", "a", [](Parser&, auto&& args) { + return 1 + args[0].value; + }) + .production("a", [](Parser&, auto&&) { + return 1; + }); + EXPECT_TRUE(p.prepare()); + + std::string input1("a"); + auto result = p.parse(input1); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 1); + + std::string input2("aaaa"); + result = p.parse(input2); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 4); + + std::string input3("aa aaa"); + result = p.parse(input3); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 5); } TEST_F(TestParser, -SameNumberOfAsAndBs) { - Parser p; - - p.token("a").symbol("a"); - p.token("b").symbol("b"); - - p.set_start_symbol("S"); - p.rule("S") - .production("a", "S", "b", [](Parser&, auto&& args) { - return 1 + args[1].value; - }) - .production("a", "b", [](Parser&, auto&&) { - return 1; - }); - EXPECT_TRUE(p.prepare()); - - std::string input1("ab"); - auto result = p.parse(input1); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 1); - - std::string input2("aaabbb"); - result = p.parse(input2); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 3); - - try - { - std::string input3("aabbb"); - p.parse(input3); - FAIL() << "Expected syntax error"; - } - catch (const SyntaxError& e) - { - EXPECT_STREQ(e.what(), "Syntax error: Unexpected b, expected one of @end"); - } - - try - { - std::string input4("aaabb"); - p.parse(input4); - FAIL() << "Expected syntax error"; - } - catch (const SyntaxError& e) - { - EXPECT_STREQ(e.what(), "Syntax error: Unexpected @end, expected one of b"); - } + SameNumberOfAsAndBs) { + Parser p; + + p.token("a").symbol("a"); + p.token("b").symbol("b"); + + p.set_start_symbol("S"); + p.rule("S") + .production("a", "S", "b", [](Parser&, auto&& args) { + return 1 + args[1].value; + }) + .production("a", "b", [](Parser&, auto&&) { + return 1; + }); + EXPECT_TRUE(p.prepare()); + + std::string input1("ab"); + auto result = p.parse(input1); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 1); + + std::string input2("aaabbb"); + result = p.parse(input2); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 3); + + try { + std::string input3("aabbb"); + p.parse(input3); + FAIL() << "Expected syntax error"; + } catch (const SyntaxError& e) { + EXPECT_STREQ(e.what(), "Syntax error: Unexpected b, expected one of @end"); + } + + try { + std::string input4("aaabb"); + p.parse(input4); + FAIL() << "Expected syntax error"; + } catch (const SyntaxError& e) { + EXPECT_STREQ(e.what(), "Syntax error: Unexpected @end, expected one of b"); + } } TEST_F(TestParser, -SymbolDescriptionInErrorMessages) { - Parser p; - - p.token("a").symbol("a"); - p.token("b").symbol("b").description("symbol_b"); - - p.set_start_symbol("S"); - p.rule("S") - .production("a", "S", "b", [](Parser&, auto&& args) { - return 1 + args[1].value; - }) - .production("a", "b", [](Parser&, auto&&) { - return 1; - }); - EXPECT_TRUE(p.prepare()); - - std::string input1("ab"); - auto result = p.parse(input1); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 1); - - std::string input2("aaabbb"); - result = p.parse(input2); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 3); - - try - { - std::string input3("aabbb"); - p.parse(input3); - FAIL() << "Expected syntax error"; - } - catch (const SyntaxError& e) - { - EXPECT_STREQ(e.what(), "Syntax error: Unexpected symbol_b, expected one of @end"); - } - - try - { - std::string input4("aaabb"); - p.parse(input4); - FAIL() << "Expected syntax error"; - } - catch (const SyntaxError& e) - { - EXPECT_STREQ(e.what(), "Syntax error: Unexpected @end, expected one of symbol_b"); - } + SymbolDescriptionInErrorMessages) { + Parser p; + + p.token("a").symbol("a"); + p.token("b").symbol("b").description("symbol_b"); + + p.set_start_symbol("S"); + p.rule("S") + .production("a", "S", "b", [](Parser&, auto&& args) { + return 1 + args[1].value; + }) + .production("a", "b", [](Parser&, auto&&) { + return 1; + }); + EXPECT_TRUE(p.prepare()); + + std::string input1("ab"); + auto result = p.parse(input1); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 1); + + std::string input2("aaabbb"); + result = p.parse(input2); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 3); + + try { + std::string input3("aabbb"); + p.parse(input3); + FAIL() << "Expected syntax error"; + } catch (const SyntaxError& e) { + EXPECT_STREQ(e.what(), "Syntax error: Unexpected symbol_b, expected one of @end"); + } + + try { + std::string input4("aaabb"); + p.parse(input4); + FAIL() << "Expected syntax error"; + } catch (const SyntaxError& e) { + EXPECT_STREQ(e.what(), "Syntax error: Unexpected @end, expected one of symbol_b"); + } } TEST_F(TestParser, -LalrButNotLrNorNqlalr) { - Parser p; - - p.token("a").symbol("a"); - p.token("b").symbol("b"); - p.token("c").symbol("c"); - p.token("d").symbol("d"); - p.token("g").symbol("g"); - - p.set_start_symbol("S"); - p.rule("S") - .production("a", "g", "d") - .production("a", "A", "c") - .production("b", "A", "d") - .production("b", "g", "c"); - p.rule("A") - .production("B"); - p.rule("B") - .production("g"); - EXPECT_TRUE(p.prepare()); - - std::string input("agc"); - auto result = p.parse(input); - EXPECT_TRUE(result); + LalrButNotLrNorNqlalr) { + Parser p; + + p.token("a").symbol("a"); + p.token("b").symbol("b"); + p.token("c").symbol("c"); + p.token("d").symbol("d"); + p.token("g").symbol("g"); + + p.set_start_symbol("S"); + p.rule("S") + .production("a", "g", "d") + .production("a", "A", "c") + .production("b", "A", "d") + .production("b", "g", "c"); + p.rule("A") + .production("B"); + p.rule("B") + .production("g"); + EXPECT_TRUE(p.prepare()); + + std::string input("agc"); + auto result = p.parse(input); + EXPECT_TRUE(result); } TEST_F(TestParser, -Precedence) { - Parser p; - - p.token(R"(\s+)"); - p.token(R"(\+)").symbol("+").precedence(0, Associativity::Left); - p.token(R"(-)").symbol("-").precedence(0, Associativity::Left); - p.token(R"(\*)").symbol("*").precedence(1, Associativity::Left); - p.token("[0-9]+").symbol("int").action([](std::string_view str) { - return std::stoi(std::string{str}); - }); - - p.set_start_symbol("E"); - p.rule("E") - .production("E", "+", "E", [](Parser&, auto&& args) { - return args[0].value + args[2].value; - }) - .production("E", "-", "E", [](Parser&, auto&& args) { - return args[0].value - args[2].value; - }) - .production("E", "*", "E", [](Parser&, auto&& args) { - return args[0].value * args[2].value; - }) - .production("-", "E", [](Parser&, auto&& args) { - return -args[1].value; - }).precedence(2, Associativity::Right) - .production("int", [](Parser&, auto&& args) { - return args[0].value; - }); - EXPECT_TRUE(p.prepare()); - - std::string input1("2 + 3 * 4 + 5"); - auto result = p.parse(input1); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 19); - - std::string input2("-5 - 3 - -10"); - result = p.parse(input2); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 2); - - std::string input3("5 + -3 * 10"); - result = p.parse(input3); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), -25); + Precedence) { + Parser p; + + p.token(R"(\s+)"); + p.token(R"(\+)").symbol("+").precedence(0, Associativity::Left); + p.token(R"(-)").symbol("-").precedence(0, Associativity::Left); + p.token(R"(\*)").symbol("*").precedence(1, Associativity::Left); + p.token("[0-9]+").symbol("int").action([](std::string_view str) { + return std::stoi(std::string{str}); + }); + + p.set_start_symbol("E"); + p.rule("E") + .production("E", "+", "E", [](Parser&, auto&& args) { + return args[0].value + args[2].value; + }) + .production("E", "-", "E", [](Parser&, auto&& args) { + return args[0].value - args[2].value; + }) + .production("E", "*", "E", [](Parser&, auto&& args) { + return args[0].value * args[2].value; + }) + .production("-", "E", [](Parser&, auto&& args) { + return -args[1].value; + }) + .precedence(2, Associativity::Right) + .production("int", [](Parser&, auto&& args) { + return args[0].value; + }); + EXPECT_TRUE(p.prepare()); + + std::string input1("2 + 3 * 4 + 5"); + auto result = p.parse(input1); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 19); + + std::string input2("-5 - 3 - -10"); + result = p.parse(input2); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 2); + + std::string input3("5 + -3 * 10"); + result = p.parse(input3); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), -25); } TEST_F(TestParser, -Conflicts1) { - Parser p; - - p.token("a").symbol("a"); - - p.set_start_symbol("sequence"); - p.rule("sequence") - .production("sequence", "a") - .production("maybea") - .production(); - p.rule("maybea") - .production("a") - .production(); - - auto report = p.prepare(); - EXPECT_FALSE(report); - EXPECT_EQ(report.number_of_issues(), 3u); - EXPECT_EQ(report.to_string(), - "Shift-reduce conflict of symbol 'a' and rule 'sequence -> ' in state 0\n" - "Reduce-reduce conflict of rule 'sequence -> ' and rule 'maybea -> ' in state 0\n" - "Shift-reduce conflict of symbol 'a' and rule 'maybea -> ' in state 0" - ); + Conflicts1) { + Parser p; + + p.token("a").symbol("a"); + + p.set_start_symbol("sequence"); + p.rule("sequence") + .production("sequence", "a") + .production("maybea") + .production(); + p.rule("maybea") + .production("a") + .production(); + + auto report = p.prepare(); + EXPECT_FALSE(report); + EXPECT_EQ(report.number_of_issues(), 3u); + EXPECT_EQ(report.to_string(), + "Shift-reduce conflict of symbol 'a' and rule 'sequence -> ' in state 0\n" + "Reduce-reduce conflict of rule 'sequence -> ' and rule 'maybea -> ' in state 0\n" + "Shift-reduce conflict of symbol 'a' and rule 'maybea -> ' in state 0"); } TEST_F(TestParser, -Conflicts2) { - Parser p; - - p.token("b").symbol("b"); - p.token("c").symbol("c"); - - p.set_start_symbol("Y"); - p.rule("Y") - .production("c", "c", "Z", "b"); - p.rule("Z") - .production("c", "Z", "b") - .production("c", "Z") - .production(); - - auto report = p.prepare(); - EXPECT_FALSE(report); - EXPECT_EQ(report.number_of_issues(), 1u); - EXPECT_EQ(report.to_string(), "Shift-reduce conflict of symbol 'b' and rule 'Z -> c Z' in state 6"); + Conflicts2) { + Parser p; + + p.token("b").symbol("b"); + p.token("c").symbol("c"); + + p.set_start_symbol("Y"); + p.rule("Y") + .production("c", "c", "Z", "b"); + p.rule("Z") + .production("c", "Z", "b") + .production("c", "Z") + .production(); + + auto report = p.prepare(); + EXPECT_FALSE(report); + EXPECT_EQ(report.number_of_issues(), 1u); + EXPECT_EQ(report.to_string(), "Shift-reduce conflict of symbol 'b' and rule 'Z -> c Z' in state 6"); } TEST_F(TestParser, -Conflicts3) { - Parser> p; - - p.token("\\(").symbol("("); - p.token("\\)").symbol(")"); - p.token("a").symbol("a"); - - p.set_start_symbol("E"); - p.rule("E") - .production("(", "E", ")", [](Parser>&, auto&& args) { - args[1].value.push_back("E -> ( E )"); - return std::move(args[1].value); - }) - .production("PE", [](Parser>&, auto&& args) { - args[0].value.push_back("E -> PE"); - return std::move(args[0].value); - }); - p.rule("PE") - .production("(", "PE", ")", [](Parser>&, auto&& args) { - args[1].value.push_back("PE -> ( PE )"); - return std::move(args[1].value); - }) - .production("a", [](Parser>&, auto&&) { - return std::vector{"PE -> a"}; - }); - - auto report = p.prepare(); - EXPECT_FALSE(report); - EXPECT_EQ(report.number_of_issues(), 1u); - EXPECT_EQ(report.to_string(), "Shift-reduce conflict of symbol ')' and rule 'E -> PE' in state 6"); - - std::string input1("(((a)))"); - auto result = p.parse(input1); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), (std::vector{ - "PE -> a", - "PE -> ( PE )", - "PE -> ( PE )", - "PE -> ( PE )", - "E -> PE" - })); + Conflicts3) { + Parser> p; + + p.token("\\(").symbol("("); + p.token("\\)").symbol(")"); + p.token("a").symbol("a"); + + p.set_start_symbol("E"); + p.rule("E") + .production("(", "E", ")", [](Parser>&, auto&& args) { + args[1].value.push_back("E -> ( E )"); + return std::move(args[1].value); + }) + .production("PE", [](Parser>&, auto&& args) { + args[0].value.push_back("E -> PE"); + return std::move(args[0].value); + }); + p.rule("PE") + .production("(", "PE", ")", [](Parser>&, auto&& args) { + args[1].value.push_back("PE -> ( PE )"); + return std::move(args[1].value); + }) + .production("a", [](Parser>&, auto&&) { + return std::vector{"PE -> a"}; + }); + + auto report = p.prepare(); + EXPECT_FALSE(report); + EXPECT_EQ(report.number_of_issues(), 1u); + EXPECT_EQ(report.to_string(), "Shift-reduce conflict of symbol ')' and rule 'E -> PE' in state 6"); + + std::string input1("(((a)))"); + auto result = p.parse(input1); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), (std::vector{ + "PE -> a", + "PE -> ( PE )", + "PE -> ( PE )", + "PE -> ( PE )", + "E -> PE"})); } TEST_F(TestParser, -ResolveConflictWithPrecedence) { - Parser> p; - - p.token("\\(").symbol("("); - p.token("\\)").symbol(")").precedence(0, Associativity::Left); - p.token("a").symbol("a"); - - p.set_start_symbol("E"); - p.rule("E") - .production("(", "E", ")", [](Parser>&, auto&& args) { - args[1].value.push_back("E -> ( E )"); - return std::move(args[1].value); - }) - .production("PE", [](Parser>&, auto&& args) { - args[0].value.push_back("E -> PE"); - return std::move(args[0].value); - }).precedence(1, Associativity::Left); - p.rule("PE") - .production("(", "PE", ")", [](Parser>&, auto&& args) { - args[1].value.push_back("PE -> ( PE )"); - return std::move(args[1].value); - }) - .production("a", [](Parser>&, auto&&) { - return std::vector{"PE -> a"}; - }); - EXPECT_TRUE(p.prepare()); - - std::string input1("(((a)))"); - auto result = p.parse(input1); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), (std::vector{ - "PE -> a", - "E -> PE", - "E -> ( E )", - "E -> ( E )", - "E -> ( E )" - })); + ResolveConflictWithPrecedence) { + Parser> p; + + p.token("\\(").symbol("("); + p.token("\\)").symbol(")").precedence(0, Associativity::Left); + p.token("a").symbol("a"); + + p.set_start_symbol("E"); + p.rule("E") + .production("(", "E", ")", [](Parser>&, auto&& args) { + args[1].value.push_back("E -> ( E )"); + return std::move(args[1].value); + }) + .production("PE", [](Parser>&, auto&& args) { + args[0].value.push_back("E -> PE"); + return std::move(args[0].value); + }) + .precedence(1, Associativity::Left); + p.rule("PE") + .production("(", "PE", ")", [](Parser>&, auto&& args) { + args[1].value.push_back("PE -> ( PE )"); + return std::move(args[1].value); + }) + .production("a", [](Parser>&, auto&&) { + return std::vector{"PE -> a"}; + }); + EXPECT_TRUE(p.prepare()); + + std::string input1("(((a)))"); + auto result = p.parse(input1); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), (std::vector{ + "PE -> a", + "E -> PE", + "E -> ( E )", + "E -> ( E )", + "E -> ( E )"})); } TEST_F(TestParser, -EndTokenAction) { - int end_call_count = 0; - Parser p; - - p.token("a").symbol("a"); - p.end_token().action([&](std::string_view) { - end_call_count++; - return 0; - }); - - p.set_start_symbol("A"); - p.rule("A") - .production("A", "a", [](Parser&, auto&& args) { - return 1 + args[0].value; - }) - .production("a", [](Parser&, auto&&) { - return 1; - }); - EXPECT_TRUE(p.prepare()); - - std::string input1("aaaa"); - auto result = p.parse(input1); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 4); - EXPECT_EQ(end_call_count, 1); + EndTokenAction) { + int end_call_count = 0; + Parser p; + + p.token("a").symbol("a"); + p.end_token().action([&](std::string_view) { + end_call_count++; + return 0; + }); + + p.set_start_symbol("A"); + p.rule("A") + .production("A", "a", [](Parser&, auto&& args) { + return 1 + args[0].value; + }) + .production("a", [](Parser&, auto&&) { + return 1; + }); + EXPECT_TRUE(p.prepare()); + + std::string input1("aaaa"); + auto result = p.parse(input1); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 4); + EXPECT_EQ(end_call_count, 1); } TEST_F(TestParser, -TokenActionsCalledOnce) { - int a_call_count = 0; - Parser p; - - p.token("a").symbol("a").action([&](std::string_view) { - a_call_count++; - return 0; - }); - - p.set_start_symbol("A"); - p.rule("A") - .production("B", [](Parser&, auto&& args) { - return args[0].value; - }); - p.rule("B") - .production("A", "a", [](Parser&, auto&& args) { - return 1 + args[0].value; - }) - .production("a", [](Parser&, auto&&) { - return 1; - }); - EXPECT_TRUE(p.prepare()); - - std::string input1("aaaa"); - auto result = p.parse(input1); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 4); - EXPECT_EQ(a_call_count, 4); + TokenActionsCalledOnce) { + int a_call_count = 0; + Parser p; + + p.token("a").symbol("a").action([&](std::string_view) { + a_call_count++; + return 0; + }); + + p.set_start_symbol("A"); + p.rule("A") + .production("B", [](Parser&, auto&& args) { + return args[0].value; + }); + p.rule("B") + .production("A", "a", [](Parser&, auto&& args) { + return 1 + args[0].value; + }) + .production("a", [](Parser&, auto&&) { + return 1; + }); + EXPECT_TRUE(p.prepare()); + + std::string input1("aaaa"); + auto result = p.parse(input1); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 4); + EXPECT_EQ(a_call_count, 4); } TEST_F(TestParser, -MultistateTokenizer) { - using Value = std::variant< - std::string, - std::pair, - std::vector> - >; - - Parser p; - std::string built_string; - - p.token("\\s+"); - p.token("=").symbol("="); - p.token("[a-zA-Z_][a-zA-Z0-9_]*").symbol("id").action([](std::string_view str) -> Value { - return std::string{str}; - }); - - p.token(R"(")").enter_state("string").action([&](std::string_view) -> Value { - built_string.clear(); - return {}; - }); - p.token(R"(\\n)").states("string").action([&](std::string_view) -> Value { - built_string += '\n'; - return {}; - }); - p.token(R"(\\t)").states("string").action([&](std::string_view) -> Value { - built_string += '\t'; - return {}; - }); - p.token(R"(\\r)").states("string").action([&](std::string_view) -> Value { - built_string += '\r'; - return {}; - }); - p.token(R"(\\x[0-9a-fA-F]{2})").states("string").action([&](std::string_view str) -> Value { - auto s = std::string{str.begin() + 2, str.end()}; - built_string += static_cast(std::stoi(s, nullptr, 16)); - return {}; - }); - p.token(R"([^\\"]+)").states("string").action([&](std::string_view str) -> Value { - built_string += str; - return {}; - }); - p.token(R"(")").states("string").enter_state("@default").symbol("string_literal").action([&](std::string_view) -> Value { - return built_string; - }); - - p.set_start_symbol("root"); - p.rule("root") - .production("strings", [](Parser&, auto&& args) -> Value { - return std::move(args[0].value); - }) - .production([](Parser&, auto&&) -> Value { - return std::vector>{}; - }); - p.rule("strings") - .production("strings", "string", [](Parser&, auto&& args) -> Value { - std::get>>(args[0].value).push_back( - std::get>(args[1].value) - ); - return std::move(args[0].value); - }) - .production("string", [](Parser&, auto&& args) -> Value { - return std::vector>{ - std::get>(args[0].value) - }; - }); - p.rule("string") - .production("id", "=", "string_literal", [](Parser&, auto&& args) -> Value { - return std::make_pair( - std::get(args[0].value), - std::get(args[2].value) - ); - }); - EXPECT_TRUE(p.prepare()); - - std::string input( - "abc = \"xyz\"\n" - "x = \"ab\\n\\t\\r\\x20cd\"" - ); - auto result = p.parse(input); - EXPECT_TRUE(result); - auto strings = std::get>>(result.value()); - EXPECT_EQ(strings.size(), 2u); - EXPECT_THAT(strings[0], Pair(Eq("abc"), Eq("xyz"))); - EXPECT_THAT(strings[1], Pair(Eq("x"), Eq("ab\n\t\r cd"))); + MultistateTokenizer) { + using Value = std::variant< + std::string, + std::pair, + std::vector>>; + + Parser p; + std::string built_string; + + p.token("\\s+"); + p.token("=").symbol("="); + p.token("[a-zA-Z_][a-zA-Z0-9_]*").symbol("id").action([](std::string_view str) -> Value { + return std::string{str}; + }); + + p.token(R"(")").enter_state("string").action([&](std::string_view) -> Value { + built_string.clear(); + return {}; + }); + p.token(R"(\\n)").states("string").action([&](std::string_view) -> Value { + built_string += '\n'; + return {}; + }); + p.token(R"(\\t)").states("string").action([&](std::string_view) -> Value { + built_string += '\t'; + return {}; + }); + p.token(R"(\\r)").states("string").action([&](std::string_view) -> Value { + built_string += '\r'; + return {}; + }); + p.token(R"(\\x[0-9a-fA-F]{2})").states("string").action([&](std::string_view str) -> Value { + auto s = std::string{str.begin() + 2, str.end()}; + built_string += static_cast(std::stoi(s, nullptr, 16)); + return {}; + }); + p.token(R"([^\\"]+)").states("string").action([&](std::string_view str) -> Value { + built_string += str; + return {}; + }); + p.token(R"(")").states("string").enter_state("@default").symbol("string_literal").action([&](std::string_view) -> Value { + return built_string; + }); + + p.set_start_symbol("root"); + p.rule("root") + .production("strings", [](Parser&, auto&& args) -> Value { + return std::move(args[0].value); + }) + .production([](Parser&, auto&&) -> Value { + return std::vector>{}; + }); + p.rule("strings") + .production("strings", "string", [](Parser&, auto&& args) -> Value { + std::get>>(args[0].value).push_back(std::get>(args[1].value)); + return std::move(args[0].value); + }) + .production("string", [](Parser&, auto&& args) -> Value { + return std::vector>{ + std::get>(args[0].value)}; + }); + p.rule("string") + .production("id", "=", "string_literal", [](Parser&, auto&& args) -> Value { + return std::make_pair( + std::get(args[0].value), + std::get(args[2].value)); + }); + EXPECT_TRUE(p.prepare()); + + std::string input( + "abc = \"xyz\"\n" + "x = \"ab\\n\\t\\r\\x20cd\""); + auto result = p.parse(input); + EXPECT_TRUE(result); + auto strings = std::get>>(result.value()); + EXPECT_EQ(strings.size(), 2u); + EXPECT_THAT(strings[0], Pair(Eq("abc"), Eq("xyz"))); + EXPECT_THAT(strings[1], Pair(Eq("x"), Eq("ab\n\t\r cd"))); } TEST_F(TestParser, -MidruleActionsToCheckRedefinition) { - using Value = std::variant< - int, - std::string - >; - - Parser p; - - p.token("\\s+"); - p.token("=").symbol("="); - p.token(";").symbol(";"); - p.token("\\{").symbol("{"); - p.token("\\}").symbol("}"); - p.token("function").symbol("function"); - p.token("var").symbol("var"); - p.token("[_a-zA-Z][_a-zA-Z0-9]*").symbol("id").action([](std::string_view str) -> Value { - return std::string{str}; - }); - p.token("[0-9]+").symbol("num").action([](std::string_view str) -> Value { - return std::stoi(std::string{str}); - }); - - std::unordered_set defs, redefs; - - p.set_start_symbol("prog"); - p.rule("prog") - .production("funcs") - .production(); - p.rule("funcs") - .production("funcs", "func") - .production("func"); - p.rule("func") - .production( - "function", "id", [&](Parser&, auto&& args) -> Value { - auto func_name = std::get(args[1].value); - auto [itr, inserted] = defs.insert(func_name); - if (!inserted) - redefs.insert(func_name); - return {}; - }, - "{", "func_body", "}" - ); - p.rule("func_body") - .production("stmts") - .production(); - p.rule("stmts") - .production("stmts", "stmt") - .production("stmt"); - p.rule("stmt") - .production( - "var", "id", [&](Parser&, auto&& args) -> Value { - auto var_name = std::get(args[1].value); - auto [itr, inserted] = defs.insert(var_name); - if (!inserted) - redefs.insert(var_name); - return {}; - }, - "=", "num", ";" - ); - EXPECT_TRUE(p.prepare()); - - std::string input1( -R"(function x { + MidruleActionsToCheckRedefinition) { + using Value = std::variant< + int, + std::string>; + + Parser p; + + p.token("\\s+"); + p.token("=").symbol("="); + p.token(";").symbol(";"); + p.token("\\{").symbol("{"); + p.token("\\}").symbol("}"); + p.token("function").symbol("function"); + p.token("var").symbol("var"); + p.token("[_a-zA-Z][_a-zA-Z0-9]*").symbol("id").action([](std::string_view str) -> Value { + return std::string{str}; + }); + p.token("[0-9]+").symbol("num").action([](std::string_view str) -> Value { + return std::stoi(std::string{str}); + }); + + std::unordered_set defs, redefs; + + p.set_start_symbol("prog"); + p.rule("prog") + .production("funcs") + .production(); + p.rule("funcs") + .production("funcs", "func") + .production("func"); + p.rule("func") + .production( + "function", "id", [&](Parser&, auto&& args) -> Value { + auto func_name = std::get(args[1].value); + auto [itr, inserted] = defs.insert(func_name); + if (!inserted) + redefs.insert(func_name); + return {}; + }, + "{", "func_body", "}"); + p.rule("func_body") + .production("stmts") + .production(); + p.rule("stmts") + .production("stmts", "stmt") + .production("stmt"); + p.rule("stmt") + .production( + "var", "id", [&](Parser&, auto&& args) -> Value { + auto var_name = std::get(args[1].value); + auto [itr, inserted] = defs.insert(var_name); + if (!inserted) + redefs.insert(var_name); + return {}; + }, + "=", "num", ";"); + EXPECT_TRUE(p.prepare()); + + std::string input1( + R"(function x { var y = 5; var z = 10; -})" - ); - auto result1 = p.parse(input1); - EXPECT_TRUE(result1); - EXPECT_EQ(defs, (std::unordered_set{"x", "y", "z"})); - EXPECT_EQ(redefs, (std::unordered_set{})); - - defs.clear(); - redefs.clear(); - - std::string input2( -R"(function x { +})"); + auto result1 = p.parse(input1); + EXPECT_TRUE(result1); + EXPECT_EQ(defs, (std::unordered_set{"x", "y", "z"})); + EXPECT_EQ(redefs, (std::unordered_set{})); + + defs.clear(); + redefs.clear(); + + std::string input2( + R"(function x { var y = 5; var x = 10; -})" - ); - auto result2 = p.parse(input2); - EXPECT_TRUE(result2); - EXPECT_EQ(defs, (std::unordered_set{"x", "y"})); - EXPECT_EQ(redefs, (std::unordered_set{"x"})); - - defs.clear(); - redefs.clear(); - - std::string input3( -R"(function x { +})"); + auto result2 = p.parse(input2); + EXPECT_TRUE(result2); + EXPECT_EQ(defs, (std::unordered_set{"x", "y"})); + EXPECT_EQ(redefs, (std::unordered_set{"x"})); + + defs.clear(); + redefs.clear(); + + std::string input3( + R"(function x { var y = 5; var z = 10; } function z { var a = 1; -})" - ); - auto result3 = p.parse(input3); - EXPECT_TRUE(result3); - EXPECT_EQ(defs, (std::unordered_set{"x", "y", "z", "a"})); - EXPECT_EQ(redefs, (std::unordered_set{"z"})); +})"); + auto result3 = p.parse(input3); + EXPECT_TRUE(result3); + EXPECT_EQ(defs, (std::unordered_set{"x", "y", "z", "a"})); + EXPECT_EQ(redefs, (std::unordered_set{"z"})); } TEST_F(TestParser, -InputStreamStackManipulation) { - static std::vector input_streams = { - "10", - "include 0", - "30", - "40" - }; - - std::vector> inputs; - - Parser p; - - p.token("\\s+"); - p.token("\\+").symbol("+").precedence(1, Associativity::Left); - p.token("\\*").symbol("*").precedence(2, Associativity::Left); - p.token("include [0-9]+").action([&](std::string_view str) { - auto stream_idx = std::stoi(std::string{str.begin() + 8, str.end()}); - inputs.emplace_back(std::make_unique(input_streams[stream_idx])); - p.push_input_stream(*inputs.back().get()); - return 0; - }); - p.token("[0-9]+").symbol("number").action([](std::string_view str) { - return std::stoi(std::string{str}); - }); - p.end_token().action([&](std::string_view) { - p.pop_input_stream(); - return 0; - }); - - p.set_start_symbol("E"); - p.rule("E") - .production("E", "+", "E", [](Parser&, auto&& args) { return args[0].value + args[2].value; }) - .production("E", "*", "E", [](Parser&, auto&& args) { return args[0].value * args[2].value; }) - .production("number", [](Parser&, auto&& args) { return args[0].value; }); - - EXPECT_TRUE(p.prepare()); - - std::string input("include 1 + include 2 * include 3 + 5"); - auto result = p.parse(input); - - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 1215); + InputStreamStackManipulation) { + static std::vector input_streams = { + "10", + "include 0", + "30", + "40"}; + + std::vector> inputs; + + Parser p; + + p.token("\\s+"); + p.token("\\+").symbol("+").precedence(1, Associativity::Left); + p.token("\\*").symbol("*").precedence(2, Associativity::Left); + p.token("include [0-9]+").action([&](std::string_view str) { + auto stream_idx = std::stoi(std::string{str.begin() + 8, str.end()}); + inputs.emplace_back(std::make_unique(input_streams[stream_idx])); + p.push_input_stream(*inputs.back().get()); + return 0; + }); + p.token("[0-9]+").symbol("number").action([](std::string_view str) { + return std::stoi(std::string{str}); + }); + p.end_token().action([&](std::string_view) { + p.pop_input_stream(); + return 0; + }); + + p.set_start_symbol("E"); + p.rule("E") + .production("E", "+", "E", [](Parser&, auto&& args) { return args[0].value + args[2].value; }) + .production("E", "*", "E", [](Parser&, auto&& args) { return args[0].value * args[2].value; }) + .production("number", [](Parser&, auto&& args) { return args[0].value; }); + + EXPECT_TRUE(p.prepare()); + + std::string input("include 1 + include 2 * include 3 + 5"); + auto result = p.parse(input); + + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 1215); } TEST_F(TestParser, -RuleActionsAccessingDataBeforeMidruleAction) { - Parser p; - - p.token("\\s+"); - p.token("a").symbol("a").action([](std::string_view) { - return 1; - }); - p.token("function").symbol("func").action([](std::string_view) { - return 10; - }); - p.token("[a-zA-Z_]+").symbol("id").action([](std::string_view) { - return 100; - }); - - std::vector all_values; - - p.set_start_symbol("S"); - p.rule("S") - .production("func", "id", [](Parser&, auto&& args) { - return args[0].value + args[1].value; - }, - "A", [&](Parser&, auto&& args) { + RuleActionsAccessingDataBeforeMidruleAction) { + Parser p; + + p.token("\\s+"); + p.token("a").symbol("a").action([](std::string_view) { + return 1; + }); + p.token("function").symbol("func").action([](std::string_view) { + return 10; + }); + p.token("[a-zA-Z_]+").symbol("id").action([](std::string_view) { + return 100; + }); + + std::vector all_values; + + p.set_start_symbol("S"); + p.rule("S") + .production("func", "id", [](Parser&, auto&& args) { return args[0].value + args[1].value; }, "A", [&](Parser&, auto&& args) { for (const auto& arg : args) all_values.push_back(arg.value); - return args[2].value + args[3].value; - }); - p.rule("A") - .production("A", "a", [](Parser&, auto&& args) { return args[0].value + args[1].value; }) - .production("a", [](Parser&, auto&& args) { return args[0].value; }); - - - EXPECT_TRUE(p.prepare()); - - std::string input("function abc a a a a a"); - auto result = p.parse(input); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 115); - EXPECT_EQ(all_values, (std::vector{10, 100, 110, 5})); + return args[2].value + args[3].value; }); + p.rule("A") + .production("A", "a", [](Parser&, auto&& args) { return args[0].value + args[1].value; }) + .production("a", [](Parser&, auto&& args) { return args[0].value; }); + + EXPECT_TRUE(p.prepare()); + + std::string input("function abc a a a a a"); + auto result = p.parse(input); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 115); + EXPECT_EQ(all_values, (std::vector{10, 100, 110, 5})); } TEST_F(TestParser, -MultistateTokenizerWithExplicitCalls) { - using Value = std::variant< - std::string, - std::pair, - std::vector> - >; - - Parser p; - std::string built_string; - - p.token("\\s+"); - p.token("=").symbol("="); - p.token("[a-zA-Z_][a-zA-Z0-9_]*").symbol("id").action([](std::string_view str) -> Value { - return std::string{str}; - }); - - p.token(R"(")").action([&](std::string_view) -> Value { - p.enter_tokenizer_state("string"); - built_string.clear(); - return {}; - }); - p.token(R"(\\n)").states("string").action([&](std::string_view) -> Value { - built_string += '\n'; - return {}; - }); - p.token(R"(\\t)").states("string").action([&](std::string_view) -> Value { - built_string += '\t'; - return {}; - }); - p.token(R"(\\r)").states("string").action([&](std::string_view) -> Value { - built_string += '\r'; - return {}; - }); - p.token(R"(\\x[0-9a-fA-F]{2})").states("string").action([&](std::string_view str) -> Value { - auto s = std::string{str.begin() + 2, str.end()}; - built_string += static_cast(std::stoi(s, nullptr, 16)); - return {}; - }); - p.token(R"([^\\"]+)").states("string").action([&](std::string_view str) -> Value { - built_string += str; - return {}; - }); - p.token(R"(")").states("string").symbol("string_literal").action([&](std::string_view) -> Value { - p.enter_tokenizer_state("@default"); - return built_string; - }); - - p.set_start_symbol("root"); - p.rule("root") - .production("strings", [](Parser&, auto&& args) -> Value { - return std::move(args[0].value); - }) - .production([](Parser&, auto&&) -> Value { - return std::vector>{}; - }); - p.rule("strings") - .production("strings", "string", [](Parser&, auto&& args) -> Value { - std::get>>(args[0].value).push_back( - std::get>(args[1].value) - ); - return std::move(args[0].value); - }) - .production("string", [](Parser&, auto&& args) -> Value { - return std::vector>{ - std::get>(args[0].value) - }; - }); - p.rule("string") - .production("id", "=", "string_literal", [](Parser&, auto&& args) -> Value { - return std::make_pair( - std::get(args[0].value), - std::get(args[2].value) - ); - }); - EXPECT_TRUE(p.prepare()); - - std::string input( - "abc = \"xyz\"\n" - "x = \"ab\\n\\t\\r\\x20cd\"" - ); - auto result = p.parse(input); - EXPECT_TRUE(result); - auto strings = std::get>>(result.value()); - EXPECT_EQ(strings.size(), 2u); - EXPECT_THAT(strings[0], Pair(Eq("abc"), Eq("xyz"))); - EXPECT_THAT(strings[1], Pair(Eq("x"), Eq("ab\n\t\r cd"))); + MultistateTokenizerWithExplicitCalls) { + using Value = std::variant< + std::string, + std::pair, + std::vector>>; + + Parser p; + std::string built_string; + + p.token("\\s+"); + p.token("=").symbol("="); + p.token("[a-zA-Z_][a-zA-Z0-9_]*").symbol("id").action([](std::string_view str) -> Value { + return std::string{str}; + }); + + p.token(R"(")").action([&](std::string_view) -> Value { + p.enter_tokenizer_state("string"); + built_string.clear(); + return {}; + }); + p.token(R"(\\n)").states("string").action([&](std::string_view) -> Value { + built_string += '\n'; + return {}; + }); + p.token(R"(\\t)").states("string").action([&](std::string_view) -> Value { + built_string += '\t'; + return {}; + }); + p.token(R"(\\r)").states("string").action([&](std::string_view) -> Value { + built_string += '\r'; + return {}; + }); + p.token(R"(\\x[0-9a-fA-F]{2})").states("string").action([&](std::string_view str) -> Value { + auto s = std::string{str.begin() + 2, str.end()}; + built_string += static_cast(std::stoi(s, nullptr, 16)); + return {}; + }); + p.token(R"([^\\"]+)").states("string").action([&](std::string_view str) -> Value { + built_string += str; + return {}; + }); + p.token(R"(")").states("string").symbol("string_literal").action([&](std::string_view) -> Value { + p.enter_tokenizer_state("@default"); + return built_string; + }); + + p.set_start_symbol("root"); + p.rule("root") + .production("strings", [](Parser&, auto&& args) -> Value { + return std::move(args[0].value); + }) + .production([](Parser&, auto&&) -> Value { + return std::vector>{}; + }); + p.rule("strings") + .production("strings", "string", [](Parser&, auto&& args) -> Value { + std::get>>(args[0].value).push_back(std::get>(args[1].value)); + return std::move(args[0].value); + }) + .production("string", [](Parser&, auto&& args) -> Value { + return std::vector>{ + std::get>(args[0].value)}; + }); + p.rule("string") + .production("id", "=", "string_literal", [](Parser&, auto&& args) -> Value { + return std::make_pair( + std::get(args[0].value), + std::get(args[2].value)); + }); + EXPECT_TRUE(p.prepare()); + + std::string input( + "abc = \"xyz\"\n" + "x = \"ab\\n\\t\\r\\x20cd\""); + auto result = p.parse(input); + EXPECT_TRUE(result); + auto strings = std::get>>(result.value()); + EXPECT_EQ(strings.size(), 2u); + EXPECT_THAT(strings[0], Pair(Eq("abc"), Eq("xyz"))); + EXPECT_THAT(strings[1], Pair(Eq("x"), Eq("ab\n\t\r cd"))); } TEST_F(TestParser, -EndInputInNonDefaultTokenizerState) { - Parser p; - - p.token("a").symbol("a").enter_state("special"); - p.token("b").symbol("b").enter_state("@default"); - p.end_token().states("@default", "special"); - - p.set_start_symbol("A"); - p.rule("A") - .production("A", "a", [](Parser&, auto&& args) { - return 1 + args[0].value; - }) - .production("A", "b", [](Parser&, auto&& args) { - return 1 + args[0].value; - }) - .production("a", [](Parser&, auto&&) { - return 1; - }) - .production("b", [](Parser&, auto&&) { - return 1; - }); - EXPECT_TRUE(p.prepare()); - - std::string input1("a"); - auto result = p.parse(input1); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 1); - - std::string input2("bbbba"); - result = p.parse(input2); - EXPECT_TRUE(result); - EXPECT_EQ(result.value(), 5); - - try - { - std::string input3("bbbbab"); - p.parse(input3); - FAIL() << "Expected syntax error"; - } - catch (const SyntaxError& e) - { - EXPECT_STREQ(e.what(), "Syntax error: Unknown symbol on input, expected one of @end, a, b"); - } + EndInputInNonDefaultTokenizerState) { + Parser p; + + p.token("a").symbol("a").enter_state("special"); + p.token("b").symbol("b").enter_state("@default"); + p.end_token().states("@default", "special"); + + p.set_start_symbol("A"); + p.rule("A") + .production("A", "a", [](Parser&, auto&& args) { + return 1 + args[0].value; + }) + .production("A", "b", [](Parser&, auto&& args) { + return 1 + args[0].value; + }) + .production("a", [](Parser&, auto&&) { + return 1; + }) + .production("b", [](Parser&, auto&&) { + return 1; + }); + EXPECT_TRUE(p.prepare()); + + std::string input1("a"); + auto result = p.parse(input1); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 1); + + std::string input2("bbbba"); + result = p.parse(input2); + EXPECT_TRUE(result); + EXPECT_EQ(result.value(), 5); + + try { + std::string input3("bbbbab"); + p.parse(input3); + FAIL() << "Expected syntax error"; + } catch (const SyntaxError& e) { + EXPECT_STREQ(e.what(), "Syntax error: Unknown symbol on input, expected one of @end, a, b"); + } } TEST_F(TestParser, -IncludesRelationCalulcatedCorrectlyForSameRightHandSifePrefix) { - Parser p; - - p.token("a").symbol("a"); - p.token("b").symbol("b"); - - p.set_start_symbol("S"); - p.rule("S") - .production("A"); - p.rule("A") - .production("B", "b") - .production("B"); - p.rule("B") - .production("a"); - EXPECT_TRUE(p.prepare()); - - std::string input1("a"); - auto result = p.parse(input1); - EXPECT_TRUE(result); - - std::string input2("ab"); - result = p.parse(input2); - EXPECT_TRUE(result); + IncludesRelationCalulcatedCorrectlyForSameRightHandSifePrefix) { + Parser p; + + p.token("a").symbol("a"); + p.token("b").symbol("b"); + + p.set_start_symbol("S"); + p.rule("S") + .production("A"); + p.rule("A") + .production("B", "b") + .production("B"); + p.rule("B") + .production("a"); + EXPECT_TRUE(p.prepare()); + + std::string input1("a"); + auto result = p.parse(input1); + EXPECT_TRUE(result); + + std::string input2("ab"); + result = p.parse(input2); + EXPECT_TRUE(result); } TEST_F(TestParser, -GlobalTokenizerAction) { - Parser p; - - std::pair location = {1, 0}; - p.global_tokenizer_action([&](std::string_view str) { - location.second += str.length(); - }); - - p.token(R"(\n)").action([&](std::string_view) { - location.first++; - location.second = 0; - return 0; - }); - p.token(R"([ \t\v\r]+)"); - p.token("a+").symbol("As"); - p.token("b{3}").symbol("Bs"); - - p.set_start_symbol("S"); - p.rule("S") - .production("S", "As") - .production("S", "Bs") - .production(); - EXPECT_TRUE(p.prepare()); - - std::string input1("aaaaa"); - auto result = p.parse(input1); - EXPECT_TRUE(result); - EXPECT_THAT(location, Pair(Eq(1), Eq(5))); - - location = {1, 0}; - std::string input2("aaa \nbbb bbb\n \n\na"); - result = p.parse(input2); - EXPECT_TRUE(result); - EXPECT_THAT(location, Pair(Eq(5), Eq(1))); + GlobalTokenizerAction) { + Parser p; + + std::pair location = {1, 0}; + p.global_tokenizer_action([&](std::string_view str) { + location.second += str.length(); + }); + + p.token(R"(\n)").action([&](std::string_view) { + location.first++; + location.second = 0; + return 0; + }); + p.token(R"([ \t\v\r]+)"); + p.token("a+").symbol("As"); + p.token("b{3}").symbol("Bs"); + + p.set_start_symbol("S"); + p.rule("S") + .production("S", "As") + .production("S", "Bs") + .production(); + EXPECT_TRUE(p.prepare()); + + std::string input1("aaaaa"); + auto result = p.parse(input1); + EXPECT_TRUE(result); + EXPECT_THAT(location, Pair(Eq(1), Eq(5))); + + location = {1, 0}; + std::string input2("aaa \nbbb bbb\n \n\na"); + result = p.parse(input2); + EXPECT_TRUE(result); + EXPECT_THAT(location, Pair(Eq(5), Eq(1))); } diff --git a/tests/Pog/ParsingTable.cpp b/tests/Pog/ParsingTable.cpp index b59db1fa..2e87e1b6 100644 --- a/tests/Pog/ParsingTable.cpp +++ b/tests/Pog/ParsingTable.cpp @@ -7,6 +7,6 @@ using namespace pog; class TestParsingTable : public ::testing::Test {}; TEST_F(TestParsingTable, -AddAccept) { - //ParsingTable pt; + AddAccept) { + // ParsingTable pt; } diff --git a/tests/Pog/PogTests.cpp b/tests/Pog/PogTests.cpp index 5ff23f2f..697a9d70 100644 --- a/tests/Pog/PogTests.cpp +++ b/tests/Pog/PogTests.cpp @@ -1,7 +1,6 @@ #include -int main(int argc, char **argv) -{ - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/tests/Pog/Precedence.cpp b/tests/Pog/Precedence.cpp index 4bd379d3..b729a64f 100644 --- a/tests/Pog/Precedence.cpp +++ b/tests/Pog/Precedence.cpp @@ -7,75 +7,63 @@ class TestPrecedence : public ::testing::Test {}; using namespace pog; TEST_F(TestPrecedence, -Equality) { - Precedence p1{1, Associativity::Left}; - Precedence p2{1, Associativity::Left}; - Precedence p3{1, Associativity::Right}; - Precedence p4{0, Associativity::Left}; - Precedence p5{2, Associativity::Left}; + Equality) { + Precedence p1{1, Associativity::Left}; + Precedence p2{1, Associativity::Left}; + Precedence p3{1, Associativity::Right}; + Precedence p4{0, Associativity::Left}; + Precedence p5{2, Associativity::Left}; - EXPECT_EQ(p1, p2); - EXPECT_NE(p1, p3); - EXPECT_NE(p1, p4); - EXPECT_NE(p1, p5); + EXPECT_EQ(p1, p2); + EXPECT_NE(p1, p3); + EXPECT_NE(p1, p4); + EXPECT_NE(p1, p5); } TEST_F(TestPrecedence, -SameLevelLeftAssociative) { - EXPECT_FALSE( - (Precedence{1, Associativity::Left}) < (Precedence{1, Associativity::Left}) - ); - EXPECT_TRUE( - (Precedence{1, Associativity::Left}) > (Precedence{1, Associativity::Left}) - ); + SameLevelLeftAssociative) { + EXPECT_FALSE( + (Precedence{1, Associativity::Left}) < (Precedence{1, Associativity::Left})); + EXPECT_TRUE( + (Precedence{1, Associativity::Left}) > (Precedence{1, Associativity::Left})); } TEST_F(TestPrecedence, -SameLevelRightAssociative) { - EXPECT_TRUE( - (Precedence{1, Associativity::Right}) < (Precedence{1, Associativity::Right}) - ); - EXPECT_FALSE( - (Precedence{1, Associativity::Right}) > (Precedence{1, Associativity::Right}) - ); + SameLevelRightAssociative) { + EXPECT_TRUE( + (Precedence{1, Associativity::Right}) < (Precedence{1, Associativity::Right})); + EXPECT_FALSE( + (Precedence{1, Associativity::Right}) > (Precedence{1, Associativity::Right})); } TEST_F(TestPrecedence, -LowerLevelLeftAssociative) { - EXPECT_TRUE( - (Precedence{0, Associativity::Left}) < (Precedence{1, Associativity::Left}) - ); - EXPECT_FALSE( - (Precedence{0, Associativity::Left}) > (Precedence{1, Associativity::Left}) - ); + LowerLevelLeftAssociative) { + EXPECT_TRUE( + (Precedence{0, Associativity::Left}) < (Precedence{1, Associativity::Left})); + EXPECT_FALSE( + (Precedence{0, Associativity::Left}) > (Precedence{1, Associativity::Left})); } TEST_F(TestPrecedence, -LowerLevelRightAssociative) { - EXPECT_TRUE( - (Precedence{0, Associativity::Right}) < (Precedence{1, Associativity::Right}) - ); - EXPECT_FALSE( - (Precedence{0, Associativity::Right}) > (Precedence{1, Associativity::Right}) - ); + LowerLevelRightAssociative) { + EXPECT_TRUE( + (Precedence{0, Associativity::Right}) < (Precedence{1, Associativity::Right})); + EXPECT_FALSE( + (Precedence{0, Associativity::Right}) > (Precedence{1, Associativity::Right})); } TEST_F(TestPrecedence, -HigherLevelLeftAssociative) { - EXPECT_FALSE( - (Precedence{2, Associativity::Left}) < (Precedence{1, Associativity::Left}) - ); - EXPECT_TRUE( - (Precedence{2, Associativity::Left}) > (Precedence{1, Associativity::Left}) - ); + HigherLevelLeftAssociative) { + EXPECT_FALSE( + (Precedence{2, Associativity::Left}) < (Precedence{1, Associativity::Left})); + EXPECT_TRUE( + (Precedence{2, Associativity::Left}) > (Precedence{1, Associativity::Left})); } TEST_F(TestPrecedence, -HigherLevelRightAssociative) { - EXPECT_FALSE( - (Precedence{2, Associativity::Right}) < (Precedence{1, Associativity::Right}) - ); - EXPECT_TRUE( - (Precedence{2, Associativity::Right}) > (Precedence{1, Associativity::Right}) - ); + HigherLevelRightAssociative) { + EXPECT_FALSE( + (Precedence{2, Associativity::Right}) < (Precedence{1, Associativity::Right})); + EXPECT_TRUE( + (Precedence{2, Associativity::Right}) > (Precedence{1, Associativity::Right})); } diff --git a/tests/Pog/Rule.cpp b/tests/Pog/Rule.cpp index 6318b568..f8656028 100644 --- a/tests/Pog/Rule.cpp +++ b/tests/Pog/Rule.cpp @@ -7,86 +7,86 @@ class TestRule : public ::testing::Test {}; using namespace pog; TEST_F(TestRule, -SimpleRule) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - - EXPECT_EQ(rule.get_index(), 42u); - EXPECT_EQ(rule.get_lhs(), &s1); - EXPECT_EQ(rule.get_rhs(), (std::vector*>{&s2, &s3})); - EXPECT_FALSE(rule.has_precedence()); + SimpleRule) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + + EXPECT_EQ(rule.get_index(), 42u); + EXPECT_EQ(rule.get_lhs(), &s1); + EXPECT_EQ(rule.get_rhs(), (std::vector*>{&s2, &s3})); + EXPECT_FALSE(rule.has_precedence()); } TEST_F(TestRule, -Precedence) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - rule.set_precedence(1, Associativity::Right); - - EXPECT_EQ(rule.get_index(), 42u); - EXPECT_EQ(rule.get_lhs(), &s1); - EXPECT_EQ(rule.get_rhs(), (std::vector*>{&s2, &s3})); - EXPECT_TRUE(rule.has_precedence()); - EXPECT_EQ(rule.get_precedence(), (Precedence{1, Associativity::Right})); + Precedence) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + rule.set_precedence(1, Associativity::Right); + + EXPECT_EQ(rule.get_index(), 42u); + EXPECT_EQ(rule.get_lhs(), &s1); + EXPECT_EQ(rule.get_rhs(), (std::vector*>{&s2, &s3})); + EXPECT_TRUE(rule.has_precedence()); + EXPECT_EQ(rule.get_precedence(), (Precedence{1, Associativity::Right})); } TEST_F(TestRule, -RightmostTerminalWhileThereIsNone) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + RightmostTerminalWhileThereIsNone) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - EXPECT_EQ(rule.get_rightmost_terminal(), nullptr); + EXPECT_EQ(rule.get_rightmost_terminal(), nullptr); } TEST_F(TestRule, -RightmostTerminal) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Terminal, "2"); - Symbol s3(3, SymbolKind::Terminal, "3"); - Symbol s4(4, SymbolKind::Nonterminal, "4"); - Rule rule(42, &s1, std::vector*>{&s2, &s3, &s4}, [](Parser&, auto&&) -> int { return 0; }); - - EXPECT_EQ(rule.get_rightmost_terminal(), &s3); + RightmostTerminal) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Terminal, "2"); + Symbol s3(3, SymbolKind::Terminal, "3"); + Symbol s4(4, SymbolKind::Nonterminal, "4"); + Rule rule(42, &s1, std::vector*>{&s2, &s3, &s4}, [](Parser&, auto&&) -> int { return 0; }); + + EXPECT_EQ(rule.get_rightmost_terminal(), &s3); } TEST_F(TestRule, -ToString) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Terminal, "2"); - Symbol s3(3, SymbolKind::Terminal, "3"); - Symbol s4(4, SymbolKind::Nonterminal, "4"); - Rule rule(42, &s1, std::vector*>{&s2, &s3, &s4}, [](Parser&, auto&&) -> int { return 0; }); - - EXPECT_EQ(rule.to_string(), "1 -> 2 3 4"); + ToString) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Terminal, "2"); + Symbol s3(3, SymbolKind::Terminal, "3"); + Symbol s4(4, SymbolKind::Nonterminal, "4"); + Rule rule(42, &s1, std::vector*>{&s2, &s3, &s4}, [](Parser&, auto&&) -> int { return 0; }); + + EXPECT_EQ(rule.to_string(), "1 -> 2 3 4"); } TEST_F(TestRule, -EpsilonToString) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Rule rule(42, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); + EpsilonToString) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Rule rule(42, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); - EXPECT_EQ(rule.to_string(), "1 -> "); + EXPECT_EQ(rule.to_string(), "1 -> "); } TEST_F(TestRule, -Equality) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Terminal, "2"); - Symbol s3(3, SymbolKind::Terminal, "3"); - Symbol s4(4, SymbolKind::Nonterminal, "4"); - Rule rule1(42, &s1, std::vector*>{&s2, &s3, &s4}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule2(42, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule3(43, &s1, std::vector*>{&s2, &s3, &s4}, [](Parser&, auto&&) -> int { return 0; }); - - EXPECT_TRUE(rule1 == rule2); - EXPECT_FALSE(rule1 == rule3); - - EXPECT_FALSE(rule1 != rule2); - EXPECT_TRUE(rule1 != rule3); + Equality) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Terminal, "2"); + Symbol s3(3, SymbolKind::Terminal, "3"); + Symbol s4(4, SymbolKind::Nonterminal, "4"); + Rule rule1(42, &s1, std::vector*>{&s2, &s3, &s4}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule2(42, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule3(43, &s1, std::vector*>{&s2, &s3, &s4}, [](Parser&, auto&&) -> int { return 0; }); + + EXPECT_TRUE(rule1 == rule2); + EXPECT_FALSE(rule1 == rule3); + + EXPECT_FALSE(rule1 != rule2); + EXPECT_TRUE(rule1 != rule3); } diff --git a/tests/Pog/RuleBuilder.cpp b/tests/Pog/RuleBuilder.cpp index fe33cd29..b71be55e 100644 --- a/tests/Pog/RuleBuilder.cpp +++ b/tests/Pog/RuleBuilder.cpp @@ -4,65 +4,63 @@ using namespace pog; -class TestRuleBuilder : public ::testing::Test -{ +class TestRuleBuilder : public ::testing::Test { public: - Grammar grammar; + Grammar grammar; }; TEST_F(TestRuleBuilder, -Initialization) { - RuleBuilder rb(&grammar, "A"); + Initialization) { + RuleBuilder rb(&grammar, "A"); - EXPECT_EQ(grammar.get_symbols().size(), 2u); // start and end symbol - EXPECT_TRUE(grammar.get_rules().empty()); + EXPECT_EQ(grammar.get_symbols().size(), 2u); // start and end symbol + EXPECT_TRUE(grammar.get_rules().empty()); } TEST_F(TestRuleBuilder, -NoProductions) { - RuleBuilder rb(&grammar, "A"); - rb.done(); + NoProductions) { + RuleBuilder rb(&grammar, "A"); + rb.done(); - EXPECT_EQ(grammar.get_symbols().size(), 2u); - EXPECT_TRUE(grammar.get_rules().empty()); + EXPECT_EQ(grammar.get_symbols().size(), 2u); + EXPECT_TRUE(grammar.get_rules().empty()); } TEST_F(TestRuleBuilder, -SingleProductionWithoutAction) { - RuleBuilder rb(&grammar, "A"); - rb.production("a"); - rb.done(); + SingleProductionWithoutAction) { + RuleBuilder rb(&grammar, "A"); + rb.production("a"); + rb.done(); - EXPECT_EQ(grammar.get_symbols().size(), 4u); - EXPECT_EQ(grammar.get_rules().size(), 1u); - EXPECT_EQ(grammar.get_rules()[0]->to_string(), "A -> a"); - EXPECT_FALSE(grammar.get_rules()[0]->has_action()); + EXPECT_EQ(grammar.get_symbols().size(), 4u); + EXPECT_EQ(grammar.get_rules().size(), 1u); + EXPECT_EQ(grammar.get_rules()[0]->to_string(), "A -> a"); + EXPECT_FALSE(grammar.get_rules()[0]->has_action()); } TEST_F(TestRuleBuilder, -SingleProductionWithAction) { - RuleBuilder rb(&grammar, "A"); - rb.production("a", [](Parser&, auto&&) { return 42; }); - rb.done(); + SingleProductionWithAction) { + RuleBuilder rb(&grammar, "A"); + rb.production("a", [](Parser&, auto&&) { return 42; }); + rb.done(); - EXPECT_EQ(grammar.get_symbols().size(), 4u); - EXPECT_EQ(grammar.get_rules().size(), 1u); - EXPECT_EQ(grammar.get_rules()[0]->to_string(), "A -> a"); - EXPECT_TRUE(grammar.get_rules()[0]->has_action()); + EXPECT_EQ(grammar.get_symbols().size(), 4u); + EXPECT_EQ(grammar.get_rules().size(), 1u); + EXPECT_EQ(grammar.get_rules()[0]->to_string(), "A -> a"); + EXPECT_TRUE(grammar.get_rules()[0]->has_action()); } TEST_F(TestRuleBuilder, -MultipleProductionsWithActions) { - RuleBuilder rb(&grammar, "A"); - rb.production("A", "a", [](Parser&, auto&&) { return 42; }) - .production("a", [](Parser&, auto&&) { return 42; }); - rb.done(); + MultipleProductionsWithActions) { + RuleBuilder rb(&grammar, "A"); + rb.production("A", "a", [](Parser&, auto&&) { return 42; }) + .production("a", [](Parser&, auto&&) { return 42; }); + rb.done(); - EXPECT_EQ(grammar.get_symbols().size(), 4u); - EXPECT_EQ(grammar.get_rules().size(), 2u); - EXPECT_EQ(grammar.get_rules()[0]->to_string(), "A -> A a"); - EXPECT_EQ(grammar.get_rules()[1]->to_string(), "A -> a"); - EXPECT_TRUE(grammar.get_rules()[0]->has_action()); - EXPECT_TRUE(grammar.get_rules()[1]->has_action()); + EXPECT_EQ(grammar.get_symbols().size(), 4u); + EXPECT_EQ(grammar.get_rules().size(), 2u); + EXPECT_EQ(grammar.get_rules()[0]->to_string(), "A -> A a"); + EXPECT_EQ(grammar.get_rules()[1]->to_string(), "A -> a"); + EXPECT_TRUE(grammar.get_rules()[0]->has_action()); + EXPECT_TRUE(grammar.get_rules()[1]->has_action()); } - diff --git a/tests/Pog/State.cpp b/tests/Pog/State.cpp index 526e8d36..dd936a59 100644 --- a/tests/Pog/State.cpp +++ b/tests/Pog/State.cpp @@ -8,271 +8,271 @@ using namespace ::testing; class TestState : public ::testing::Test {}; TEST_F(TestState, -DefultState) { - State state; + DefultState) { + State state; - EXPECT_EQ(state.get_index(), std::numeric_limits::max()); + EXPECT_EQ(state.get_index(), std::numeric_limits::max()); } TEST_F(TestState, -SimpleState) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + SimpleState) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - State state(1); + State state(1); - EXPECT_EQ(state.get_index(), 1u); - EXPECT_EQ(state.size(), 0u); + EXPECT_EQ(state.get_index(), 1u); + EXPECT_EQ(state.size(), 0u); } TEST_F(TestState, -SetIndex) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + SetIndex) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - State state(1); - state.set_index(2); + State state(1); + state.set_index(2); - EXPECT_EQ(state.get_index(), 2u); - EXPECT_EQ(state.size(), 0u); + EXPECT_EQ(state.get_index(), 2u); + EXPECT_EQ(state.size(), 0u); } TEST_F(TestState, -AddItem) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule1(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule2(43, &s1, std::vector*>{&s2}, [](Parser&, auto&&) -> int { return 0; }); - - State state(1); - auto result1 = state.add_item(Item{&rule1, 0}); - auto result2 = state.add_item(Item{&rule2, 0}); - EXPECT_EQ(state.size(), 2u); - EXPECT_THAT(result1, Pair(An*>(), Eq(true))); - EXPECT_THAT(result2, Pair(An*>(), Eq(true))); - EXPECT_NE(result1.first, result2.first); + AddItem) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule1(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule2(43, &s1, std::vector*>{&s2}, [](Parser&, auto&&) -> int { return 0; }); + + State state(1); + auto result1 = state.add_item(Item{&rule1, 0}); + auto result2 = state.add_item(Item{&rule2, 0}); + EXPECT_EQ(state.size(), 2u); + EXPECT_THAT(result1, Pair(An*>(), Eq(true))); + EXPECT_THAT(result2, Pair(An*>(), Eq(true))); + EXPECT_NE(result1.first, result2.first); } TEST_F(TestState, -AddItemAlreadyExists) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule1(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule2(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - - State state(1); - auto result1 = state.add_item(Item{&rule1, 0}); - auto result2 = state.add_item(Item{&rule2, 0}); - EXPECT_EQ(state.size(), 1u); - EXPECT_THAT(result1, Pair(An*>(), Eq(true))); - EXPECT_THAT(result2, Pair(An*>(), Eq(false))); - EXPECT_EQ(result1.first, result2.first); + AddItemAlreadyExists) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule1(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule2(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + + State state(1); + auto result1 = state.add_item(Item{&rule1, 0}); + auto result2 = state.add_item(Item{&rule2, 0}); + EXPECT_EQ(state.size(), 1u); + EXPECT_THAT(result1, Pair(An*>(), Eq(true))); + EXPECT_THAT(result2, Pair(An*>(), Eq(false))); + EXPECT_EQ(result1.first, result2.first); } TEST_F(TestState, -ItemsAreSorted) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule1(44, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule2(43, &s1, std::vector*>{&s2}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule3(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - - State state(1); - state.add_item(Item{&rule1, 0}); - state.add_item(Item{&rule2, 0}); - state.add_item(Item{&rule3, 0}); - EXPECT_EQ(state.size(), 3u); - EXPECT_EQ(state.begin()->get()->get_rule()->get_index(), 42u); - EXPECT_EQ((state.begin() + 1)->get()->get_rule()->get_index(), 43u); - EXPECT_EQ((state.begin() + 2)->get()->get_rule()->get_index(), 44u); + ItemsAreSorted) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule1(44, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule2(43, &s1, std::vector*>{&s2}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule3(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + + State state(1); + state.add_item(Item{&rule1, 0}); + state.add_item(Item{&rule2, 0}); + state.add_item(Item{&rule3, 0}); + EXPECT_EQ(state.size(), 3u); + EXPECT_EQ(state.begin()->get()->get_rule()->get_index(), 42u); + EXPECT_EQ((state.begin() + 1)->get()->get_rule()->get_index(), 43u); + EXPECT_EQ((state.begin() + 2)->get()->get_rule()->get_index(), 44u); } TEST_F(TestState, -ItemAreIterable) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule1(44, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule2(43, &s1, std::vector*>{&s2}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule3(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - - State state(1); - auto result1 = state.add_item(Item{&rule1, 0}); - auto result2 = state.add_item(Item{&rule2, 0}); - auto result3 = state.add_item(Item{&rule3, 0}); - - auto expected = std::vector*>{result3.first, result2.first, result1.first}; - std::size_t i = 0; - for (const auto& item : state) - EXPECT_EQ(item.get(), expected[i++]); + ItemAreIterable) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule1(44, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule2(43, &s1, std::vector*>{&s2}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule3(42, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + + State state(1); + auto result1 = state.add_item(Item{&rule1, 0}); + auto result2 = state.add_item(Item{&rule2, 0}); + auto result3 = state.add_item(Item{&rule3, 0}); + + auto expected = std::vector*>{result3.first, result2.first, result1.first}; + std::size_t i = 0; + for (const auto& item : state) + EXPECT_EQ(item.get(), expected[i++]); } TEST_F(TestState, -AddTransition) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule1(42, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule2(43, &s1, std::vector*>{&s2}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule3(44, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - - State state1(1); - state1.add_item(Item{&rule1, 0}); - State state2(2); - state2.add_item(Item{&rule2, 0}); - - state1.add_transition(&s1, &state2); - - EXPECT_EQ(state1.get_transitions().size(), 1u); - auto itr = state1.get_transitions().find(&s1); - EXPECT_NE(itr, state1.get_transitions().end()); - EXPECT_EQ(itr->second, &state2); + AddTransition) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule1(42, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule2(43, &s1, std::vector*>{&s2}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule3(44, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + + State state1(1); + state1.add_item(Item{&rule1, 0}); + State state2(2); + state2.add_item(Item{&rule2, 0}); + + state1.add_transition(&s1, &state2); + + EXPECT_EQ(state1.get_transitions().size(), 1u); + auto itr = state1.get_transitions().find(&s1); + EXPECT_NE(itr, state1.get_transitions().end()); + EXPECT_EQ(itr->second, &state2); } TEST_F(TestState, -AddBackTransition) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::Nonterminal, "3"); - Rule rule1(42, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule2(43, &s1, std::vector*>{&s2}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule3(44, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - - State state1(1); - state1.add_item(Item{&rule1, 0}); - State state2(30); - state2.add_item(Item{&rule2, 0}); - State state3(20); - state2.add_item(Item{&rule3, 0}); - - state1.add_back_transition(&s1, &state2); - state1.add_back_transition(&s1, &state3); - - EXPECT_EQ(state1.get_back_transitions().size(), 1u); - auto itr = state1.get_back_transitions().find(&s1); - EXPECT_NE(itr, state1.get_back_transitions().end()); - EXPECT_EQ(itr->second, (std::vector*>{&state3, &state2})); + AddBackTransition) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::Nonterminal, "3"); + Rule rule1(42, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule2(43, &s1, std::vector*>{&s2}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule3(44, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + + State state1(1); + state1.add_item(Item{&rule1, 0}); + State state2(30); + state2.add_item(Item{&rule2, 0}); + State state3(20); + state2.add_item(Item{&rule3, 0}); + + state1.add_back_transition(&s1, &state2); + state1.add_back_transition(&s1, &state3); + + EXPECT_EQ(state1.get_back_transitions().size(), 1u); + auto itr = state1.get_back_transitions().find(&s1); + EXPECT_NE(itr, state1.get_back_transitions().end()); + EXPECT_EQ(itr->second, (std::vector*>{&state3, &state2})); } TEST_F(TestState, -IsAccepting) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::End, "3"); - Rule rule1(42, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule2(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - - State state1(1); - state1.add_item(Item{&rule1, 0}); - State state2(2); - state2.add_item(Item{&rule2, 0}); - State state3(3); - state3.add_item(Item{&rule2, 1}); - - EXPECT_FALSE(state1.is_accepting()); - EXPECT_FALSE(state2.is_accepting()); - EXPECT_TRUE(state3.is_accepting()); + IsAccepting) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::End, "3"); + Rule rule1(42, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule2(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + + State state1(1); + state1.add_item(Item{&rule1, 0}); + State state2(2); + state2.add_item(Item{&rule2, 0}); + State state3(3); + state3.add_item(Item{&rule2, 1}); + + EXPECT_FALSE(state1.is_accepting()); + EXPECT_FALSE(state2.is_accepting()); + EXPECT_TRUE(state3.is_accepting()); } TEST_F(TestState, -ToString) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::End, "3"); - Rule rule1(42, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); - Rule rule2(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - - State state(1); - state.add_item(Item{&rule1, 0}); - state.add_item(Item{&rule2, 0}); - state.add_item(Item{&rule2, 1}); - - EXPECT_EQ(state.to_string(), "1 -> 2 <*> 3\n1 -> <*> \n1 -> <*> 2 3"); + ToString) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::End, "3"); + Rule rule1(42, &s1, std::vector*>{}, [](Parser&, auto&&) -> int { return 0; }); + Rule rule2(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + + State state(1); + state.add_item(Item{&rule1, 0}); + state.add_item(Item{&rule2, 0}); + state.add_item(Item{&rule2, 1}); + + EXPECT_EQ(state.to_string(), "1 -> 2 <*> 3\n1 -> <*> \n1 -> <*> 2 3"); } TEST_F(TestState, -GetProductionItems) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::End, "3"); - Rule rule(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - - State state(1); - state.add_item(Item{&rule, 0}); - state.add_item(Item{&rule, 1}); - - auto expected = std::vector*>{}; - EXPECT_EQ(state.get_production_items(), expected); - - auto i = state.add_item(Item{&rule, 2}); - expected.push_back(i.first); - EXPECT_EQ(state.get_production_items(), expected); + GetProductionItems) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::End, "3"); + Rule rule(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + + State state(1); + state.add_item(Item{&rule, 0}); + state.add_item(Item{&rule, 1}); + + auto expected = std::vector*>{}; + EXPECT_EQ(state.get_production_items(), expected); + + auto i = state.add_item(Item{&rule, 2}); + expected.push_back(i.first); + EXPECT_EQ(state.get_production_items(), expected); } TEST_F(TestState, -Contains) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::End, "3"); - Rule rule(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - - State state(1); - state.add_item(Item{&rule, 0}); - state.add_item(Item{&rule, 1}); - - EXPECT_TRUE(state.contains(Item{&rule, 0})); - EXPECT_TRUE(state.contains(Item{&rule, 1})); - EXPECT_FALSE(state.contains(Item{&rule, 2})); + Contains) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::End, "3"); + Rule rule(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + + State state(1); + state.add_item(Item{&rule, 0}); + state.add_item(Item{&rule, 1}); + + EXPECT_TRUE(state.contains(Item{&rule, 0})); + EXPECT_TRUE(state.contains(Item{&rule, 1})); + EXPECT_FALSE(state.contains(Item{&rule, 2})); } TEST_F(TestState, -Equality) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::End, "3"); - Rule rule(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + Equality) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::End, "3"); + Rule rule(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - State state1(1); - state1.add_item(Item{&rule, 0}); - state1.add_item(Item{&rule, 1}); + State state1(1); + state1.add_item(Item{&rule, 0}); + state1.add_item(Item{&rule, 1}); - State state2(2); - state2.add_item(Item{&rule, 0}); - state2.add_item(Item{&rule, 1}); + State state2(2); + state2.add_item(Item{&rule, 0}); + state2.add_item(Item{&rule, 1}); - State state3(3); - state3.add_item(Item{&rule, 0}); - state3.add_item(Item{&rule, 2}); + State state3(3); + state3.add_item(Item{&rule, 0}); + state3.add_item(Item{&rule, 2}); - EXPECT_TRUE(state1 == state2); - EXPECT_FALSE(state1 == state3); + EXPECT_TRUE(state1 == state2); + EXPECT_FALSE(state1 == state3); - EXPECT_FALSE(state1 != state2); - EXPECT_TRUE(state1 != state3); + EXPECT_FALSE(state1 != state2); + EXPECT_TRUE(state1 != state3); } TEST_F(TestState, -Kernel) { - Symbol s1(1, SymbolKind::Nonterminal, "1"); - Symbol s2(2, SymbolKind::Nonterminal, "2"); - Symbol s3(3, SymbolKind::End, "3"); - Rule rule(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); - - State state(1); - state.add_item(Item{&rule, 0}); - state.add_item(Item{&rule, 1}); - state.add_item(Item{&rule, 2}); - - std::vector kernel; - for (const auto& item : state.get_kernel()) - kernel.push_back(item->to_string()); - - EXPECT_EQ(kernel, (std::vector{"1 -> 2 <*> 3", "1 -> 2 3 <*>"})); + Kernel) { + Symbol s1(1, SymbolKind::Nonterminal, "1"); + Symbol s2(2, SymbolKind::Nonterminal, "2"); + Symbol s3(3, SymbolKind::End, "3"); + Rule rule(43, &s1, std::vector*>{&s2, &s3}, [](Parser&, auto&&) -> int { return 0; }); + + State state(1); + state.add_item(Item{&rule, 0}); + state.add_item(Item{&rule, 1}); + state.add_item(Item{&rule, 2}); + + std::vector kernel; + for (const auto& item : state.get_kernel()) + kernel.push_back(item->to_string()); + + EXPECT_EQ(kernel, (std::vector{"1 -> 2 <*> 3", "1 -> 2 3 <*>"})); } diff --git a/tests/Pog/Symbol.cpp b/tests/Pog/Symbol.cpp index cabccb75..cf65c8e8 100644 --- a/tests/Pog/Symbol.cpp +++ b/tests/Pog/Symbol.cpp @@ -7,51 +7,51 @@ class TestSymbol : public ::testing::Test {}; using namespace pog; TEST_F(TestSymbol, -Nonterminal) { - Symbol symbol(42, SymbolKind::Nonterminal, "testing_nonterminal"); - - EXPECT_EQ(symbol.get_index(), 42u); - EXPECT_EQ(symbol.get_name(), "testing_nonterminal"); - EXPECT_FALSE(symbol.is_end()); - EXPECT_TRUE(symbol.is_nonterminal()); - EXPECT_FALSE(symbol.is_terminal()); - EXPECT_FALSE(symbol.has_precedence()); + Nonterminal) { + Symbol symbol(42, SymbolKind::Nonterminal, "testing_nonterminal"); + + EXPECT_EQ(symbol.get_index(), 42u); + EXPECT_EQ(symbol.get_name(), "testing_nonterminal"); + EXPECT_FALSE(symbol.is_end()); + EXPECT_TRUE(symbol.is_nonterminal()); + EXPECT_FALSE(symbol.is_terminal()); + EXPECT_FALSE(symbol.has_precedence()); } TEST_F(TestSymbol, -Terminal) { - Symbol symbol(42, SymbolKind::Terminal, "testing_terminal"); - - EXPECT_EQ(symbol.get_index(), 42u); - EXPECT_EQ(symbol.get_name(), "testing_terminal"); - EXPECT_FALSE(symbol.is_end()); - EXPECT_FALSE(symbol.is_nonterminal()); - EXPECT_TRUE(symbol.is_terminal()); - EXPECT_FALSE(symbol.has_precedence()); + Terminal) { + Symbol symbol(42, SymbolKind::Terminal, "testing_terminal"); + + EXPECT_EQ(symbol.get_index(), 42u); + EXPECT_EQ(symbol.get_name(), "testing_terminal"); + EXPECT_FALSE(symbol.is_end()); + EXPECT_FALSE(symbol.is_nonterminal()); + EXPECT_TRUE(symbol.is_terminal()); + EXPECT_FALSE(symbol.has_precedence()); } TEST_F(TestSymbol, -End) { - Symbol symbol(42, SymbolKind::End, "testing_end"); - - EXPECT_EQ(symbol.get_index(), 42u); - EXPECT_EQ(symbol.get_name(), "testing_end"); - EXPECT_TRUE(symbol.is_end()); - EXPECT_FALSE(symbol.is_nonterminal()); - EXPECT_FALSE(symbol.is_terminal()); - EXPECT_FALSE(symbol.has_precedence()); + End) { + Symbol symbol(42, SymbolKind::End, "testing_end"); + + EXPECT_EQ(symbol.get_index(), 42u); + EXPECT_EQ(symbol.get_name(), "testing_end"); + EXPECT_TRUE(symbol.is_end()); + EXPECT_FALSE(symbol.is_nonterminal()); + EXPECT_FALSE(symbol.is_terminal()); + EXPECT_FALSE(symbol.has_precedence()); } TEST_F(TestSymbol, -Precedence) { - Symbol symbol(42, SymbolKind::Terminal, "testing_terminal"); - symbol.set_precedence(1, Associativity::Right); - - EXPECT_EQ(symbol.get_index(), 42u); - EXPECT_EQ(symbol.get_name(), "testing_terminal"); - EXPECT_FALSE(symbol.is_end()); - EXPECT_FALSE(symbol.is_nonterminal()); - EXPECT_TRUE(symbol.is_terminal()); - EXPECT_TRUE(symbol.has_precedence()); - EXPECT_EQ(symbol.get_precedence(), (Precedence{1, Associativity::Right})); + Precedence) { + Symbol symbol(42, SymbolKind::Terminal, "testing_terminal"); + symbol.set_precedence(1, Associativity::Right); + + EXPECT_EQ(symbol.get_index(), 42u); + EXPECT_EQ(symbol.get_name(), "testing_terminal"); + EXPECT_FALSE(symbol.is_end()); + EXPECT_FALSE(symbol.is_nonterminal()); + EXPECT_TRUE(symbol.is_terminal()); + EXPECT_TRUE(symbol.has_precedence()); + EXPECT_EQ(symbol.get_precedence(), (Precedence{1, Associativity::Right})); } diff --git a/tests/Pog/Token.cpp b/tests/Pog/Token.cpp index 5c362ca0..1c19925f 100644 --- a/tests/Pog/Token.cpp +++ b/tests/Pog/Token.cpp @@ -8,74 +8,74 @@ using namespace ::testing; class TestToken : public ::testing::Test {}; TEST_F(TestToken, -SimpleTokenWithoutSymbol) { - Token t(1, "abc", std::vector{"s1", "s2"}); - - EXPECT_EQ(t.get_index(), 1u); - EXPECT_EQ(t.get_pattern(), "abc"); - EXPECT_EQ(t.get_active_in_states(), (std::vector{"s1", "s2"})); - EXPECT_EQ(t.get_symbol(), nullptr); - EXPECT_THAT(t.get_regexp(), A()); - - EXPECT_FALSE(t.has_symbol()); - EXPECT_FALSE(t.has_action()); - EXPECT_FALSE(t.has_transition_to_state()); + SimpleTokenWithoutSymbol) { + Token t(1, "abc", std::vector{"s1", "s2"}); + + EXPECT_EQ(t.get_index(), 1u); + EXPECT_EQ(t.get_pattern(), "abc"); + EXPECT_EQ(t.get_active_in_states(), (std::vector{"s1", "s2"})); + EXPECT_EQ(t.get_symbol(), nullptr); + EXPECT_THAT(t.get_regexp(), A()); + + EXPECT_FALSE(t.has_symbol()); + EXPECT_FALSE(t.has_action()); + EXPECT_FALSE(t.has_transition_to_state()); } TEST_F(TestToken, -SimpleTokenWithSymbol) { - Symbol s(1, SymbolKind::Nonterminal, "a"); - Token t(1, "abc", std::vector{"s1", "s2"}, &s); - - EXPECT_EQ(t.get_index(), 1u); - EXPECT_EQ(t.get_pattern(), "abc"); - EXPECT_EQ(t.get_active_in_states(), (std::vector{"s1", "s2"})); - EXPECT_EQ(t.get_symbol(), &s); - EXPECT_THAT(t.get_regexp(), A()); - - EXPECT_TRUE(t.has_symbol()); - EXPECT_FALSE(t.has_action()); - EXPECT_FALSE(t.has_transition_to_state()); + SimpleTokenWithSymbol) { + Symbol s(1, SymbolKind::Nonterminal, "a"); + Token t(1, "abc", std::vector{"s1", "s2"}, &s); + + EXPECT_EQ(t.get_index(), 1u); + EXPECT_EQ(t.get_pattern(), "abc"); + EXPECT_EQ(t.get_active_in_states(), (std::vector{"s1", "s2"})); + EXPECT_EQ(t.get_symbol(), &s); + EXPECT_THAT(t.get_regexp(), A()); + + EXPECT_TRUE(t.has_symbol()); + EXPECT_FALSE(t.has_action()); + EXPECT_FALSE(t.has_transition_to_state()); } TEST_F(TestToken, -TransitionToState) { - Token t(1, "abc", std::vector{"s1", "s2"}); - t.set_transition_to_state("dest_state"); - - EXPECT_EQ(t.get_index(), 1u); - EXPECT_EQ(t.get_pattern(), "abc"); - EXPECT_EQ(t.get_active_in_states(), (std::vector{"s1", "s2"})); - EXPECT_EQ(t.get_symbol(), nullptr); - EXPECT_THAT(t.get_regexp(), A()); - - EXPECT_FALSE(t.has_symbol()); - EXPECT_FALSE(t.has_action()); - EXPECT_TRUE(t.has_transition_to_state()); - EXPECT_EQ(t.get_transition_to_state(), "dest_state"); + TransitionToState) { + Token t(1, "abc", std::vector{"s1", "s2"}); + t.set_transition_to_state("dest_state"); + + EXPECT_EQ(t.get_index(), 1u); + EXPECT_EQ(t.get_pattern(), "abc"); + EXPECT_EQ(t.get_active_in_states(), (std::vector{"s1", "s2"})); + EXPECT_EQ(t.get_symbol(), nullptr); + EXPECT_THAT(t.get_regexp(), A()); + + EXPECT_FALSE(t.has_symbol()); + EXPECT_FALSE(t.has_action()); + EXPECT_TRUE(t.has_transition_to_state()); + EXPECT_EQ(t.get_transition_to_state(), "dest_state"); } TEST_F(TestToken, -AddActiveInState) { - Token t(1, "abc", std::vector{"s1", "s2"}); + AddActiveInState) { + Token t(1, "abc", std::vector{"s1", "s2"}); - t.add_active_in_state("s3"); + t.add_active_in_state("s3"); - EXPECT_EQ(t.get_active_in_states(), (std::vector{"s1", "s2", "s3"})); + EXPECT_EQ(t.get_active_in_states(), (std::vector{"s1", "s2", "s3"})); } TEST_F(TestToken, -Action) { - bool called = false; - - Token t(1, "abc", std::vector{"s1", "s2"}); - t.set_action([&](std::string_view str) -> int { - called = true; - return static_cast(str.length()); - }); - - EXPECT_EQ(t.get_index(), 1u); - EXPECT_TRUE(t.has_action()); - EXPECT_EQ(t.perform_action("abcdef"), 6); - EXPECT_TRUE(called); + Action) { + bool called = false; + + Token t(1, "abc", std::vector{"s1", "s2"}); + t.set_action([&](std::string_view str) -> int { + called = true; + return static_cast(str.length()); + }); + + EXPECT_EQ(t.get_index(), 1u); + EXPECT_TRUE(t.has_action()); + EXPECT_EQ(t.perform_action("abcdef"), 6); + EXPECT_TRUE(called); } diff --git a/tests/Pog/TokenBuilder.cpp b/tests/Pog/TokenBuilder.cpp index b29601a5..1d16e831 100644 --- a/tests/Pog/TokenBuilder.cpp +++ b/tests/Pog/TokenBuilder.cpp @@ -4,142 +4,142 @@ using namespace pog; -class TestTokenBuilder : public ::testing::Test -{ +class TestTokenBuilder : public ::testing::Test { public: - TestTokenBuilder() : grammar(), tokenizer(&grammar) {} + TestTokenBuilder() + : grammar(), tokenizer(&grammar) { + } - Grammar grammar; - Tokenizer tokenizer; + Grammar grammar; + Tokenizer tokenizer; }; TEST_F(TestTokenBuilder, -Initialization) { - TokenBuilder tb(&grammar, &tokenizer); + Initialization) { + TokenBuilder tb(&grammar, &tokenizer); - EXPECT_EQ(grammar.get_symbols().size(), 2u); - EXPECT_EQ(tokenizer.get_tokens().size(), 1u); + EXPECT_EQ(grammar.get_symbols().size(), 2u); + EXPECT_EQ(tokenizer.get_tokens().size(), 1u); } TEST_F(TestTokenBuilder, -NoTokens) { - TokenBuilder tb(&grammar, &tokenizer); - tb.done(); + NoTokens) { + TokenBuilder tb(&grammar, &tokenizer); + tb.done(); - EXPECT_EQ(grammar.get_symbols().size(), 2u); - EXPECT_EQ(tokenizer.get_tokens().size(), 1u); + EXPECT_EQ(grammar.get_symbols().size(), 2u); + EXPECT_EQ(tokenizer.get_tokens().size(), 1u); } TEST_F(TestTokenBuilder, -SingleTokenWithoutAnything) { - TokenBuilder tb(&grammar, &tokenizer, "abc"); - tb.done(); + SingleTokenWithoutAnything) { + TokenBuilder tb(&grammar, &tokenizer, "abc"); + tb.done(); - EXPECT_EQ(grammar.get_symbols().size(), 2u); - EXPECT_EQ(tokenizer.get_tokens().size(), 2u); + EXPECT_EQ(grammar.get_symbols().size(), 2u); + EXPECT_EQ(tokenizer.get_tokens().size(), 2u); - EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); + EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); } TEST_F(TestTokenBuilder, -SingleTokenWithSymbol) { - TokenBuilder tb(&grammar, &tokenizer, "abc"); - tb.symbol("ABC"); - tb.done(); + SingleTokenWithSymbol) { + TokenBuilder tb(&grammar, &tokenizer, "abc"); + tb.symbol("ABC"); + tb.done(); - EXPECT_EQ(grammar.get_symbols().size(), 3u); - EXPECT_EQ(tokenizer.get_tokens().size(), 2u); + EXPECT_EQ(grammar.get_symbols().size(), 3u); + EXPECT_EQ(tokenizer.get_tokens().size(), 2u); - EXPECT_EQ(grammar.get_symbols()[2]->get_name(), "ABC"); - EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); + EXPECT_EQ(grammar.get_symbols()[2]->get_name(), "ABC"); + EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); } TEST_F(TestTokenBuilder, -SingleTokenWithAction) { - TokenBuilder tb(&grammar, &tokenizer, "abc"); - tb.action([](std::string_view) { return 42; }); - tb.done(); + SingleTokenWithAction) { + TokenBuilder tb(&grammar, &tokenizer, "abc"); + tb.action([](std::string_view) { return 42; }); + tb.done(); - EXPECT_EQ(grammar.get_symbols().size(), 2u); - EXPECT_EQ(tokenizer.get_tokens().size(), 2u); + EXPECT_EQ(grammar.get_symbols().size(), 2u); + EXPECT_EQ(tokenizer.get_tokens().size(), 2u); - EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); - EXPECT_TRUE(tokenizer.get_tokens()[1]->has_action()); - EXPECT_EQ(tokenizer.get_tokens()[1]->perform_action("xyz"), 42); + EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); + EXPECT_TRUE(tokenizer.get_tokens()[1]->has_action()); + EXPECT_EQ(tokenizer.get_tokens()[1]->perform_action("xyz"), 42); } TEST_F(TestTokenBuilder, -SingleTokenWithFullwordSpecifier) { - TokenBuilder tb(&grammar, &tokenizer, "abc"); - tb.fullword(); - tb.done(); + SingleTokenWithFullwordSpecifier) { + TokenBuilder tb(&grammar, &tokenizer, "abc"); + tb.fullword(); + tb.done(); - EXPECT_EQ(grammar.get_symbols().size(), 2u); - EXPECT_EQ(tokenizer.get_tokens().size(), 2u); + EXPECT_EQ(grammar.get_symbols().size(), 2u); + EXPECT_EQ(tokenizer.get_tokens().size(), 2u); - EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc(\\b|$)"); + EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc(\\b|$)"); } TEST_F(TestTokenBuilder, -SingleTokenWithStates) { - TokenBuilder tb(&grammar, &tokenizer, "abc"); - tb.states("state1", "state2"); - tb.done(); + SingleTokenWithStates) { + TokenBuilder tb(&grammar, &tokenizer, "abc"); + tb.states("state1", "state2"); + tb.done(); - EXPECT_EQ(grammar.get_symbols().size(), 2u); - EXPECT_EQ(tokenizer.get_tokens().size(), 2u); + EXPECT_EQ(grammar.get_symbols().size(), 2u); + EXPECT_EQ(tokenizer.get_tokens().size(), 2u); - EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); + EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); } TEST_F(TestTokenBuilder, -SingleTokenWithTransitionToState) { - TokenBuilder tb(&grammar, &tokenizer, "abc"); - tb.enter_state("state1"); - tb.done(); + SingleTokenWithTransitionToState) { + TokenBuilder tb(&grammar, &tokenizer, "abc"); + tb.enter_state("state1"); + tb.done(); - EXPECT_EQ(grammar.get_symbols().size(), 2u); - EXPECT_EQ(tokenizer.get_tokens().size(), 2u); + EXPECT_EQ(grammar.get_symbols().size(), 2u); + EXPECT_EQ(tokenizer.get_tokens().size(), 2u); - EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); - EXPECT_TRUE(tokenizer.get_tokens()[1]->has_transition_to_state()); - EXPECT_EQ(tokenizer.get_tokens()[1]->get_transition_to_state(), "state1"); + EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); + EXPECT_TRUE(tokenizer.get_tokens()[1]->has_transition_to_state()); + EXPECT_EQ(tokenizer.get_tokens()[1]->get_transition_to_state(), "state1"); } TEST_F(TestTokenBuilder, -SingleTokenWithPrecedence) { - TokenBuilder tb(&grammar, &tokenizer, "abc"); - tb.symbol("ABC"); - tb.precedence(1, Associativity::Left); - tb.done(); - - EXPECT_EQ(grammar.get_symbols().size(), 3u); - EXPECT_EQ(tokenizer.get_tokens().size(), 2u); - - EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); - EXPECT_TRUE(grammar.get_symbols()[2]->has_precedence()); - EXPECT_EQ(grammar.get_symbols()[2]->get_precedence(), (Precedence{1, Associativity::Left})); + SingleTokenWithPrecedence) { + TokenBuilder tb(&grammar, &tokenizer, "abc"); + tb.symbol("ABC"); + tb.precedence(1, Associativity::Left); + tb.done(); + + EXPECT_EQ(grammar.get_symbols().size(), 3u); + EXPECT_EQ(tokenizer.get_tokens().size(), 2u); + + EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); + EXPECT_TRUE(grammar.get_symbols()[2]->has_precedence()); + EXPECT_EQ(grammar.get_symbols()[2]->get_precedence(), (Precedence{1, Associativity::Left})); } TEST_F(TestTokenBuilder, -MultipleTokensDescription) { - TokenBuilder tb1(&grammar, &tokenizer, "abc"); - tb1.symbol("ABC"); - tb1.description("abc token"); - tb1.done(); - - TokenBuilder tb2(&grammar, &tokenizer, "def"); - tb2.symbol("DEF"); - tb2.done(); - - - EXPECT_EQ(grammar.get_symbols().size(), 4u); - EXPECT_EQ(tokenizer.get_tokens().size(), 3u); - - EXPECT_EQ(grammar.get_symbols()[2]->get_name(), "ABC"); - EXPECT_EQ(grammar.get_symbols()[2]->get_description(), "abc token"); - EXPECT_EQ(grammar.get_symbols()[3]->get_name(), "DEF"); - EXPECT_EQ(grammar.get_symbols()[3]->get_description(), "DEF"); - EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); - EXPECT_EQ(tokenizer.get_tokens()[2]->get_pattern(), "def"); + MultipleTokensDescription) { + TokenBuilder tb1(&grammar, &tokenizer, "abc"); + tb1.symbol("ABC"); + tb1.description("abc token"); + tb1.done(); + + TokenBuilder tb2(&grammar, &tokenizer, "def"); + tb2.symbol("DEF"); + tb2.done(); + + EXPECT_EQ(grammar.get_symbols().size(), 4u); + EXPECT_EQ(tokenizer.get_tokens().size(), 3u); + + EXPECT_EQ(grammar.get_symbols()[2]->get_name(), "ABC"); + EXPECT_EQ(grammar.get_symbols()[2]->get_description(), "abc token"); + EXPECT_EQ(grammar.get_symbols()[3]->get_name(), "DEF"); + EXPECT_EQ(grammar.get_symbols()[3]->get_description(), "DEF"); + EXPECT_EQ(tokenizer.get_tokens()[1]->get_pattern(), "abc"); + EXPECT_EQ(tokenizer.get_tokens()[2]->get_pattern(), "def"); } diff --git a/tests/Pog/Tokenizer.cpp b/tests/Pog/Tokenizer.cpp index ad2197b1..7ebfcea6 100644 --- a/tests/Pog/Tokenizer.cpp +++ b/tests/Pog/Tokenizer.cpp @@ -4,292 +4,291 @@ using namespace pog; -class TestTokenizer : public ::testing::Test -{ +class TestTokenizer : public ::testing::Test { public: - Grammar grammar; + Grammar grammar; }; TEST_F(TestTokenizer, -Initialization) { - Tokenizer t(&grammar); + Initialization) { + Tokenizer t(&grammar); - EXPECT_EQ(t.get_tokens().size(), 1u); - EXPECT_EQ(t.get_tokens()[0].get(), t.get_end_token()); - EXPECT_FALSE(t.get_tokens()[0]->has_symbol()); + EXPECT_EQ(t.get_tokens().size(), 1u); + EXPECT_EQ(t.get_tokens()[0].get(), t.get_end_token()); + EXPECT_FALSE(t.get_tokens()[0]->has_symbol()); } TEST_F(TestTokenizer, -AddToken) { - auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); - auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); - - Tokenizer t(&grammar); - - t.add_token("aaa", a, std::vector{std::string{decltype(t)::DefaultState}}); - t.add_token("bbb", b, std::vector{std::string{decltype(t)::DefaultState}}); - t.add_token("ccc", nullptr, std::vector{std::string{decltype(t)::DefaultState}}); - - EXPECT_EQ(t.get_tokens().size(), 4u); - EXPECT_EQ(t.get_tokens()[1]->get_pattern(), "aaa"); - EXPECT_TRUE(t.get_tokens()[1]->has_symbol()); - EXPECT_EQ(t.get_tokens()[1]->get_symbol(), a); - EXPECT_EQ(t.get_tokens()[2]->get_pattern(), "bbb"); - EXPECT_TRUE(t.get_tokens()[2]->has_symbol()); - EXPECT_EQ(t.get_tokens()[2]->get_symbol(), b); - EXPECT_EQ(t.get_tokens()[3]->get_pattern(), "ccc"); - EXPECT_FALSE(t.get_tokens()[3]->has_symbol()); + AddToken) { + auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); + auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); + + Tokenizer t(&grammar); + + t.add_token("aaa", a, std::vector{std::string{decltype(t)::DefaultState}}); + t.add_token("bbb", b, std::vector{std::string{decltype(t)::DefaultState}}); + t.add_token("ccc", nullptr, std::vector{std::string{decltype(t)::DefaultState}}); + + EXPECT_EQ(t.get_tokens().size(), 4u); + EXPECT_EQ(t.get_tokens()[1]->get_pattern(), "aaa"); + EXPECT_TRUE(t.get_tokens()[1]->has_symbol()); + EXPECT_EQ(t.get_tokens()[1]->get_symbol(), a); + EXPECT_EQ(t.get_tokens()[2]->get_pattern(), "bbb"); + EXPECT_TRUE(t.get_tokens()[2]->has_symbol()); + EXPECT_EQ(t.get_tokens()[2]->get_symbol(), b); + EXPECT_EQ(t.get_tokens()[3]->get_pattern(), "ccc"); + EXPECT_FALSE(t.get_tokens()[3]->has_symbol()); } TEST_F(TestTokenizer, -NextToken) { - auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); - auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); + NextToken) { + auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); + auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); - Tokenizer t(&grammar); + Tokenizer t(&grammar); - t.add_token("aaa", a, std::vector{std::string{decltype(t)::DefaultState}}); - t.add_token("bbb", b, std::vector{std::string{decltype(t)::DefaultState}}); - t.add_token("ccc", nullptr, std::vector{std::string{decltype(t)::DefaultState}}); - t.prepare(); + t.add_token("aaa", a, std::vector{std::string{decltype(t)::DefaultState}}); + t.add_token("bbb", b, std::vector{std::string{decltype(t)::DefaultState}}); + t.add_token("ccc", nullptr, std::vector{std::string{decltype(t)::DefaultState}}); + t.prepare(); - std::string input("aaacccbbb"); - t.push_input_stream(input); + std::string input("aaacccbbb"); + t.push_input_stream(input); - auto result = t.next_token(); - EXPECT_TRUE(result); - EXPECT_EQ(result.value().symbol, a); + auto result = t.next_token(); + EXPECT_TRUE(result); + EXPECT_EQ(result.value().symbol, a); - result = t.next_token(); - EXPECT_TRUE(result); - EXPECT_EQ(result.value().symbol, b); + result = t.next_token(); + EXPECT_TRUE(result); + EXPECT_EQ(result.value().symbol, b); - result = t.next_token(); - EXPECT_TRUE(result); - EXPECT_EQ(result.value().symbol, grammar.get_end_of_input_symbol()); + result = t.next_token(); + EXPECT_TRUE(result); + EXPECT_EQ(result.value().symbol, grammar.get_end_of_input_symbol()); } TEST_F(TestTokenizer, -NextTokenWithUnknownToken) { - auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); - auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); + NextTokenWithUnknownToken) { + auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); + auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); - Tokenizer t(&grammar); + Tokenizer t(&grammar); - t.add_token("aaa", a, std::vector{std::string{decltype(t)::DefaultState}}); - t.add_token("bbb", b, std::vector{std::string{decltype(t)::DefaultState}}); - t.add_token("ccc", nullptr, std::vector{std::string{decltype(t)::DefaultState}}); - t.prepare(); + t.add_token("aaa", a, std::vector{std::string{decltype(t)::DefaultState}}); + t.add_token("bbb", b, std::vector{std::string{decltype(t)::DefaultState}}); + t.add_token("ccc", nullptr, std::vector{std::string{decltype(t)::DefaultState}}); + t.prepare(); - std::string input("aaaccbbb"); - t.push_input_stream(input); + std::string input("aaaccbbb"); + t.push_input_stream(input); - auto result = t.next_token(); - EXPECT_TRUE(result); - EXPECT_EQ(result.value().symbol, a); + auto result = t.next_token(); + EXPECT_TRUE(result); + EXPECT_EQ(result.value().symbol, a); - result = t.next_token(); - EXPECT_FALSE(result); + result = t.next_token(); + EXPECT_FALSE(result); } TEST_F(TestTokenizer, -NextTokenLongestMatchWins) { - auto a1 = grammar.add_symbol(SymbolKind::Terminal, "a1"); - auto a2 = grammar.add_symbol(SymbolKind::Terminal, "a3"); - auto a3 = grammar.add_symbol(SymbolKind::Terminal, "a3"); + NextTokenLongestMatchWins) { + auto a1 = grammar.add_symbol(SymbolKind::Terminal, "a1"); + auto a2 = grammar.add_symbol(SymbolKind::Terminal, "a3"); + auto a3 = grammar.add_symbol(SymbolKind::Terminal, "a3"); - Tokenizer t(&grammar); + Tokenizer t(&grammar); - t.add_token("a", a1, std::vector{std::string{decltype(t)::DefaultState}}); - t.add_token("aaa", a3, std::vector{std::string{decltype(t)::DefaultState}}); - t.add_token("aa", a2, std::vector{std::string{decltype(t)::DefaultState}}); - t.prepare(); + t.add_token("a", a1, std::vector{std::string{decltype(t)::DefaultState}}); + t.add_token("aaa", a3, std::vector{std::string{decltype(t)::DefaultState}}); + t.add_token("aa", a2, std::vector{std::string{decltype(t)::DefaultState}}); + t.prepare(); - std::string input("aaaaa"); - t.push_input_stream(input); + std::string input("aaaaa"); + t.push_input_stream(input); - auto result = t.next_token(); - EXPECT_TRUE(result); - EXPECT_EQ(result.value().symbol, a3); + auto result = t.next_token(); + EXPECT_TRUE(result); + EXPECT_EQ(result.value().symbol, a3); } TEST_F(TestTokenizer, -NextTokenIndexWinsInCaseOfEqualMatch) { - auto a3 = grammar.add_symbol(SymbolKind::Terminal, "a3"); - auto an = grammar.add_symbol(SymbolKind::Terminal, "an"); + NextTokenIndexWinsInCaseOfEqualMatch) { + auto a3 = grammar.add_symbol(SymbolKind::Terminal, "a3"); + auto an = grammar.add_symbol(SymbolKind::Terminal, "an"); - Tokenizer t(&grammar); + Tokenizer t(&grammar); - t.add_token("aaa", a3, std::vector{std::string{decltype(t)::DefaultState}}); - t.add_token("a*", an, std::vector{std::string{decltype(t)::DefaultState}}); - t.prepare(); + t.add_token("aaa", a3, std::vector{std::string{decltype(t)::DefaultState}}); + t.add_token("a*", an, std::vector{std::string{decltype(t)::DefaultState}}); + t.prepare(); - std::string input("aaa"); - t.push_input_stream(input); + std::string input("aaa"); + t.push_input_stream(input); - auto result = t.next_token(); - EXPECT_TRUE(result); - EXPECT_EQ(result.value().symbol, a3); + auto result = t.next_token(); + EXPECT_TRUE(result); + EXPECT_EQ(result.value().symbol, a3); } TEST_F(TestTokenizer, -TokenActionsPerformed) { - auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); - auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); - - Tokenizer t(&grammar); - - std::vector matches; - - auto a_t = t.add_token("a+", a, std::vector{std::string{decltype(t)::DefaultState}}); - a_t->set_action([&](std::string_view str) { - matches.push_back(std::string{str}); - return 0; - }); - auto b_t = t.add_token("b+", b, std::vector{std::string{decltype(t)::DefaultState}}); - b_t->set_action([&](std::string_view str) { - matches.push_back(std::string{str}); - return 0; - }); - t.get_end_token()->set_action([&](std::string_view str) { - matches.push_back(std::string{str}); - return 0; - }); - t.prepare(); - - std::string input("aabbbbaaaaabb"); - t.push_input_stream(input); - - for (auto i = 0; i < 5; ++i) - t.next_token(); - - EXPECT_EQ(matches.size(), 5u); - EXPECT_EQ(matches, (std::vector{"aa", "bbbb", "aaaaa", "bb", ""})); + TokenActionsPerformed) { + auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); + auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); + + Tokenizer t(&grammar); + + std::vector matches; + + auto a_t = t.add_token("a+", a, std::vector{std::string{decltype(t)::DefaultState}}); + a_t->set_action([&](std::string_view str) { + matches.push_back(std::string{str}); + return 0; + }); + auto b_t = t.add_token("b+", b, std::vector{std::string{decltype(t)::DefaultState}}); + b_t->set_action([&](std::string_view str) { + matches.push_back(std::string{str}); + return 0; + }); + t.get_end_token()->set_action([&](std::string_view str) { + matches.push_back(std::string{str}); + return 0; + }); + t.prepare(); + + std::string input("aabbbbaaaaabb"); + t.push_input_stream(input); + + for (auto i = 0; i < 5; ++i) + t.next_token(); + + EXPECT_EQ(matches.size(), 5u); + EXPECT_EQ(matches, (std::vector{"aa", "bbbb", "aaaaa", "bb", ""})); } TEST_F(TestTokenizer, -NextTokenGlobalActionPerformed) { - auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); - auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); + NextTokenGlobalActionPerformed) { + auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); + auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); - Tokenizer t(&grammar); + Tokenizer t(&grammar); - std::vector matches; + std::vector matches; - t.global_action([&](std::string_view str) { - matches.push_back(fmt::format("global:{}", str)); - }); - auto a_t = t.add_token("a+", a, std::vector{std::string{decltype(t)::DefaultState}}); - a_t->set_action([&](std::string_view str) { - matches.push_back(std::string{str}); - return 0; - }); - t.add_token("b+", b, std::vector{std::string{decltype(t)::DefaultState}}); - t.prepare(); + t.global_action([&](std::string_view str) { + matches.push_back(fmt::format("global:{}", str)); + }); + auto a_t = t.add_token("a+", a, std::vector{std::string{decltype(t)::DefaultState}}); + a_t->set_action([&](std::string_view str) { + matches.push_back(std::string{str}); + return 0; + }); + t.add_token("b+", b, std::vector{std::string{decltype(t)::DefaultState}}); + t.prepare(); - std::string input("aabbbbaaaaabb"); - t.push_input_stream(input); + std::string input("aabbbbaaaaabb"); + t.push_input_stream(input); - for (auto i = 0; i < 5; ++i) - t.next_token(); + for (auto i = 0; i < 5; ++i) + t.next_token(); - EXPECT_EQ(matches.size(), 7u); - EXPECT_EQ(matches, (std::vector{"global:aa", "aa", "global:bbbb", "global:aaaaa", "aaaaa", "global:bb", "global:"})); + EXPECT_EQ(matches.size(), 7u); + EXPECT_EQ(matches, (std::vector{"global:aa", "aa", "global:bbbb", "global:aaaaa", "aaaaa", "global:bb", "global:"})); } TEST_F(TestTokenizer, -InputStreamStackManipulation) { - auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); - auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); + InputStreamStackManipulation) { + auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); + auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); - Tokenizer t(&grammar); + Tokenizer t(&grammar); - t.add_token("aaa", a, std::vector{std::string{decltype(t)::DefaultState}}); - t.add_token("bbb", b, std::vector{std::string{decltype(t)::DefaultState}}); - t.prepare(); + t.add_token("aaa", a, std::vector{std::string{decltype(t)::DefaultState}}); + t.add_token("bbb", b, std::vector{std::string{decltype(t)::DefaultState}}); + t.prepare(); - std::string input("aaabbb"); - t.push_input_stream(input); + std::string input("aaabbb"); + t.push_input_stream(input); - auto result = t.next_token(); - EXPECT_TRUE(result); - EXPECT_EQ(result.value().symbol, a); + auto result = t.next_token(); + EXPECT_TRUE(result); + EXPECT_EQ(result.value().symbol, a); - std::string input2("aaaaaa"); - t.push_input_stream(input2); + std::string input2("aaaaaa"); + t.push_input_stream(input2); - result = t.next_token(); - EXPECT_TRUE(result); - EXPECT_EQ(result.value().symbol, a); + result = t.next_token(); + EXPECT_TRUE(result); + EXPECT_EQ(result.value().symbol, a); - result = t.next_token(); - EXPECT_TRUE(result); - EXPECT_EQ(result.value().symbol, a); + result = t.next_token(); + EXPECT_TRUE(result); + EXPECT_EQ(result.value().symbol, a); - result = t.next_token(); - EXPECT_TRUE(result); - EXPECT_EQ(result.value().symbol, grammar.get_end_of_input_symbol()); + result = t.next_token(); + EXPECT_TRUE(result); + EXPECT_EQ(result.value().symbol, grammar.get_end_of_input_symbol()); - t.pop_input_stream(); + t.pop_input_stream(); - result = t.next_token(); - EXPECT_TRUE(result); - EXPECT_EQ(result.value().symbol, b); + result = t.next_token(); + EXPECT_TRUE(result); + EXPECT_EQ(result.value().symbol, b); - result = t.next_token(); - EXPECT_TRUE(result); - EXPECT_EQ(result.value().symbol, grammar.get_end_of_input_symbol()); + result = t.next_token(); + EXPECT_TRUE(result); + EXPECT_EQ(result.value().symbol, grammar.get_end_of_input_symbol()); } TEST_F(TestTokenizer, -StatesAndTransitions) { - auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); - auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); - - Tokenizer t(&grammar); - - auto a_t = t.add_token("aaa", a, std::vector{std::string{decltype(t)::DefaultState}}); - auto b_t = t.add_token("bbb", b, std::vector{"state1"}); - a_t->set_transition_to_state("state1"); - b_t->set_transition_to_state(std::string{decltype(t)::DefaultState}); - t.prepare(); - - std::string input("aaabbb"); - t.push_input_stream(input); - EXPECT_TRUE(t.next_token()); - EXPECT_TRUE(t.next_token()); - EXPECT_TRUE(t.next_token()); - t.pop_input_stream(); - - std::string input2("aaaaaa"); - t.push_input_stream(input2); - EXPECT_TRUE(t.next_token()); - EXPECT_FALSE(t.next_token()); - t.pop_input_stream(); + StatesAndTransitions) { + auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); + auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); + + Tokenizer t(&grammar); + + auto a_t = t.add_token("aaa", a, std::vector{std::string{decltype(t)::DefaultState}}); + auto b_t = t.add_token("bbb", b, std::vector{"state1"}); + a_t->set_transition_to_state("state1"); + b_t->set_transition_to_state(std::string{decltype(t)::DefaultState}); + t.prepare(); + + std::string input("aaabbb"); + t.push_input_stream(input); + EXPECT_TRUE(t.next_token()); + EXPECT_TRUE(t.next_token()); + EXPECT_TRUE(t.next_token()); + t.pop_input_stream(); + + std::string input2("aaaaaa"); + t.push_input_stream(input2); + EXPECT_TRUE(t.next_token()); + EXPECT_FALSE(t.next_token()); + t.pop_input_stream(); } TEST_F(TestTokenizer, -EnterState) { - auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); - auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); + EnterState) { + auto a = grammar.add_symbol(SymbolKind::Terminal, "a"); + auto b = grammar.add_symbol(SymbolKind::Terminal, "b"); - Tokenizer t(&grammar); + Tokenizer t(&grammar); - [[maybe_unused]] auto a_t = t.add_token("aaa", a, std::vector{std::string{decltype(t)::DefaultState}}); - [[maybe_unused]] auto b_t = t.add_token("bbb", b, std::vector{"state1"}); - t.prepare(); + [[maybe_unused]] auto a_t = t.add_token("aaa", a, std::vector{std::string{decltype(t)::DefaultState}}); + [[maybe_unused]] auto b_t = t.add_token("bbb", b, std::vector{"state1"}); + t.prepare(); - t.enter_state("state1"); + t.enter_state("state1"); - std::string input("aaabbb"); - t.push_input_stream(input); - EXPECT_FALSE(t.next_token()); - t.pop_input_stream(); + std::string input("aaabbb"); + t.push_input_stream(input); + EXPECT_FALSE(t.next_token()); + t.pop_input_stream(); - std::string input2("bbbbbb"); - t.push_input_stream(input2); - EXPECT_TRUE(t.next_token()); - EXPECT_TRUE(t.next_token()); - EXPECT_FALSE(t.next_token()); - t.pop_input_stream(); + std::string input2("bbbbbb"); + t.push_input_stream(input2); + EXPECT_TRUE(t.next_token()); + EXPECT_TRUE(t.next_token()); + EXPECT_FALSE(t.next_token()); + t.pop_input_stream(); } diff --git a/tests/Pog/Utils.cpp b/tests/Pog/Utils.cpp index 6a207247..a012da50 100644 --- a/tests/Pog/Utils.cpp +++ b/tests/Pog/Utils.cpp @@ -5,58 +5,40 @@ class TestUtils : public ::testing::Test {}; TEST_F(TestUtils, -transform_if) { - std::vector v{0, 1, 2, 3, 4, 5, 6}; - - std::vector result; - pog::transform_if(v.begin(), v.end(), std::back_inserter(result), - [](auto i) { return i % 2 == 0; }, - [](auto i) { return i + 10; } - ); - EXPECT_EQ(result, (std::vector{10, 12, 14, 16})); - - result.clear(); - pog::transform_if(v.begin(), v.end(), std::back_inserter(result), - [](auto i) { return i < 100; }, - [](auto i) { return i + 10; } - ); - EXPECT_EQ(result, (std::vector{10, 11, 12, 13, 14, 15, 16})); - - result.clear(); - pog::transform_if(v.begin(), v.end(), std::back_inserter(result), - [](auto i) { return i > 100; }, - [](auto i) { return i + 10; } - ); - EXPECT_EQ(result, (std::vector{})); + transform_if) { + std::vector v{0, 1, 2, 3, 4, 5, 6}; + + std::vector result; + pog::transform_if(v.begin(), v.end(), std::back_inserter(result), [](auto i) { return i % 2 == 0; }, [](auto i) { return i + 10; }); + EXPECT_EQ(result, (std::vector{10, 12, 14, 16})); + + result.clear(); + pog::transform_if(v.begin(), v.end(), std::back_inserter(result), [](auto i) { return i < 100; }, [](auto i) { return i + 10; }); + EXPECT_EQ(result, (std::vector{10, 11, 12, 13, 14, 15, 16})); + + result.clear(); + pog::transform_if(v.begin(), v.end(), std::back_inserter(result), [](auto i) { return i > 100; }, [](auto i) { return i + 10; }); + EXPECT_EQ(result, (std::vector{})); } TEST_F(TestUtils, -accumulate_if) { - std::vector v{1, 2, 3, 4, 5, 6}; - - auto result = pog::accumulate_if(v.begin(), v.end(), 0, - [](auto i) { return i % 2 == 0; }, - [](auto res, auto i) { return res + i; } - ); - EXPECT_EQ(result, 12); - - result = pog::accumulate_if(v.begin(), v.end(), 0, - [](auto i) { return i < 100; }, - [](auto res, auto i) { return res + i; } - ); - EXPECT_EQ(result, 21); - - result = pog::accumulate_if(v.begin(), v.end(), 0, - [](auto i) { return i > 100; }, - [](auto res, auto i) { return res + i; } - ); - EXPECT_EQ(result, 0); + accumulate_if) { + std::vector v{1, 2, 3, 4, 5, 6}; + + auto result = pog::accumulate_if(v.begin(), v.end(), 0, [](auto i) { return i % 2 == 0; }, [](auto res, auto i) { return res + i; }); + EXPECT_EQ(result, 12); + + result = pog::accumulate_if(v.begin(), v.end(), 0, [](auto i) { return i < 100; }, [](auto res, auto i) { return res + i; }); + EXPECT_EQ(result, 21); + + result = pog::accumulate_if(v.begin(), v.end(), 0, [](auto i) { return i > 100; }, [](auto res, auto i) { return res + i; }); + EXPECT_EQ(result, 0); } TEST_F(TestUtils, -hash_combine) { - EXPECT_EQ(pog::hash_combine(1, 2), pog::hash_combine(1, 2)); - EXPECT_NE(pog::hash_combine(1, 2), pog::hash_combine(1, 3)); - EXPECT_NE(pog::hash_combine(1, 2), pog::hash_combine(2, 1)); - EXPECT_NE(pog::hash_combine(1, 2), pog::hash_combine(1, 2, 3)); + hash_combine) { + EXPECT_EQ(pog::hash_combine(1, 2), pog::hash_combine(1, 2)); + EXPECT_NE(pog::hash_combine(1, 2), pog::hash_combine(1, 3)); + EXPECT_NE(pog::hash_combine(1, 2), pog::hash_combine(2, 1)); + EXPECT_NE(pog::hash_combine(1, 2), pog::hash_combine(1, 2, 3)); } diff --git a/tests/fixtures.hpp b/tests/fixtures.hpp index 404be3d1..2b94bdf3 100644 --- a/tests/fixtures.hpp +++ b/tests/fixtures.hpp @@ -1,19 +1,18 @@ #pragma once -#include #include +#include #define private public -#include -#include -#include +#include +#include +#include #include #include -#include -#include +#include +#include +#include #include -#include - static constexpr std::uint64_t MEM_SIZE = 4096; static constexpr std::uint64_t MEM_FIXTURE_MEM_SIZE = 1024; @@ -21,7 +20,7 @@ static constexpr std::uint64_t MEM_PTR = 0x0102030405060708; class TempDir { public: - TempDir(const char* test_name) { + TempDir(const char* test_name) { dir_name = "test_"; dir_name += test_name; std::filesystem::create_directory(dir_name); @@ -32,37 +31,43 @@ class TempDir { [[maybe_unused]] auto t = chdir(".."); try { std::filesystem::remove_all(dir_name); - } catch (std::filesystem::filesystem_error&) { } + } catch (std::filesystem::filesystem_error&) { + } } + private: std::string dir_name; }; class MC_ST_TEST : public testing::Test { - protected: - HyperCPU::MemoryControllerST mcmt; - char tmp_buffer[MEM_FIXTURE_MEM_SIZE]; - std::uint64_t counter; - MC_ST_TEST() : mcmt(MEM_FIXTURE_MEM_SIZE), counter(0) { - std::memset(tmp_buffer, 0x55, MEM_FIXTURE_MEM_SIZE); - } +protected: + HyperCPU::MemoryControllerST mcmt; + char tmp_buffer[MEM_FIXTURE_MEM_SIZE]; + std::uint64_t counter; + MC_ST_TEST() + : mcmt(MEM_FIXTURE_MEM_SIZE), counter(0) { + std::memset(tmp_buffer, 0x55, MEM_FIXTURE_MEM_SIZE); + } }; class MC_ST_FAILTEST : public testing::Test { - protected: - HyperCPU::MemoryControllerST mcmt; - char tmp_buffer[MEM_FIXTURE_MEM_SIZE]; - std::uint64_t counter; - MC_ST_FAILTEST() : mcmt(MEM_FIXTURE_MEM_SIZE), counter(LONG_MAX) { - std::memset(tmp_buffer, 0x55, MEM_FIXTURE_MEM_SIZE); - } +protected: + HyperCPU::MemoryControllerST mcmt; + char tmp_buffer[MEM_FIXTURE_MEM_SIZE]; + std::uint64_t counter; + MC_ST_FAILTEST() + : mcmt(MEM_FIXTURE_MEM_SIZE), counter(LONG_MAX) { + std::memset(tmp_buffer, 0x55, MEM_FIXTURE_MEM_SIZE); + } }; class MC_ST_NEARFAILTEST : public testing::Test { - protected: - HyperCPU::MemoryControllerST mcmt; - std::uint64_t counter; - MC_ST_NEARFAILTEST() : mcmt(MEM_FIXTURE_MEM_SIZE) {} +protected: + HyperCPU::MemoryControllerST mcmt; + std::uint64_t counter; + MC_ST_NEARFAILTEST() + : mcmt(MEM_FIXTURE_MEM_SIZE) { + } }; class DECODER_TEST : public ::testing::Test { @@ -89,7 +94,9 @@ class CPU_TEST : public ::testing::Test { HyperCPU::Logger logger; HyperCPU::CPU cpu; - CPU_TEST() : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { } + CPU_TEST() + : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { + } }; class OPERAND_EVAL_TEST : public ::testing::Test { @@ -98,7 +105,9 @@ class OPERAND_EVAL_TEST : public ::testing::Test { HyperCPU::CPU cpu; std::pair result; - OPERAND_EVAL_TEST() : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { } + OPERAND_EVAL_TEST() + : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { + } }; class STACK_TEST : public ::testing::Test { @@ -106,7 +115,8 @@ class STACK_TEST : public ::testing::Test { HyperCPU::Logger logger; HyperCPU::CPU cpu; - STACK_TEST() : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { + STACK_TEST() + : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { *cpu.xbp = 1024; *cpu.xsp = 1024; } @@ -117,8 +127,8 @@ class IVT_INIT_TEST : public ::testing::Test { HyperCPU::Logger logger; HyperCPU::CPU cpu; - IVT_INIT_TEST() : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { - + IVT_INIT_TEST() + : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { } }; @@ -127,7 +137,9 @@ class EXCEPTION_TEST : public ::testing::Test { HyperCPU::Logger logger; HyperCPU::CPU cpu; - EXCEPTION_TEST() : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { } + EXCEPTION_TEST() + : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { + } virtual void SetUp() { *cpu.xsp = 512; @@ -148,7 +160,8 @@ class ASM_PARSER_TEST : public ::testing::Test { HCAsm::CompilerState _state; pog::Parser& parser; - ASM_PARSER_TEST() : compiler(HyperCPU::LogLevel::ERROR), _state(compiler.pool), parser(compiler.parser) { + ASM_PARSER_TEST() + : compiler(HyperCPU::LogLevel::ERROR), _state(compiler.pool), parser(compiler.parser) { parser.set_compiler_state(&_state); } }; @@ -157,7 +170,9 @@ class ASM_PARSER_STMT_TEST : public ::testing::Test { protected: HCAsm::HCAsmCompiler compiler; - ASM_PARSER_STMT_TEST() : compiler(HyperCPU::LogLevel::ERROR) { } + ASM_PARSER_STMT_TEST() + : compiler(HyperCPU::LogLevel::ERROR) { + } virtual void TearDown() { HCAsm::current_index = 0; @@ -168,7 +183,9 @@ class ASSEMBLER : public ::testing::Test { protected: HCAsm::HCAsmCompiler compiler; - ASSEMBLER() : compiler(HyperCPU::LogLevel::ERROR) { } + ASSEMBLER() + : compiler(HyperCPU::LogLevel::ERROR) { + } virtual void TearDown() { HCAsm::current_index = 0; @@ -180,7 +197,9 @@ class FULL_ASSEMBLER : public ::testing::Test { HCAsm::HCAsmCompiler compiler; TempDir dir; - FULL_ASSEMBLER() : compiler(HyperCPU::LogLevel::ERROR), dir(::testing::UnitTest::GetInstance()->current_test_info()->test_case_name()) { } + FULL_ASSEMBLER() + : compiler(HyperCPU::LogLevel::ERROR), dir(::testing::UnitTest::GetInstance()->current_test_info()->test_case_name()) { + } virtual void TearDown() { HCAsm::current_index = 0; @@ -191,7 +210,9 @@ class TWO_OPERANDS_SUCCESS : public ::testing::Test { protected: HCAsm::HCAsmCompiler compiler; - TWO_OPERANDS_SUCCESS() : compiler(HyperCPU::LogLevel::ERROR) { } + TWO_OPERANDS_SUCCESS() + : compiler(HyperCPU::LogLevel::ERROR) { + } virtual void TearDown() { HCAsm::current_index = 0; @@ -202,7 +223,9 @@ class TWO_OPERANDS_FAILURE : public ::testing::Test { protected: HCAsm::HCAsmCompiler compiler; - TWO_OPERANDS_FAILURE() : compiler(HyperCPU::LogLevel::ERROR) { } + TWO_OPERANDS_FAILURE() + : compiler(HyperCPU::LogLevel::ERROR) { + } virtual void TearDown() { HCAsm::current_index = 0; diff --git a/tests/main.cpp b/tests/main.cpp index 7031334c..5863b3eb 100644 --- a/tests/main.cpp +++ b/tests/main.cpp @@ -1,8 +1,8 @@ -#include #include "pch.hpp" +#include -int main(int argc, char **argv) { - ::testing::InitGoogleTest(&argc, argv); +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + return RUN_ALL_TESTS(); } diff --git a/tools/bazel/BUILD.bazel b/tools/bazel/BUILD.bazel index ce91b6d7..387d54a6 100644 --- a/tools/bazel/BUILD.bazel +++ b/tools/bazel/BUILD.bazel @@ -1,8 +1,9 @@ 'Common macros, rules etc. used by HyperCPU' +load('@bazel_skylib//rules:native_binary.bzl', 'native_binary') -package( - default_visibility = [ - "//:__subpackages__", - ], +native_binary( + name = 'clang_tidy', + src = '@llvm_toolchain_llvm//:bin/clang-tidy', + out = 'clang_tidy', ) diff --git a/tools/bazel/linting.bzl b/tools/bazel/linting.bzl new file mode 100644 index 00000000..f4008bcf --- /dev/null +++ b/tools/bazel/linting.bzl @@ -0,0 +1,11 @@ +load('@aspect_rules_lint//lint:clang_tidy.bzl', 'lint_clang_tidy_aspect') + +clang_tidy = lint_clang_tidy_aspect( + binary = '//tools/bazel:clang_tidy', + # configs = [ + # '//:.clang-tidy', + # ], + lint_target_headers = True, + angle_includes_are_system = True, + verbose = True, +) From 82cf8edb9741a9197f4184ff71b7356d26ff39dc Mon Sep 17 00:00:00 2001 From: AshFungor Date: Thu, 8 May 2025 23:09:57 +0300 Subject: [PATCH 08/40] src finished --- .bazelrc | 44 ++- BUILD.bazel | 6 +- MODULE.bazel | 12 +- src/Assembler/BUILD.bazel | 6 +- src/Assembler/Core/BinaryTransformer.hpp | 112 +++---- src/Assembler/Core/Compiler.cpp | 34 +- src/Assembler/Core/Compiler.hpp | 8 +- src/Assembler/Core/ModeNameAssoc.hpp | 2 +- src/Assembler/Core/OpcodeNameAssoc.hpp | 77 +++-- src/Assembler/Core/RegNameAssoc.hpp | 87 ++--- src/Assembler/Main/Main.cpp | 42 +-- src/Assembler/Utils/Extension.hpp | 7 - src/Common/NotImplemented.hpp | 4 +- src/{ => Common}/Version.hpp | 0 src/Emulator/BUILD.bazel | 42 ++- src/Emulator/Core/CPU/ALU.hpp | 2 +- src/Emulator/Core/CPU/Assert.hpp | 2 +- src/Emulator/Core/CPU/CPU.cpp | 21 +- src/Emulator/Core/CPU/CPU.hpp | 15 +- src/Emulator/Core/CPU/Decoders/StdDecoder.cpp | 81 +++-- src/Emulator/Core/CPU/Decoders/StdDecoder.hpp | 16 +- src/Emulator/Core/CPU/IO/Simple.cpp | 6 +- src/Emulator/Core/CPU/IO/Simple.hpp | 2 +- .../Core/CPU/InstructionsImpl/ADC.cpp | 316 +++++++++--------- .../Core/CPU/InstructionsImpl/ADD.cpp | 267 ++++++++------- .../Core/CPU/InstructionsImpl/AND.cpp | 230 +++++++------ .../Core/CPU/InstructionsImpl/ANDN.cpp | 274 ++++++++------- .../Core/CPU/InstructionsImpl/BSWAP.cpp | 52 ++- .../Core/CPU/InstructionsImpl/CALL.cpp | 37 +- .../Core/CPU/InstructionsImpl/CALLE.cpp | 38 +-- .../Core/CPU/InstructionsImpl/CALLGR.cpp | 37 +- .../Core/CPU/InstructionsImpl/CALLL.cpp | 37 +- .../Core/CPU/InstructionsImpl/CCRF.cpp | 11 +- .../Core/CPU/InstructionsImpl/CMP.cpp | 301 ++++++++--------- .../Core/CPU/InstructionsImpl/COVF.cpp | 10 +- .../Core/CPU/InstructionsImpl/CUDF.cpp | 10 +- .../Core/CPU/InstructionsImpl/DEC.cpp | 58 ++-- .../Core/CPU/InstructionsImpl/DIV.cpp | 66 ++-- .../Core/CPU/InstructionsImpl/HALT.cpp | 10 +- .../Core/CPU/InstructionsImpl/HID.cpp | 34 +- .../Core/CPU/InstructionsImpl/INC.cpp | 58 ++-- .../Core/CPU/InstructionsImpl/INTR.cpp | 27 +- .../Core/CPU/InstructionsImpl/JME.cpp | 34 +- .../Core/CPU/InstructionsImpl/JMGR.cpp | 33 +- .../Core/CPU/InstructionsImpl/JML.cpp | 33 +- .../Core/CPU/InstructionsImpl/JMP.cpp | 33 +- .../Core/CPU/InstructionsImpl/LOIVT.cpp | 28 +- .../Core/CPU/InstructionsImpl/MOV.cpp | 283 ++++++++-------- .../Core/CPU/InstructionsImpl/MUL.cpp | 268 ++++++++------- src/Emulator/Core/CPU/InstructionsImpl/OR.cpp | 229 +++++++------ .../Core/CPU/InstructionsImpl/POP.cpp | 39 +-- .../Core/CPU/InstructionsImpl/PUSH.cpp | 67 ++-- .../Core/CPU/InstructionsImpl/READ.cpp | 29 +- .../Core/CPU/InstructionsImpl/SHFL.cpp | 89 +++-- .../Core/CPU/InstructionsImpl/SHFR.cpp | 90 +++-- .../Core/CPU/InstructionsImpl/SUB.cpp | 242 +++++++------- .../Core/CPU/InstructionsImpl/WRITE.cpp | 27 +- .../Core/CPU/Interrupts/InterruptHandler.cpp | 15 +- .../CPU/Interrupts/ReservedInterrupts.hpp | 2 +- src/Emulator/Core/CPU/OperandsEvaluation.cpp | 129 ++++--- src/Emulator/Core/CPU/Stack.cpp | 6 +- .../MemoryController/IMemoryController.hpp | 9 +- .../MemoryController/MemoryControllerST.hpp | 8 +- src/Emulator/Main/Main.cpp | 180 +++++----- src/Emulator/Misc/bit_cast.hpp | 5 +- src/Emulator/Misc/byteswap.hpp | 5 +- src/Emulator/Misc/deref.hpp | 4 +- src/Emulator/Misc/overflow.hpp | 2 +- src/Emulator/Misc/print.hpp | 3 +- src/PCH/CStd.hpp | 1 + src/Pog/BUILD.bazel | 3 +- tools/bazel/BUILD.bazel | 8 - tools/bazel/linting.bzl | 11 - 73 files changed, 2068 insertions(+), 2348 deletions(-) delete mode 100644 src/Assembler/Utils/Extension.hpp rename src/{ => Common}/Version.hpp (100%) delete mode 100644 tools/bazel/linting.bzl diff --git a/.bazelrc b/.bazelrc index afe2c319..2bce9d49 100644 --- a/.bazelrc +++ b/.bazelrc @@ -1,2 +1,42 @@ -build --cxxopt=-std=c++23 --cxxopt=-Isrc/ -build --aspects //tools/bazel:linting.bzl%clang_tidy +# Make Bazel print out all options from rc files +common --announce_rc + +# We use 23 standard +build:linux --cxxopt=-std=c++23 +# Include: source directory +build:linux --cxxopt=-iquote --cxxopt=src +# Essential warnings +build:linux --cxxopt=-Wall +# Extra warnings +build:linux --cxxopt=-Wextra +# TODO: document the rest +build:linux --cxxopt=-Wno-pointer-arith +build:linux --cxxopt=-Wno-unused-const-variable +build:linux --cxxopt=-Wno-missing-field-initializers +build:linux --cxxopt=-Wno-stringop-overflow + +# LTO, see: https://gcc.gnu.org/wiki/LinkTimeOptimization +build:linux --cxxopt=-flto +build:linux --linkopt=-flto + +# Optimize for native (host) architecture +# Be warned - might break distribution builds +build:linux-fragile --config=linux +build:linux-fragile --cxxopt=-march=native + +# Treat warnings as errors should be enabled optionally +build:linux-strict --config=linux +build:linux-strict --cxxopt=-Werror + +# --- Build configurations --- +# Linux, Debug +build:linux-dbg --compilation_mode dbg +build:linux-dbg --config=linux-fragile +build:linux-dbg --cxxopt=-ggdb3 +# Linux, Release +build:linux-opt --compilation_mode opt +build:linux-opt --config=linux-strict +build:linux-opt --cxxopt=-O3 +# ---------------------------- + +# Distro-specific configurations diff --git a/BUILD.bazel b/BUILD.bazel index b11278ed..beb53971 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -12,8 +12,8 @@ refresh_compile_commands( format_multirun( name = 'format', - cc = '@llvm_toolchain_llvm//:bin/clang-format', - # python = '@aspect_rules_lint//format:ruff', - # starlark = '@buildifier_prebuilt//:buildifier', + cc = '@llvm_toolchain//:bin/clang-format', + python = '@aspect_rules_lint//format:ruff', + starlark = '@buildifier_prebuilt//:buildifier', print_command = True ) diff --git a/MODULE.bazel b/MODULE.bazel index 4b3acf78..90887760 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -29,8 +29,8 @@ use_repo( bazel_dep(name = 'rules_cc', version = '0.0.17') bazel_dep(name = 'aspect_rules_lint', version = '1.3.5') bazel_dep(name = 'bazel_skylib', version = '1.7.1') -bazel_dep(name = 'toolchains_llvm', version = '1.4.0') bazel_dep(name = 'hedron_compile_commands', dev_dependency = True) +bazel_dep(name = 'buildifier_prebuilt', version = '8.0.3', dev_dependency = True) git_override( module_name = 'hedron_compile_commands', @@ -38,10 +38,12 @@ git_override( commit = '4f28899228fb3ad0126897876f147ca15026151e' ) +# We use this for static analysis +bazel_dep(name = 'toolchains_llvm', version = '1.4.0', dev_dependency = True) + llvm = use_extension('@toolchains_llvm//toolchain/extensions:llvm.bzl', 'llvm') llvm.toolchain( - llvm_versions = { - '': '19.1.7', - } + llvm_version = '19.1.7', ) -use_repo(llvm, 'llvm_toolchain', 'llvm_toolchain_llvm') + +use_repo(llvm, 'llvm_toolchain') diff --git a/src/Assembler/BUILD.bazel b/src/Assembler/BUILD.bazel index ccc827f9..74cb07cd 100644 --- a/src/Assembler/BUILD.bazel +++ b/src/Assembler/BUILD.bazel @@ -15,12 +15,12 @@ cc_library( '//src/PCH:pch_cstd', '//src/Pog:pog', '//src/Common:hcpu_common', + '//dist:hpool', '@fmt//:fmt', '@re2//:re2', '@eternal//:eternal', - '@argparse//:argparse', '@spdlog//:spdlog', - '//dist:hpool' + '@argparse//:argparse' ] ) @@ -29,6 +29,6 @@ cc_binary( srcs = glob(['Main/**/*.cpp']), deps = [ ':assembler_core', - '@eternal//:eternal' + # TODO: research why direct deps do not provide system headers ] ) diff --git a/src/Assembler/Core/BinaryTransformer.hpp b/src/Assembler/Core/BinaryTransformer.hpp index b4ffd47b..f34e3b6c 100644 --- a/src/Assembler/Core/BinaryTransformer.hpp +++ b/src/Assembler/Core/BinaryTransformer.hpp @@ -2,9 +2,10 @@ #include -#include "Assembler/Core/Compiler.hpp" -#include "Common/LanguageSpec/Flags.hpp" #include "PCH/CStd.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "Assembler/Core/Compiler.hpp" + namespace HCAsm { struct BinaryResult; @@ -12,19 +13,19 @@ namespace HCAsm { struct Operand; enum class Op1T : std::uint8_t { - R = 0x10, - M = 0x20, - IMM = 0x30, - RM = 0x40, - NONE = 0x50 + R = 0x10, + M = 0x20, + IMM = 0x30, + RM = 0x40, + NONE = 0x50 }; enum class Op2T : std::uint8_t { - R = 0x01, - M = 0x02, - IMM = 0x03, - RM = 0x04, - NONE = 0x05 + R = 0x01, + M = 0x02, + IMM = 0x03, + RM = 0x04, + NONE = 0x05 }; constexpr inline std::uint8_t QuickOR(Op1T a, Op2T b) { @@ -36,76 +37,59 @@ namespace HCAsm { } enum class OperandTypes : std::uint8_t { - R_R = QuickOR(Op1T::R, Op2T::R), - R_RM = QuickOR(Op1T::R, Op2T::RM), - R_M = QuickOR(Op1T::R, Op2T::M), - R_IMM = QuickOR(Op1T::R, Op2T::IMM), - RM_R = QuickOR(Op1T::RM, Op2T::R), - RM_M = QuickOR(Op1T::RM, Op2T::M), - RM_IMM = QuickOR(Op1T::RM, Op2T::IMM), - M_R = QuickOR(Op1T::M, Op2T::R), - R = QuickOR(Op1T::R, Op2T::NONE), - M = QuickOR(Op1T::M, Op2T::NONE), - IMM = QuickOR(Op1T::IMM, Op2T::NONE), - NONE = QuickOR(Op1T::NONE, Op2T::NONE), + R_R = QuickOR(Op1T::R, Op2T::R), + R_RM = QuickOR(Op1T::R, Op2T::RM), + R_M = QuickOR(Op1T::R, Op2T::M), + R_IMM = QuickOR(Op1T::R, Op2T::IMM), + RM_R = QuickOR(Op1T::RM, Op2T::R), + RM_M = QuickOR(Op1T::RM, Op2T::M), + RM_IMM = QuickOR(Op1T::RM, Op2T::IMM), + M_R = QuickOR(Op1T::M, Op2T::R), + R = QuickOR(Op1T::R, Op2T::NONE), + M = QuickOR(Op1T::M, Op2T::NONE), + IMM = QuickOR(Op1T::IMM, Op2T::NONE), + NONE = QuickOR(Op1T::NONE, Op2T::NONE), }; constexpr HyperCPU::OperandTypes QuickCast(std::uint8_t x) { switch (static_cast(x)) { - case OperandTypes::R_R: - return HyperCPU::OperandTypes::R_R; - case OperandTypes::R_RM: - return HyperCPU::OperandTypes::R_RM; - case OperandTypes::R_M: - return HyperCPU::OperandTypes::R_M; - case OperandTypes::R_IMM: - return HyperCPU::OperandTypes::R_IMM; - case OperandTypes::RM_R: - return HyperCPU::OperandTypes::RM_R; - case OperandTypes::RM_M: - return HyperCPU::OperandTypes::RM_M; - case OperandTypes::RM_IMM: - return HyperCPU::OperandTypes::RM_IMM; - case OperandTypes::M_R: - return HyperCPU::OperandTypes::M_R; - case OperandTypes::R: - return HyperCPU::OperandTypes::R; - case OperandTypes::M: - return HyperCPU::OperandTypes::M; - case OperandTypes::IMM: - return HyperCPU::OperandTypes::IMM; - case OperandTypes::NONE: - return HyperCPU::OperandTypes::NONE; - default: - spdlog::error("Invalid operand types!"); - // TODO: handle error + case OperandTypes::R_R: return HyperCPU::OperandTypes::R_R; + case OperandTypes::R_RM: return HyperCPU::OperandTypes::R_RM; + case OperandTypes::R_M: return HyperCPU::OperandTypes::R_M; + case OperandTypes::R_IMM: return HyperCPU::OperandTypes::R_IMM; + case OperandTypes::RM_R: return HyperCPU::OperandTypes::RM_R; + case OperandTypes::RM_M: return HyperCPU::OperandTypes::RM_M; + case OperandTypes::RM_IMM: return HyperCPU::OperandTypes::RM_IMM; + case OperandTypes::M_R: return HyperCPU::OperandTypes::M_R; + case OperandTypes::R: return HyperCPU::OperandTypes::R; + case OperandTypes::M: return HyperCPU::OperandTypes::M; + case OperandTypes::IMM: return HyperCPU::OperandTypes::IMM; + case OperandTypes::NONE: return HyperCPU::OperandTypes::NONE; + default: + spdlog::error("Invalid operand types!"); + std::abort(); } } constexpr HyperCPU::Mode cast_mode(HCAsm::Mode md) { switch (md) { - case HCAsm::Mode::b8: - return HyperCPU::Mode::b8; - case HCAsm::Mode::b16: - return HyperCPU::Mode::b16; - case HCAsm::Mode::b32: - return HyperCPU::Mode::b32; - case HCAsm::Mode::b64: - return HyperCPU::Mode::b64; + case HCAsm::Mode::b8: return HyperCPU::Mode::b8; + case HCAsm::Mode::b16: return HyperCPU::Mode::b16; + case HCAsm::Mode::b32: return HyperCPU::Mode::b32; + case HCAsm::Mode::b64: return HyperCPU::Mode::b64; + default: std::abort(); } } class BinaryTransformer { public: - BinaryTransformer(BinaryResult& result, CompilerState* state = nullptr) - : res(result), state(state) { - } + // TODO: move to src + BinaryTransformer(BinaryResult& result, CompilerState* state = nullptr) : res(result), state(state) { } void EncodeInstruction(Instruction& instr); HyperCPU::OperandTypes DetermineOperandTypes(Operand& op1, Operand& op2); - private: BinaryResult& res; CompilerState* state; }; -} // namespace HCAsm +} diff --git a/src/Assembler/Core/Compiler.cpp b/src/Assembler/Core/Compiler.cpp index 75b55b1d..dd1b12e7 100644 --- a/src/Assembler/Core/Compiler.cpp +++ b/src/Assembler/Core/Compiler.cpp @@ -172,6 +172,7 @@ constexpr inline std::uint8_t HCAsm::HCAsmCompiler::OperandSize(HCAsm::OperandTy case HCAsm::OperandType::uint: case HCAsm::OperandType::label: return 8; + default: std::abort(); } } @@ -188,6 +189,7 @@ std::uint8_t HCAsm::HCAsmCompiler::ModeToSize(const Operand& op) { case Mode::b64_label: case Mode::b64: return 8; + default: std::abort(); } } @@ -202,6 +204,7 @@ std::uint8_t HCAsm::HCAsmCompiler::ModeToSize(Mode md) { case Mode::b64_label: case Mode::b64: return 8; + default: std::abort(); } } @@ -288,6 +291,7 @@ std::uint8_t HCAsm::HCAsmCompiler::InstructionSize(HCAsm::Instruction& instr) { break; case OperandType::none: break; + default: std::abort(); } return result; @@ -303,20 +307,21 @@ HCAsm::BinaryResult HCAsm::HCAsmCompiler::TransformToBinary(HCAsm::CompilerState if (label.is_entry_point) { ir.entry_point = ir.code_size; } }, [&ir](RawValue& raw) mutable -> void { ir.code_size += [&raw]() -> std::uint8_t { - switch (raw.mode) { - case Mode::b8_str: - return std::get>(raw.value.variant)->size(); - case Mode::b8: - return 1; - case Mode::b16: - return 2; - case Mode::b32: - return 4; - case Mode::b64_label: - case Mode::b64: - return 8; - } - }(); }); + switch (raw.mode) { + case Mode::b8_str: + return std::get>(raw.value.variant)->size(); + case Mode::b8: + return 1; + case Mode::b16: + return 2; + case Mode::b32: + return 4; + case Mode::b64_label: + case Mode::b64: + return 8; + default: std::abort(); + } + }(); }); } // Resolve references - pass 2 @@ -411,6 +416,7 @@ std::string_view HCAsm::FindLine(const pog::LineSpecialization& line_spec, const "", std::to_string(err_token.line_spec.line).length(), "", err_token.line_spec.offset, std::string(err_token.line_spec.length, '^')); + std::abort(); // handle error } diff --git a/src/Assembler/Core/Compiler.hpp b/src/Assembler/Core/Compiler.hpp index 71f88f1e..083f3fce 100644 --- a/src/Assembler/Core/Compiler.hpp +++ b/src/Assembler/Core/Compiler.hpp @@ -1,12 +1,14 @@ #pragma once +// TODO: fix this in hpool +#include #include -#include "Common/LanguageSpec/Flags.hpp" +#include "Common/Helpers/Classes.hpp" #include "Common/LanguageSpec/Opcodes.hpp" #include "Common/LanguageSpec/Registers.hpp" -#include "PCH/CStd.hpp" #include "Pog/Pog.hpp" +#include "PCH/CStd.hpp" namespace HCAsm { enum class ValueType { @@ -183,7 +185,9 @@ namespace HCAsm { case Reg::XLLL2: case Reg::XLLL3: return Mode::b8; + default: std::abort(); } + // TODO: handle missing return } std::string_view FindLine(const pog::LineSpecialization&, const std::string_view&); diff --git a/src/Assembler/Core/ModeNameAssoc.hpp b/src/Assembler/Core/ModeNameAssoc.hpp index 42dea1ff..b1e7926b 100644 --- a/src/Assembler/Core/ModeNameAssoc.hpp +++ b/src/Assembler/Core/ModeNameAssoc.hpp @@ -1,9 +1,9 @@ #pragma once +#include #include #include "Assembler/Core/Compiler.hpp" -#include "PCH/CStd.hpp" constexpr inline const auto mode_assoc = mapbox::eternal::hash_map({ {"b8", HCAsm::Mode::b8}, diff --git a/src/Assembler/Core/OpcodeNameAssoc.hpp b/src/Assembler/Core/OpcodeNameAssoc.hpp index 3364eb7a..a30a1609 100644 --- a/src/Assembler/Core/OpcodeNameAssoc.hpp +++ b/src/Assembler/Core/OpcodeNameAssoc.hpp @@ -1,43 +1,48 @@ #pragma once +#include #include #include "Common/LanguageSpec/Opcodes.hpp" #include "PCH/CStd.hpp" -constexpr inline const auto opcode_assoc = mapbox::eternal::hash_map({{"adc", HyperCPU::Opcode::ADC}, - {"add", HyperCPU::Opcode::ADD}, - {"and", HyperCPU::Opcode::AND}, - {"andn", HyperCPU::Opcode::ANDN}, - {"bswap", HyperCPU::Opcode::BSWAP}, - {"call", HyperCPU::Opcode::CALL}, - {"ccrf", HyperCPU::Opcode::CCRF}, - {"covf", HyperCPU::Opcode::COVF}, - {"cudf", HyperCPU::Opcode::CUDF}, - {"hid", HyperCPU::Opcode::HID}, - {"inc", HyperCPU::Opcode::INC}, - {"dec", HyperCPU::Opcode::DEC}, - {"div", HyperCPU::Opcode::DIV}, - {"mul", HyperCPU::Opcode::MUL}, - {"sub", HyperCPU::Opcode::SUB}, - {"shfr", HyperCPU::Opcode::SHFR}, - {"shfl", HyperCPU::Opcode::SHFL}, - {"or", HyperCPU::Opcode::OR}, - {"halt", HyperCPU::Opcode::HALT}, - {"loivt", HyperCPU::Opcode::LOIVT}, - {"intr", HyperCPU::Opcode::INTR}, - {"ret", HyperCPU::Opcode::RET}, - {"iret", HyperCPU::Opcode::IRET}, - {"mov", HyperCPU::Opcode::MOV}, - {"read", HyperCPU::Opcode::READ}, - {"write", HyperCPU::Opcode::WRITE}, - {"jmp", HyperCPU::Opcode::JMP}, - {"push", HyperCPU::Opcode::PUSH}, - {"pop", HyperCPU::Opcode::POP}, - {"calle", HyperCPU::Opcode::CALLE}, - {"callgr", HyperCPU::Opcode::CALLGR}, - {"calll", HyperCPU::Opcode::CALLL}, - {"jme", HyperCPU::Opcode::JME}, - {"jmgr", HyperCPU::Opcode::JMGR}, - {"jml", HyperCPU::Opcode::JML}, - {"cmp", HyperCPU::Opcode::CMP}}); +constexpr inline const auto opcode_assoc = mapbox::eternal::hash_map( + { + {"adc", HyperCPU::Opcode::ADC}, + {"add", HyperCPU::Opcode::ADD}, + {"and", HyperCPU::Opcode::AND}, + {"andn", HyperCPU::Opcode::ANDN}, + {"bswap", HyperCPU::Opcode::BSWAP}, + {"call", HyperCPU::Opcode::CALL}, + {"ccrf", HyperCPU::Opcode::CCRF}, + {"covf", HyperCPU::Opcode::COVF}, + {"cudf", HyperCPU::Opcode::CUDF}, + {"hid", HyperCPU::Opcode::HID}, + {"inc", HyperCPU::Opcode::INC}, + {"dec", HyperCPU::Opcode::DEC}, + {"div", HyperCPU::Opcode::DIV}, + {"mul", HyperCPU::Opcode::MUL}, + {"sub", HyperCPU::Opcode::SUB}, + {"shfr", HyperCPU::Opcode::SHFR}, + {"shfl", HyperCPU::Opcode::SHFL}, + {"or", HyperCPU::Opcode::OR}, + {"halt", HyperCPU::Opcode::HALT}, + {"loivt", HyperCPU::Opcode::LOIVT}, + {"intr", HyperCPU::Opcode::INTR}, + {"ret", HyperCPU::Opcode::RET}, + {"iret", HyperCPU::Opcode::IRET}, + {"mov", HyperCPU::Opcode::MOV}, + {"read", HyperCPU::Opcode::READ}, + {"write", HyperCPU::Opcode::WRITE}, + {"jmp", HyperCPU::Opcode::JMP}, + {"push", HyperCPU::Opcode::PUSH}, + {"pop", HyperCPU::Opcode::POP}, + {"calle", HyperCPU::Opcode::CALLE}, + {"callgr", HyperCPU::Opcode::CALLGR}, + {"calll", HyperCPU::Opcode::CALLL}, + {"jme", HyperCPU::Opcode::JME}, + {"jmgr", HyperCPU::Opcode::JMGR}, + {"jml", HyperCPU::Opcode::JML}, + {"cmp", HyperCPU::Opcode::CMP} + } +); diff --git a/src/Assembler/Core/RegNameAssoc.hpp b/src/Assembler/Core/RegNameAssoc.hpp index 375d68d2..03e98910 100644 --- a/src/Assembler/Core/RegNameAssoc.hpp +++ b/src/Assembler/Core/RegNameAssoc.hpp @@ -1,48 +1,53 @@ #pragma once +#include #include #include "Common/LanguageSpec/Registers.hpp" #include "PCH/CStd.hpp" -constexpr inline const auto registers_assoc = mapbox::eternal::hash_map({{"x0", HyperCPU::Registers::X0}, - {"x1", HyperCPU::Registers::X1}, - {"x2", HyperCPU::Registers::X2}, - {"x3", HyperCPU::Registers::X3}, - {"x4", HyperCPU::Registers::X4}, - {"x5", HyperCPU::Registers::X5}, - {"x6", HyperCPU::Registers::X6}, - {"x7", HyperCPU::Registers::X7}, - {"xh0", HyperCPU::Registers::XH0}, - {"xh1", HyperCPU::Registers::XH1}, - {"xh2", HyperCPU::Registers::XH2}, - {"xh3", HyperCPU::Registers::XH3}, - {"xh4", HyperCPU::Registers::XH4}, - {"xh5", HyperCPU::Registers::XH5}, - {"xh6", HyperCPU::Registers::XH6}, - {"xh7", HyperCPU::Registers::XH7}, - {"xl0", HyperCPU::Registers::XL0}, - {"xl1", HyperCPU::Registers::XL1}, - {"xl2", HyperCPU::Registers::XL2}, - {"xl3", HyperCPU::Registers::XL3}, - {"xl4", HyperCPU::Registers::XL4}, - {"xl5", HyperCPU::Registers::XL5}, - {"xl6", HyperCPU::Registers::XL6}, - {"xl7", HyperCPU::Registers::XL7}, - {"xll0", HyperCPU::Registers::XLL0}, - {"xll1", HyperCPU::Registers::XLL1}, - {"xll2", HyperCPU::Registers::XLL2}, - {"xll3", HyperCPU::Registers::XLL3}, - {"xllh0", HyperCPU::Registers::XLLH0}, - {"xllh1", HyperCPU::Registers::XLLH1}, - {"xllh2", HyperCPU::Registers::XLLH2}, - {"xllh3", HyperCPU::Registers::XLLH3}, - {"xlll0", HyperCPU::Registers::XLLL0}, - {"xlll1", HyperCPU::Registers::XLLL1}, - {"xlll2", HyperCPU::Registers::XLLL2}, - {"xlll3", HyperCPU::Registers::XLLL3}, - {"xbp", HyperCPU::Registers::XBP}, - {"xsp", HyperCPU::Registers::XSP}, - {"xip", HyperCPU::Registers::XIP}, - {"xgdp", HyperCPU::Registers::XGDP}, - {"xivt", HyperCPU::Registers::XIVT}}); +constexpr inline const auto registers_assoc = mapbox::eternal::hash_map( + { + {"x0", HyperCPU::Reg::X0}, + {"x1", HyperCPU::Reg::X1}, + {"x2", HyperCPU::Reg::X2}, + {"x3", HyperCPU::Reg::X3}, + {"x4", HyperCPU::Reg::X4}, + {"x5", HyperCPU::Reg::X5}, + {"x6", HyperCPU::Reg::X6}, + {"x7", HyperCPU::Reg::X7}, + {"xh0", HyperCPU::Reg::XH0}, + {"xh1", HyperCPU::Reg::XH1}, + {"xh2", HyperCPU::Reg::XH2}, + {"xh3", HyperCPU::Reg::XH3}, + {"xh4", HyperCPU::Reg::XH4}, + {"xh5", HyperCPU::Reg::XH5}, + {"xh6", HyperCPU::Reg::XH6}, + {"xh7", HyperCPU::Reg::XH7}, + {"xl0", HyperCPU::Reg::XL0}, + {"xl1", HyperCPU::Reg::XL1}, + {"xl2", HyperCPU::Reg::XL2}, + {"xl3", HyperCPU::Reg::XL3}, + {"xl4", HyperCPU::Reg::XL4}, + {"xl5", HyperCPU::Reg::XL5}, + {"xl6", HyperCPU::Reg::XL6}, + {"xl7", HyperCPU::Reg::XL7}, + {"xll0", HyperCPU::Reg::XLL0}, + {"xll1", HyperCPU::Reg::XLL1}, + {"xll2", HyperCPU::Reg::XLL2}, + {"xll3", HyperCPU::Reg::XLL3}, + {"xllh0", HyperCPU::Reg::XLLH0}, + {"xllh1", HyperCPU::Reg::XLLH1}, + {"xllh2", HyperCPU::Reg::XLLH2}, + {"xllh3", HyperCPU::Reg::XLLH3}, + {"xlll0", HyperCPU::Reg::XLLL0}, + {"xlll1", HyperCPU::Reg::XLLL1}, + {"xlll2", HyperCPU::Reg::XLLL2}, + {"xlll3", HyperCPU::Reg::XLLL3}, + {"xbp", HyperCPU::Reg::XBP}, + {"xsp", HyperCPU::Reg::XSP}, + {"xip", HyperCPU::Reg::XIP}, + {"xgdp", HyperCPU::Reg::XGDP}, + {"xivt", HyperCPU::Reg::XIVT} + } +); diff --git a/src/Assembler/Main/Main.cpp b/src/Assembler/Main/Main.cpp index ef7e03c8..ecc84e4f 100644 --- a/src/Assembler/Main/Main.cpp +++ b/src/Assembler/Main/Main.cpp @@ -1,8 +1,8 @@ +#include #include #include #include "Assembler/Core/Compiler.hpp" -#include "Assembler/Utils/Extension.hpp" #include "Common/NotImplemented.hpp" #include "PCH/CStd.hpp" #include "Pog/Pog.hpp" @@ -11,12 +11,13 @@ #include "BacktraceProvider/BacktraceProvider.hpp" #endif -constexpr const inline auto loglevel_assoc = mapbox::eternal::map({ - {"debug", HyperCPU::LogLevel::DEBUG}, - {"info", HyperCPU::LogLevel::INFO}, - {"warning", HyperCPU::LogLevel::WARNING}, - {"error", HyperCPU::LogLevel::ERROR}, -}); +std::string CreateObjectFilename(std::string str) { + std::size_t lastDotPos = str.rfind('.'); + if (lastDotPos != std::string::npos) { + str.replace(lastDotPos + 1, str.length() - lastDotPos - 1, "o"); + } + return str; +} int main(int argc, char** argv) { #ifdef HCPU_ENABLE_LIBUNWIND @@ -43,7 +44,7 @@ int main(int argc, char** argv) { program.parse_args(argc, argv); } catch (const std::exception& err) { std::cerr << err.what() << '\n'; - EXIT(1); + return 1; } auto source = program.get("source"); @@ -51,7 +52,7 @@ int main(int argc, char** argv) { if (program.present("-o")) { result = program.get("-o"); } else { - result = HCAsm::CreateObjectFilename(source); + result = CreateObjectFilename(source); if (result == source) { result += ".o"; } @@ -61,22 +62,22 @@ int main(int argc, char** argv) { HyperCPU::PrintUnsupported("Compilation to object files is not implemented!"); } - HCAsm::HCAsmCompiler compiler{loglevel_assoc.at(program.get("-v").c_str())}; + HCAsm::HCAsmCompiler compiler; // Verify that files are available if (!std::filesystem::is_regular_file(source)) { - HCAsm::logger.Log(HyperCPU::LogLevel::ERROR, "Source file \"{}\" is not a regular file!", source); - EXIT(1); + spdlog::error("Source file \"{}\" is not a regular file!", source); + return 1; } std::ifstream src(source); std::ofstream dst(result, std::ios::binary | std::ios::ate); if (!src.is_open()) { - HCAsm::logger.Log(HyperCPU::LogLevel::ERROR, "Failed to open source file!"); - EXIT(1); + spdlog::error("Failed to open source file!"); + return 1; } - HCAsm::logger.Log(HyperCPU::LogLevel::DEBUG, "Source and destination files handles acquired"); + spdlog::error("Source and destination files handles acquired"); HyperCPU::GenericHeader hdr; src.read(reinterpret_cast(&hdr), sizeof(hdr)); if (hdr.magic == HyperCPU::magic) { @@ -87,7 +88,8 @@ int main(int argc, char** argv) { std::string contents( (std::istreambuf_iterator(src)), - std::istreambuf_iterator()); + std::istreambuf_iterator() + ); std::uint32_t code_size; @@ -95,11 +97,3 @@ int main(int argc, char** argv) { HCAsm::WriteResultFile(HyperCPU::FileType::Binary, binary, dst, code_size, binary.entry_point); } - -std::string HCAsm::CreateObjectFilename(std::string str) { - std::size_t lastDotPos = str.rfind('.'); - if (lastDotPos != std::string::npos) { - str.replace(lastDotPos + 1, str.length() - lastDotPos - 1, "o"); - } - return str; -} diff --git a/src/Assembler/Utils/Extension.hpp b/src/Assembler/Utils/Extension.hpp deleted file mode 100644 index 6494d7ce..00000000 --- a/src/Assembler/Utils/Extension.hpp +++ /dev/null @@ -1,7 +0,0 @@ -#pragma once - -#include "PCH/CStd.hpp" - -namespace HCAsm { - std::string CreateObjectFilename(std::string str); -} diff --git a/src/Common/NotImplemented.hpp b/src/Common/NotImplemented.hpp index 08f078af..3f509ee5 100644 --- a/src/Common/NotImplemented.hpp +++ b/src/Common/NotImplemented.hpp @@ -4,7 +4,7 @@ #include "PCH/CStd.hpp" namespace HyperCPU { - HCPU_ALWAYS_INLINE static void PrintUnsupported(std::string_view msg) { - // ... + HCPU_ALWAYS_INLINE static void PrintUnsupported(std::string_view /* msg */) { + std::abort(); } } // namespace HyperCPU diff --git a/src/Version.hpp b/src/Common/Version.hpp similarity index 100% rename from src/Version.hpp rename to src/Common/Version.hpp diff --git a/src/Emulator/BUILD.bazel b/src/Emulator/BUILD.bazel index 6ac7773a..a3d64af0 100644 --- a/src/Emulator/BUILD.bazel +++ b/src/Emulator/BUILD.bazel @@ -1,25 +1,23 @@ load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') -# cc_library( -# name = 'emulator_core', -# srcs = glob(['**/*.cpp']), -# hdrs = glob(['**/*.hpp']), -# deps = [ -# '@fmt//:fmt', -# '@argparse//:argparse', -# '@eternal//:eternal', -# '//src/Assembler:assembler_core', -# '//src/PCH:pch_cstd', -# '//src/Pog:pog' -# ] -# ) +cc_library( + name = 'emulator_core', + srcs = glob(['**/*.cpp']), + hdrs = glob(['**/*.hpp']), + deps = [ + '@fmt//:fmt', + '@argparse//:argparse', + '@eternal//:eternal', + '//src/Assembler:assembler_core', + '//src/PCH:pch_cstd', + '//src/Pog:pog' + ] +) -# cc_binary( -# name = 'hcemul', -# srcs = glob(['**/*.cpp']), -# deps = [ -# ':emulator_core', -# '//src/PCH:pch_cstd', -# '//src/Pog:pog' -# ] -# ) +cc_binary( + name = 'hcemul', + srcs = glob(['**/*.cpp']), + deps = [ + ':emulator_core' + ] +) diff --git a/src/Emulator/Core/CPU/ALU.hpp b/src/Emulator/Core/CPU/ALU.hpp index 29efea2d..029b9a02 100644 --- a/src/Emulator/Core/CPU/ALU.hpp +++ b/src/Emulator/Core/CPU/ALU.hpp @@ -1,6 +1,6 @@ #pragma once -#include "pch.hpp" +#include "PCH/CStd.hpp" #define _MICROOP [[gnu::always_inline]] static constexpr inline diff --git a/src/Emulator/Core/CPU/Assert.hpp b/src/Emulator/Core/CPU/Assert.hpp index 388491bf..65e77103 100644 --- a/src/Emulator/Core/CPU/Assert.hpp +++ b/src/Emulator/Core/CPU/Assert.hpp @@ -1,6 +1,6 @@ #pragma once -#include "pch.hpp" +#include "PCH/CStd.hpp" #define h_assert(expr, statement) \ if (!(expr)) { \ diff --git a/src/Emulator/Core/CPU/CPU.cpp b/src/Emulator/Core/CPU/CPU.cpp index d365ce9d..49d20f03 100644 --- a/src/Emulator/Core/CPU/CPU.cpp +++ b/src/Emulator/Core/CPU/CPU.cpp @@ -1,14 +1,13 @@ -#include "pch.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" +#include "PCH/CStd.hpp" -#include -#include -#include -#include -#include +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" +#include "Emulator/Core/MemoryController/MemoryControllerST.hpp" HyperCPU::CPU::CPU(std::uint16_t core_count, std::uint64_t mem_size, char* binary, std::uint64_t binary_size) : mem_controller(dynamic_cast(new MemoryControllerST(mem_size, this))), - logger(LogLevel::ERROR), core_count(core_count), total_mem(mem_size), halted(false), @@ -256,9 +255,9 @@ void HyperCPU::CPU::Run() { buffer = m_decoder->FetchAndDecode(); switch (buffer.m_opcode) { - case _CONT: + case HyperCPU::Opcode::_CONT: continue; - case IRET: + case HyperCPU::Opcode::IRET: *xip = StackPop64(); continue; default: @@ -277,7 +276,3 @@ bool HyperCPU::CPU::CanExecuteInterrupts() { void HyperCPU::CPU::SetEntryPoint(std::uint32_t entry_point) { *xip = entry_point; } - -const HyperCPU::Logger& HyperCPU::CPU::GetLogger() const noexcept { - return logger; -} diff --git a/src/Emulator/Core/CPU/CPU.hpp b/src/Emulator/Core/CPU/CPU.hpp index b5998dee..686cd5db 100644 --- a/src/Emulator/Core/CPU/CPU.hpp +++ b/src/Emulator/Core/CPU/CPU.hpp @@ -1,13 +1,12 @@ #pragma once -#include "pch.hpp" +#include "PCH/CStd.hpp" -#include -#include -#include -#include -#include -#include +#include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" +#include "Emulator/Core/CPU/IO/Simple.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp" +#include "Emulator/Core/MemoryController/IMemoryController.hpp" #define DECLARE_INSTR(name) void Exec##name(const IInstruction& instr, OperandContainer op1, OperandContainer op2) @@ -28,7 +27,6 @@ namespace HyperCPU { std::unique_ptr m_decoder; // Data - const HyperCPU::Logger logger; std::uint16_t core_count; std::uint64_t total_mem; bool halted; @@ -126,7 +124,6 @@ namespace HyperCPU { bool CanExecuteInterrupts(); void SetEntryPoint(std::uint32_t entry_point); - const HyperCPU::Logger& GetLogger() const noexcept; ~CPU(); }; diff --git a/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp b/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp index 8e447554..9d0610c3 100644 --- a/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp +++ b/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp @@ -1,24 +1,23 @@ -#include "pch.hpp" +#include "PCH/CStd.hpp" -#include -#include -#include -#include -#include -#include -#include -#include +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" +#include "Common/LanguageSpec/AllowedFlags.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "Common/LanguageSpec/Registers.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" +// TODO: лишать кошка жена за такое #define dcdr_assert(expr) \ RaiseException((expr)); \ if (cpu && cpu->pending_interrupt.has_value()) \ - return {.m_opcode = _CONT, .m_opcode_mode = b64, .m_op_types = NONE, .m_op1 = {}, .m_op2 = {}, .addr_extension_status = HyperCPU::AddrExtensionStatus::Disabled, .extension = 0} + return {.m_opcode = Opcode::_CONT, .m_opcode_mode = Mode::b64, .m_op_types = OperandTypes::NONE, .m_op1 = {}, .m_op2 = {}, .addr_extension_status = HyperCPU::AddrExtensionStatus::Disabled, .extension = 0} void HyperCPU::Decoder::RaiseException(bool expr) noexcept { if (!(expr)) { if (cpu == nullptr) { std::cerr << "Invalid opcode!\n"; - EXIT(1); + std::exit(1); } else { cpu->TriggerInterrupt(HyperCPU::cpu_exceptions::IO); } @@ -27,16 +26,16 @@ void HyperCPU::Decoder::RaiseException(bool expr) noexcept { bool HyperCPU::Decoder::CheckSupportedOperandSize(std::uint8_t byte, Mode mode) const noexcept { switch (mode) { - case b8: + case Mode::b8: return byte & 0b11000000; - case b16: + case Mode::b16: return byte & 0b00110000; - case b32: + case Mode::b32: return byte & 0b00001100; - case b64: + case Mode::b64: return byte & 0b00000011; default: - UNREACHABLE(); + std::abort(); } } @@ -57,7 +56,7 @@ HyperCPU::IInstruction HyperCPU::Decoder::FetchAndDecode() { instruction.m_opcode = static_cast(opcode); switch (instruction.m_opcode) { - case IRET: + case Opcode::IRET: return instruction; default: break; @@ -67,7 +66,7 @@ HyperCPU::IInstruction HyperCPU::Decoder::FetchAndDecode() { flags = mem_controller->Fetch8(*xip); instruction.m_opcode_mode = static_cast((flags & 0b00110000) >> 4); - dcdr_assert((flags & 0b00001111) <= MAX_OPERAND_TYPE); + dcdr_assert((flags & 0b00001111) <= static_cast(OperandTypes::NONE)); instruction.m_op_types = static_cast(flags & 0b00001111); instruction.addr_extension_status = static_cast((flags & 0b11000000) >> 6); @@ -76,15 +75,15 @@ HyperCPU::IInstruction HyperCPU::Decoder::FetchAndDecode() { } // Check if op Mode is valid for this opcode - dcdr_assert(allowed_op_modes[opcode][static_cast(instruction.m_op_types)]); - dcdr_assert((allowed_op_modes[opcode][static_cast(instruction.m_op_types)] == SUPPORT_ALL) || - CheckSupportedOperandSize(allowed_op_modes[opcode][static_cast(instruction.m_op_types)], + dcdr_assert(AllowedOpModes[opcode][static_cast(instruction.m_op_types)]); + dcdr_assert((AllowedOpModes[opcode][static_cast(instruction.m_op_types)] == SUPPORT_ALL) || + CheckSupportedOperandSize(AllowedOpModes[opcode][static_cast(instruction.m_op_types)], instruction.m_opcode_mode)); switch (instruction.m_op_types) { - case R_R: - case RM_R: - case R_RM: { + case OperandTypes::R_R: + case OperandTypes::RM_R: + case OperandTypes::R_RM: { std::uint8_t tmp = mem_controller->Fetch8(*xip); dcdr_assert(Validator::IsValidRegister(tmp)); instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(tmp)); @@ -95,8 +94,8 @@ HyperCPU::IInstruction HyperCPU::Decoder::FetchAndDecode() { break; } - case RM_M: - case R_M: { + case OperandTypes::RM_M: + case OperandTypes::R_M: { std::uint8_t tmp = mem_controller->Fetch8(*xip); dcdr_assert(Validator::IsValidRegister(tmp)); instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(tmp)); @@ -105,32 +104,32 @@ HyperCPU::IInstruction HyperCPU::Decoder::FetchAndDecode() { break; } - case RM_IMM: - case R_IMM: { + case OperandTypes::RM_IMM: + case OperandTypes::R_IMM: { std::uint8_t tmp = mem_controller->Fetch8(*xip); dcdr_assert(Validator::IsValidRegister(tmp)); instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(tmp)); switch (instruction.m_opcode_mode) { - case b8: { + case Mode::b8: { std::uint8_t vtmp = mem_controller->Fetch8(*xip); instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(vtmp)); break; } - case b16: { + case Mode::b16: { std::uint16_t vtmp = mem_controller->Fetch16(*xip); instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(vtmp)); break; } - case b32: { + case Mode::b32: { std::uint32_t vtmp = mem_controller->Fetch32(*xip); instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(vtmp)); break; } - case b64: { + case Mode::b64: { instruction.m_op2 = OperandContainer{mem_controller->Fetch64(*xip)}; break; } @@ -138,7 +137,7 @@ HyperCPU::IInstruction HyperCPU::Decoder::FetchAndDecode() { break; } - case M_R: { + case OperandTypes::M_R: { instruction.m_op1 = OperandContainer{mem_controller->Fetch64(*xip)}; std::uint8_t tmp = mem_controller->Fetch8(*xip); @@ -147,45 +146,45 @@ HyperCPU::IInstruction HyperCPU::Decoder::FetchAndDecode() { break; } - case R: { + case OperandTypes::R: { std::uint8_t tmp = mem_controller->Fetch8(*xip); dcdr_assert(Validator::IsValidRegister(tmp)); instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(tmp)); break; } - case M: + case OperandTypes::M: instruction.m_op1 = OperandContainer{mem_controller->Fetch64(*xip)}; break; - case IMM: + case OperandTypes::IMM: switch (instruction.m_opcode_mode) { - case b8: { + case Mode::b8: { std::uint8_t vtmp = mem_controller->Fetch8(*xip); instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(vtmp)); break; } - case b16: { + case Mode::b16: { std::uint16_t vtmp = mem_controller->Fetch16(*xip); instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(vtmp)); break; } - case b32: { + case Mode::b32: { std::uint32_t vtmp = mem_controller->Fetch32(*xip); instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(vtmp)); break; } - case b64: { + case Mode::b64: { instruction.m_op1 = OperandContainer{mem_controller->Fetch64(*xip)}; break; } } break; - case NONE: + case OperandTypes::NONE: break; } diff --git a/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp b/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp index ece30b4d..b29471e4 100644 --- a/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp +++ b/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp @@ -1,13 +1,12 @@ #pragma once -#include "pch.hpp" +#include "PCH/CStd.hpp" -#include -#include -#include -#include -#include -#include +#include "Emulator/Core/CPU/Decoders/IDecoder.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" +#include "Emulator/Core/MemoryController/IMemoryController.hpp" +#include "Emulator/Misc/bit_cast.hpp" namespace HyperCPU { enum class AddrExtensionStatus { @@ -104,6 +103,3 @@ namespace HyperCPU { ~Decoder() = default; }; }; -} -; -} diff --git a/src/Emulator/Core/CPU/IO/Simple.cpp b/src/Emulator/Core/CPU/IO/Simple.cpp index 5bd83fdc..01af7a4e 100644 --- a/src/Emulator/Core/CPU/IO/Simple.cpp +++ b/src/Emulator/Core/CPU/IO/Simple.cpp @@ -1,10 +1,10 @@ -#include "pch.hpp" +#include "PCH/CStd.hpp" #include #include -#include -#include +#include "Emulator/Core/CPU/IO/Simple.hpp" +#include "Emulator/Misc/bit_cast.hpp" HyperCPU::SimpleIOImpl::SimpleIOImpl() : state(CurrentState::Default), was_printing(true), printing(true) { diff --git a/src/Emulator/Core/CPU/IO/Simple.hpp b/src/Emulator/Core/CPU/IO/Simple.hpp index b99755f9..74ddf25e 100644 --- a/src/Emulator/Core/CPU/IO/Simple.hpp +++ b/src/Emulator/Core/CPU/IO/Simple.hpp @@ -1,4 +1,4 @@ -#include "pch.hpp" +#include "PCH/CStd.hpp" #include diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp index 50a97f49..02c2a506 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp @@ -1,176 +1,158 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/ALU.hpp" -#include -#include - -#include -#include +#include "Emulator/Misc/bit_cast.hpp" +#include "Emulator/Misc/overflow.hpp" using namespace HyperALU; void HyperCPU::CPU::ExecADC(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - if (crf) - ++op1.deref(); - break; - - case b16: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - if (crf) - ++op1.deref(); - break; - - case b32: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - if (crf) - ++op1.deref(); - break; - - case b64: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - if (crf) - ++op1.deref(); - break; - } - break; - } - - case R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) - ++op1.deref(); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) - ++op1.deref(); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) - ++op1.deref(); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) - ++op1.deref(); - break; - } - } - break; - } - - case R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) - ++op1.deref(); + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + if (crf) ++op1.deref(); + break; + + case Mode::b16: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + if (crf) ++op1.deref(); + break; + + case Mode::b32: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + if (crf) ++op1.deref(); + break; + + case Mode::b64: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + if (crf) ++op1.deref(); + break; + } + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) ++op1.deref(); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) ++op1.deref(); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) ++op1.deref(); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) ++op1.deref(); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) ++op1.deref(); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) ++op1.deref(); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) ++op1.deref(); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) ++op1.deref(); + break; + } + } + break; + } + + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) ++op1.deref(); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) ++op1.deref(); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) ++op1.deref(); + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) ++op1.deref(); + break; + } + } + break; + } + + default: break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) - ++op1.deref(); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) - ++op1.deref(); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) - ++op1.deref(); - break; - } - } - break; - } - - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) - ++op1.deref(); - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) - ++op1.deref(); - break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) - ++op1.deref(); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) - ++op1.deref(); - break; - } - } - break; - } - - default: - break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp index c8311b5b..3129df45 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp @@ -1,142 +1,141 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/ALU.hpp" -#include -#include +#include "Emulator/Misc/bit_cast.hpp" +#include "Emulator/Misc/overflow.hpp" -#include -#include void HyperCPU::CPU::ExecADD(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b16: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b32: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b64: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + } + break; + } + + default: break; - - case b16: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b32: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b64: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - break; - } - - case R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - } - break; - } - - case R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - } - break; - } - - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - } - break; - } - - default: - break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp b/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp index 4b4fbd00..3db8b343 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp @@ -1,127 +1,125 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/ALU.hpp" -#include -#include - -#include +#include "Emulator/Misc/bit_cast.hpp" using namespace HyperALU; void HyperCPU::CPU::ExecAND(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b16: - op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b32: - op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b64: - op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - break; - } - - case R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - } - break; - } - - case R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - } - break; - } - - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_and(op1.deref(), val); + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b16: + op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b32: + op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b64: + op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + } break; - } + } - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_and(op1.deref(), val); + default: break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - } - break; - } - - default: - break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp index 705949ed..69f63199 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp @@ -1,147 +1,145 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/ALU.hpp" -#include -#include - -#include +#include "Emulator/Misc/bit_cast.hpp" using namespace HyperALU; void HyperCPU::CPU::ExecANDN(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: { - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - - case b16: { - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - - case b32: { - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - - case b64: { - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - } - break; - } - - case R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - } - break; - } - - case R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + + case Mode::b16: { + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + + case Mode::b32: { + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + + case Mode::b64: { + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + } + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + } + break; + } + + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + } + break; + } + + default: break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - } - break; - } - - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - } - break; - } - - default: - break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp index 340a5ac2..1154f332 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp @@ -1,35 +1,29 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include +#include "Emulator/Misc/byteswap.hpp" -#include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecBSWAP(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecBSWAP(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_opcode_mode) { - case b8: - break; - - case b16: { - auto& dst = op1.deref(); - dst = HyperCPU::byteswap(dst); - break; - } - - case b32: { - auto& dst = op1.deref(); - dst = HyperCPU::byteswap(dst); - break; - } - - case b64: { - auto& dst = op1.deref(); - dst = HyperCPU::byteswap(dst); - break; - } + case Mode::b8: + break; + + case Mode::b16: { + auto& dst = op1.deref(); + dst = HyperCPU::byteswap(dst); + break; + } + + case Mode::b32: { + auto& dst = op1.deref(); + dst = HyperCPU::byteswap(dst); + break; + } + + case Mode::b64: { + auto& dst = op1.deref(); + dst = HyperCPU::byteswap(dst); + break; + } } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp index 1be42d21..6ed64033 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp @@ -1,29 +1,20 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include +#include "Emulator/Misc/bit_cast.hpp" -#include -#include -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecCALL(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecCALL(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_op_types) { // Placeholders - case R: - StackPush64(*xip); - *xip = op1.deref(); - break; - case IMM: - StackPush64(*xip); - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecCALL placeholder reached: please report bug\n"; exit(1); }); - break; + case OperandTypes::R: + StackPush64(*xip); + *xip = op1.deref(); + break; + case OperandTypes::IMM: + StackPush64(*xip); + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp index a2cf7f3c..ff94c2d9 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp @@ -1,33 +1,23 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Misc/bit_cast.hpp" -#include -#include -#include - -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecCALLE(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecCALLE(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(zrf && !crf)) { return; } switch (instr.m_op_types) { // Placeholders - case R: - StackPush64(*xip); - *xip = op1.deref(); - break; - case IMM: - StackPush64(*xip); - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; exit(1); }); - break; + case OperandTypes::R: + StackPush64(*xip); + *xip = op1.deref(); + break; + case OperandTypes::IMM: + StackPush64(*xip); + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp index e7998716..6d22d67b 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp @@ -1,33 +1,24 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include +#include "Emulator/Misc/bit_cast.hpp" -#include -#include -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecCALLGR(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecCALLGR(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(!zrf && !crf)) { return; } switch (instr.m_op_types) { // Placeholders - case R: - StackPush64(*xip); - *xip = op1.deref(); - break; - case IMM: - StackPush64(*xip); - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecCALLGR placeholder reached: please report bug\n"; exit(1); }); - break; + case OperandTypes::R: + StackPush64(*xip); + *xip = op1.deref(); + break; + case OperandTypes::IMM: + StackPush64(*xip); + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp index 4dac39f6..40832135 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp @@ -1,33 +1,24 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include +#include "Emulator/Misc/bit_cast.hpp" -#include -#include -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecCALLL(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecCALLL(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(!zrf && crf)) { return; } switch (instr.m_op_types) { // Placeholders - case R: - StackPush64(*xip); - *xip = op1.deref(); - break; - case IMM: - StackPush64(*xip); - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecCALLL placeholder reached: please report bug\n"; exit(1); }); - break; + case OperandTypes::R: + StackPush64(*xip); + *xip = op1.deref(); + break; + case OperandTypes::IMM: + StackPush64(*xip); + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp index c75aebf0..3c091087 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp @@ -1,12 +1,5 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecCCRF(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecCCRF(const IInstruction& /* instr8 */, OperandContainer /* op1 */, OperandContainer /* op2 */) { crf = false; } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp index f9608757..910f2b77 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp @@ -1,220 +1,211 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/ALU.hpp" -#include -#include +#include "Emulator/Misc/bit_cast.hpp" -#include void HyperCPU::CPU::ExecCMP(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { std::int8_t res = 0; switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); - break; + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b16: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b32: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b64: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); + case Mode::b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); + break; + } break; } - break; - } - case R_RM: { - std::uint64_t ptr; - std::memcpy(&ptr, op2.ptr(), 8); + case OperandTypes::R_RM: { + std::uint64_t ptr; + std::memcpy(&ptr, op2.ptr(), 8); - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read8(ptr)); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read8(ptr)); + break; - case b16: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); + break; - case b32: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); + break; - case b64: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); + case Mode::b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); + break; + } break; } - break; - } - case R_M: { - std::uint64_t ptr = op2; + case OperandTypes::R_M: { + std::uint64_t ptr = op2; - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read8(ptr)); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read8(ptr)); + break; - case b16: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); + break; - case b32: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); + break; - case b64: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); + case Mode::b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); + break; + } break; } - break; - } - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); - break; + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); + break; - case b16: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); + break; - case b32: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); + break; - case b64: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); + case Mode::b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); + break; + } break; } - break; - } - case RM_M: { - std::uint64_t ptr1, ptr2 = 0; - std::memcpy(&ptr1, op1.ptr(), 8); - ptr2 = HyperCPU::bit_cast(op2); + case OperandTypes::RM_M: { + std::uint64_t ptr1, ptr2 = 0; + std::memcpy(&ptr1, op1.ptr(), 8); + ptr2 = HyperCPU::bit_cast(op2); - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr1), mem_controller->Read8(ptr2)); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr1), mem_controller->Read8(ptr2)); + break; - case b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr1), mem_controller->Read16(ptr2)); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr1), mem_controller->Read16(ptr2)); + break; - case b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr1), mem_controller->Read32(ptr2)); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr1), mem_controller->Read32(ptr2)); + break; - case b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr1), mem_controller->Read64(ptr2)); + case Mode::b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr1), mem_controller->Read64(ptr2)); + break; + } break; } - break; - } - case RM_R: { - std::uint64_t ptr = op1.deref(); + case OperandTypes::RM_R: { + std::uint64_t ptr = op1.deref(); - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); + case Mode::b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; + } break; } - break; - } - case RM_IMM: { - std::uint64_t ptr = op1.deref(); + case OperandTypes::RM_IMM: { + std::uint64_t ptr = op1.deref(); - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast(op2)); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast(op2)); + break; - case b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast(op2)); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast(op2)); + break; - case b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast(op2)); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast(op2)); + break; - case b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast(op2)); + case Mode::b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast(op2)); + break; + } break; } - break; - } - case M_R: { - std::size_t ptr = HyperCPU::bit_cast(op1); + case OperandTypes::M_R: { + std::size_t ptr = HyperCPU::bit_cast(op1); - switch (instr.m_opcode_mode) { - case b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); + case Mode::b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; + } break; } - break; - } - default: - break; + default: + break; } switch (res) { - case -1: - zrf = 0; - crf = 1; - break; - case 0: - zrf = 1; - crf = 0; - break; - case 1: - zrf = 0; - crf = 0; - break; + case -1: + zrf = 0; + crf = 1; + break; + case 0: + zrf = 1; + crf = 0; + break; + case 1: + zrf = 0; + crf = 0; + break; } } -crf = 0; -break; -case 1: -zrf = 0; -crf = 0; -break; -} -} diff --git a/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp b/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp index 187a8166..37823004 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp @@ -1,12 +1,6 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecCOVF(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecCOVF(const IInstruction& /* instr */, OperandContainer /* op1 */, OperandContainer /* op2 */) { ovf = false; } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp index 5d7f8a6d..6e5fb458 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp @@ -1,12 +1,6 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecCUDF(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecCUDF(const IInstruction& /* instr */, OperandContainer /* op1 */, OperandContainer /* op2 */) { udf = false; } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp b/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp index ca21eca6..a2073511 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp @@ -1,40 +1,34 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecDEC(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecDEC(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_opcode_mode) { - case b8: { - auto& dst = op1.deref(); - udf = (dst == 0); - --dst; - break; - } + case Mode::b8: { + auto& dst = op1.deref(); + udf = (dst == 0); + --dst; + break; + } - case b16: { - auto& dst = op1.deref(); - udf = (dst == 0); - --dst; - break; - } + case Mode::b16: { + auto& dst = op1.deref(); + udf = (dst == 0); + --dst; + break; + } - case b32: { - auto& dst = op1.deref(); - udf = (dst == 0); - --dst; - break; - } + case Mode::b32: { + auto& dst = op1.deref(); + udf = (dst == 0); + --dst; + break; + } - case b64: { - auto& dst = op1.deref(); - udf = (dst == 0); - --dst; - break; - } + case Mode::b64: { + auto& dst = op1.deref(); + udf = (dst == 0); + --dst; + break; + } } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp b/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp index 6fcfa040..d3be8225 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp @@ -1,11 +1,7 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/ALU.hpp" +#include "Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp" -#include -#include -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" using namespace HyperALU; @@ -16,34 +12,32 @@ void HyperCPU::CPU::ExecDIV(const IInstruction& instr, OperandContainer op1, Ope } switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t& dst = op1.deref(); - *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); - dst = __hcpu_div(dst, static_cast(*x2)); - break; - } - - case b16: { - auto& dst = op1.deref(); - *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); - dst = __hcpu_div(dst, static_cast(*x2)); - break; - } - - case b32: { - auto& dst = op1.deref(); - *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); - dst = __hcpu_div(dst, static_cast(*x2)); - break; - } - - case b64: { - auto& dst = op1.deref(); - *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); - dst = __hcpu_div(dst, static_cast(*x2)); - break; - } + case Mode::b8: { + std::uint8_t& dst = op1.deref(); + *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); + dst = __hcpu_div(dst, static_cast(*x2)); + break; + } + + case Mode::b16: { + auto& dst = op1.deref(); + *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); + dst = __hcpu_div(dst, static_cast(*x2)); + break; + } + + case Mode::b32: { + auto& dst = op1.deref(); + *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); + dst = __hcpu_div(dst, static_cast(*x2)); + break; + } + + case Mode::b64: { + auto& dst = op1.deref(); + *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); + dst = __hcpu_div(dst, static_cast(*x2)); + break; + } } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp b/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp index c941ec5e..df8469d9 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp @@ -1,12 +1,6 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecHALT(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecHALT(const IInstruction& /* instr */, OperandContainer /* op1 */, OperandContainer /* op2 */) { halted = true; } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp b/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp index 5badf850..f5a01e88 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp @@ -1,25 +1,19 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/Version.hpp" -#include -#include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecHID(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecHID(const IInstruction& /* instr */, OperandContainer /* op1 */, OperandContainer /* op2 */) { switch (*x0) { - case 0: - *x0 = 2; - break; - case 1: - std::strcpy(std::bit_cast(&data), HID_CPU_NAME); - break; - case 2: - *x0 = 0; - break; - default: - break; + case 0: + *x0 = 2; + break; + case 1: + std::strcpy(std::bit_cast(&data), HID_CPU_NAME); + break; + case 2: + *x0 = 0; + break; + default: + break; } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp b/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp index 01828f0c..387c8995 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp @@ -1,40 +1,34 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecINC(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecINC(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_opcode_mode) { - case b8: { - auto& dst = op1.deref(); - ++dst; - ovf = (dst == 0); - break; - } + case Mode::b8: { + auto& dst = op1.deref(); + ++dst; + ovf = (dst == 0); + break; + } - case b16: { - auto& dst = op1.deref(); - ++dst; - ovf = (dst == 0); - break; - } + case Mode::b16: { + auto& dst = op1.deref(); + ++dst; + ovf = (dst == 0); + break; + } - case b32: { - auto& dst = op1.deref(); - ++dst; - ovf = (dst == 0); - break; - } + case Mode::b32: { + auto& dst = op1.deref(); + ++dst; + ovf = (dst == 0); + break; + } - case b64: { - auto& dst = op1.deref(); - ++dst; - ovf = (dst == 0); - break; - } + case Mode::b64: { + auto& dst = op1.deref(); + ++dst; + ovf = (dst == 0); + break; + } } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp index 83d9c36c..c56c12c7 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp @@ -1,29 +1,18 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp" -#include -#include - -#include #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" -void HyperCPU::CPU::ExecINTR(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecINTR(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { std::uint64_t num = 0; switch (instr.m_opcode_mode) { - case b8: - num = HyperCPU::bit_cast_from(op1.ptr()); - break; - case b16: - num = HyperCPU::bit_cast_from(op1.ptr()); - break; - case b32: - num = HyperCPU::bit_cast_from(op1.ptr()); - break; - case b64: - num = HyperCPU::bit_cast_from(op1.ptr()); - break; + case Mode::b8: num = HyperCPU::bit_cast_from(op1.ptr()); break; + case Mode::b16: num = HyperCPU::bit_cast_from(op1.ptr()); break; + case Mode::b32: num = HyperCPU::bit_cast_from(op1.ptr()); break; + case Mode::b64: num = HyperCPU::bit_cast_from(op1.ptr()); break; } if (num > 255) { @@ -32,5 +21,3 @@ void HyperCPU::CPU::ExecINTR(const IInstruction& instr, OperandContainer op1, Op TriggerInterrupt(static_cast(num)); } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp index ba913d99..2c0ecdc2 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp @@ -1,32 +1,20 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#include -#include - -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecJME(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecJME(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(zrf && !crf)) { return; } switch (instr.m_op_types) { // Placeholders - case R: - *xip = op1.deref(); - break; - case IMM: - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecJMP placeholder reached: please report bug\n"; exit(1); }); - break; + case OperandTypes::R: + *xip = op1.deref(); + break; + case OperandTypes::IMM: + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } - -#pragma GCC diagnostic pop -p diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp index b59bc32e..827a5d50 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp @@ -1,31 +1,20 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#include -#include - -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecJMGR(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecJMGR(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(!zrf && !crf)) { return; } switch (instr.m_op_types) { // Placeholders - case R: - *xip = op1.deref(); - break; - case IMM: - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecJMP placeholder reached: please report bug\n"; exit(1); }); - break; + case OperandTypes::R: + *xip = op1.deref(); + break; + case OperandTypes::IMM: + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp index 0ef0ce20..1ba36db9 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp @@ -1,31 +1,20 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#include -#include - -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecJML(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecJML(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(!zrf && crf)) { return; } switch (instr.m_op_types) { // Placeholders - case R: - *xip = op1.deref(); - break; - case IMM: - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecJMP placeholder reached: please report bug\n"; exit(1); }); - break; + case OperandTypes::R: + *xip = op1.deref(); + break; + case OperandTypes::IMM: + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp index 3e6d8708..36f87bd5 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp @@ -1,27 +1,16 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#include -#include - -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecJMP(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecJMP(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_op_types) { // Placeholders - case R: - *xip = op1.deref(); - break; - case IMM: - *xip = HyperCPU::bit_cast(op1); - break; - default: - h_assert(false, {std::cout << "HyperCPU::CPU::ExecJMP placeholder reached: please report bug\n"; exit(1); }); - break; + case OperandTypes::R: + *xip = op1.deref(); + break; + case OperandTypes::IMM: + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp b/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp index 3a0fe67b..e4083ac6 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp @@ -1,25 +1,15 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#include -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecLOIVT(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecLOIVT(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_op_types) { - case IMM: - *xivt = HyperCPU::bit_cast(op1); - break; - case R: - *xivt = HyperCPU::bit_cast_from(op1.ptr()); - break; - default: - ABORT(); + case OperandTypes::IMM: + *xivt = HyperCPU::bit_cast(op1); + break; + case OperandTypes::R: + *xivt = HyperCPU::bit_cast_from(op1.ptr()); + break; + default: std::abort(); } ivt_initialized = true; } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp b/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp index 32d176e1..bdaeb82c 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp @@ -1,203 +1,200 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include - -#include void HyperCPU::CPU::ExecMOV(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - std::memcpy(op1, op2.ptr(), 1); - break; + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + std::memcpy(op1, op2.ptr(), 1); + break; - case b16: - std::memcpy(op1, op2.ptr(), 2); - break; + case Mode::b16: + std::memcpy(op1, op2.ptr(), 2); + break; - case b32: - std::memcpy(op1, op2.ptr(), 4); - break; + case Mode::b32: + std::memcpy(op1, op2.ptr(), 4); + break; - case b64: - std::memcpy(op1, op2.ptr(), 8); + case Mode::b64: + std::memcpy(op1, op2.ptr(), 8); + break; + } break; } - break; - } - case R_RM: { - std::uint64_t ptr; - std::memcpy(&ptr, op2.ptr(), 8); + case OperandTypes::R_RM: { + std::uint64_t ptr; + std::memcpy(&ptr, op2.ptr(), 8); - switch (instr.m_opcode_mode) { - case b8: - *static_cast(op1) = mem_controller->Read8(ptr); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + *static_cast(op1) = mem_controller->Read8(ptr); + break; - case b16: - *static_cast(op1) = mem_controller->Read16(ptr); - break; + case Mode::b16: + *static_cast(op1) = mem_controller->Read16(ptr); + break; - case b32: - *static_cast(op1) = mem_controller->Read32(ptr); - break; + case Mode::b32: + *static_cast(op1) = mem_controller->Read32(ptr); + break; - case b64: - *static_cast(op1) = mem_controller->Read64(ptr); + case Mode::b64: + *static_cast(op1) = mem_controller->Read64(ptr); + break; + } break; } - break; - } - case R_M: { - std::uint64_t ptr = op2; + case OperandTypes::R_M: { + std::uint64_t ptr = op2; - switch (instr.m_opcode_mode) { - case b8: - *static_cast(op1) = mem_controller->Read8(ptr); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + *static_cast(op1) = mem_controller->Read8(ptr); + break; - case b16: - *static_cast(op1) = mem_controller->Read16(ptr); - break; + case Mode::b16: + *static_cast(op1) = mem_controller->Read16(ptr); + break; - case b32: - *static_cast(op1) = mem_controller->Read32(ptr); - break; + case Mode::b32: + *static_cast(op1) = mem_controller->Read32(ptr); + break; - case b64: - *static_cast(op1) = mem_controller->Read64(ptr); + case Mode::b64: + *static_cast(op1) = mem_controller->Read64(ptr); + break; + } break; } - break; - } - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: - std::memcpy(op1, &op2.ref(), 1); - break; + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: + std::memcpy(op1, &op2.ref(), 1); + break; - case b16: - std::memcpy(op1, &op2.ref(), 2); - break; + case Mode::b16: + std::memcpy(op1, &op2.ref(), 2); + break; - case b32: - std::memcpy(op1, &op2.ref(), 4); - break; + case Mode::b32: + std::memcpy(op1, &op2.ref(), 4); + break; - case b64: - std::memcpy(op1, &op2.ref(), 8); + case Mode::b64: + std::memcpy(op1, &op2.ref(), 8); + break; + } break; } - break; - } - case RM_M: { - std::uint64_t ptr1, ptr2 = 0; - std::memcpy(&ptr1, op1.ptr(), 8); - ptr2 = op2; + case OperandTypes::RM_M: { + std::uint64_t ptr1, ptr2 = 0; + std::memcpy(&ptr1, op1.ptr(), 8); + ptr2 = op2; - switch (instr.m_opcode_mode) { - case b8: - mem_controller->Load8(ptr1, mem_controller->Read8(ptr2)); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + mem_controller->Load8(ptr1, mem_controller->Read8(ptr2)); + break; - case b16: - mem_controller->Load16(ptr1, mem_controller->Read16(ptr2)); - break; + case Mode::b16: + mem_controller->Load16(ptr1, mem_controller->Read16(ptr2)); + break; - case b32: - mem_controller->Load32(ptr1, mem_controller->Read32(ptr2)); - break; + case Mode::b32: + mem_controller->Load32(ptr1, mem_controller->Read32(ptr2)); + break; - case b64: - mem_controller->Load64(ptr1, mem_controller->Read64(ptr2)); + case Mode::b64: + mem_controller->Load64(ptr1, mem_controller->Read64(ptr2)); + break; + } break; } - break; - } - case RM_R: { - std::uint64_t ptr = op1.deref(); + case OperandTypes::RM_R: { + std::uint64_t ptr = op1.deref(); - switch (instr.m_opcode_mode) { - case b8: { - mem_controller->Load8(ptr, *static_cast(op2)); - break; - } + switch (instr.m_opcode_mode) { + case Mode::b8: { + mem_controller->Load8(ptr, *static_cast(op2)); + break; + } - case b16: { - mem_controller->Load16(ptr, *static_cast(op2)); - break; - } + case Mode::b16: { + mem_controller->Load16(ptr, *static_cast(op2)); + break; + } - case b32: { - mem_controller->Load32(ptr, *static_cast(op2)); - break; - } + case Mode::b32: { + mem_controller->Load32(ptr, *static_cast(op2)); + break; + } - case b64: { - mem_controller->Load64(ptr, *static_cast(op2)); + case Mode::b64: { + mem_controller->Load64(ptr, *static_cast(op2)); + break; + } + } break; } - } - break; - } - case RM_IMM: { - std::uint64_t ptr1 = op1.deref(); + case OperandTypes::RM_IMM: { + std::uint64_t ptr1 = op1.deref(); - switch (instr.m_opcode_mode) { - case b8: - mem_controller->Load8(ptr1, HyperCPU::bit_cast(op2)); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + mem_controller->Load8(ptr1, HyperCPU::bit_cast(op2)); + break; - case b16: - mem_controller->Load16(ptr1, HyperCPU::bit_cast(op2)); - break; + case Mode::b16: + mem_controller->Load16(ptr1, HyperCPU::bit_cast(op2)); + break; - case b32: - mem_controller->Load32(ptr1, HyperCPU::bit_cast(op2)); - break; + case Mode::b32: + mem_controller->Load32(ptr1, HyperCPU::bit_cast(op2)); + break; - case b64: - mem_controller->Load64(ptr1, HyperCPU::bit_cast(op2)); + case Mode::b64: + mem_controller->Load64(ptr1, HyperCPU::bit_cast(op2)); + break; + } break; } - break; - } - case M_R: { - std::size_t ptr1 = HyperCPU::bit_cast(op1); + case OperandTypes::M_R: { + std::size_t ptr1 = HyperCPU::bit_cast(op1); - switch (instr.m_opcode_mode) { - case b8: { - mem_controller->Load8(ptr1, HyperCPU::bit_cast_from(op2.ptr())); - break; - } + switch (instr.m_opcode_mode) { + case Mode::b8: { + mem_controller->Load8(ptr1, HyperCPU::bit_cast_from(op2.ptr())); + break; + } - case b16: { - mem_controller->Load16(ptr1, HyperCPU::bit_cast_from(op2.ptr())); - break; - } + case Mode::b16: { + mem_controller->Load16(ptr1, HyperCPU::bit_cast_from(op2.ptr())); + break; + } - case b32: { - mem_controller->Load32(ptr1, HyperCPU::bit_cast_from(op2.ptr())); - break; - } + case Mode::b32: { + mem_controller->Load32(ptr1, HyperCPU::bit_cast_from(op2.ptr())); + break; + } - case b64: { - mem_controller->Load64(ptr1, HyperCPU::bit_cast_from(op2.ptr())); + case Mode::b64: { + mem_controller->Load64(ptr1, HyperCPU::bit_cast_from(op2.ptr())); + break; + } + } break; } - } - break; - } - default: - break; + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp index 1b6e6494..df8997d7 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp @@ -1,146 +1,142 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/ALU.hpp" -#include +#include "Emulator/Misc/overflow.hpp" -#include -#include - -#include -#include using namespace HyperALU; void HyperCPU::CPU::ExecMUL(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - ovf = multiplication_will_overflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b16: - ovf = multiplication_will_overflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b32: - ovf = multiplication_will_overflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b64: - ovf = multiplication_will_overflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - break; - } - - case R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - } - break; - } - - case R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + ovf = multiplication_will_overflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b16: + ovf = multiplication_will_overflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b32: + ovf = multiplication_will_overflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b64: + ovf = multiplication_will_overflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + } + break; + } + + default: break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - } - break; - } - - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - } - break; - } - - default: - break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp index d0b0d6fd..1cdc21bd 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp @@ -1,127 +1,124 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/ALU.hpp" -#include -#include - -#include using namespace HyperALU; void HyperCPU::CPU::ExecOR(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b16: - op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b32: - op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b64: - op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - break; - } - - case R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - } - break; - } - - case R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - } - break; - } - - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_or(op1.deref(), val); + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b16: + op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b32: + op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b64: + op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + } break; - } + } - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_or(op1.deref(), val); + default: break; - } - - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - } - break; - } - - default: - break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp index 948e9871..6bab6b40 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp @@ -1,35 +1,18 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#include -#include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecPOP(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecPOP(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_op_types) { - case R: - switch (instr.m_opcode_mode) { - case HyperCPU::Mode::b8: - op1.deref() = StackPop8(); - break; - case HyperCPU::Mode::b16: - op1.deref() = StackPop16(); - break; - case HyperCPU::Mode::b32: - op1.deref() = StackPop32(); - break; - case HyperCPU::Mode::b64: - op1.deref() = StackPop64(); + case OperandTypes::R: + switch (instr.m_opcode_mode) { + case Mode::b8: op1.deref() = StackPop8(); break; + case Mode::b16: op1.deref() = StackPop16(); break; + case Mode::b32: op1.deref() = StackPop32(); break; + case Mode::b64: op1.deref() = StackPop64(); break; + default: std::abort(); + } break; default: - UNREACHABLE(); - } - break; - default: - UNREACHABLE(); + std::abort(); } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp b/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp index f6a30a70..b07eb704 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp @@ -1,54 +1,27 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#include -#include -#include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecPUSH(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecPUSH(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_op_types) { - case R: - switch (instr.m_opcode_mode) { - case HyperCPU::Mode::b8: - StackPush8(HyperCPU::bit_cast_from(op1.ptr())); - break; - case HyperCPU::Mode::b16: - StackPush16(HyperCPU::bit_cast_from(op1.ptr())); - break; - case HyperCPU::Mode::b32: - StackPush32(HyperCPU::bit_cast_from(op1.ptr())); - break; - case HyperCPU::Mode::b64: - StackPush64(HyperCPU::bit_cast_from(op1.ptr())); - break; - default: - UNREACHABLE(); - } - break; - case IMM: - switch (instr.m_opcode_mode) { - case HyperCPU::Mode::b8: - StackPush8(HyperCPU::bit_cast(op1)); - break; - case HyperCPU::Mode::b16: - StackPush16(HyperCPU::bit_cast(op1)); - break; - case HyperCPU::Mode::b32: - StackPush32(HyperCPU::bit_cast(op1)); - break; - case HyperCPU::Mode::b64: - StackPush64(HyperCPU::bit_cast(op1)); + case OperandTypes::R: + switch (instr.m_opcode_mode) { + case HyperCPU::Mode::b8: StackPush8(HyperCPU::bit_cast_from(op1.ptr())); break; + case HyperCPU::Mode::b16: StackPush16(HyperCPU::bit_cast_from(op1.ptr())); break; + case HyperCPU::Mode::b32: StackPush32(HyperCPU::bit_cast_from(op1.ptr())); break; + case HyperCPU::Mode::b64: StackPush64(HyperCPU::bit_cast_from(op1.ptr())); break; + default: std::abort(); + } + break; + case OperandTypes::IMM: + switch (instr.m_opcode_mode) { + case HyperCPU::Mode::b8: StackPush8(HyperCPU::bit_cast(op1)); break; + case HyperCPU::Mode::b16: StackPush16(HyperCPU::bit_cast(op1)); break; + case HyperCPU::Mode::b32: StackPush32(HyperCPU::bit_cast(op1)); break; + case HyperCPU::Mode::b64: StackPush64(HyperCPU::bit_cast(op1)); break; + default: std::abort(); + } break; default: - UNREACHABLE(); - } - break; - default: - UNREACHABLE(); + std::abort(); } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp b/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp index 750efb7f..e530ebfa 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp @@ -1,29 +1,20 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#include -#include -#include -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" - -void HyperCPU::CPU::ExecREAD(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecREAD(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { read_operation_handler* handler = nullptr; switch (instr.m_op_types) { - case HyperCPU::IMM: - handler = &read_io_handlers[HyperCPU::bit_cast(op1)]; - break; - case HyperCPU::R: - handler = &read_io_handlers[HyperCPU::bit_cast_from(op1.ptr())]; - break; - default: - UNREACHABLE(); + case OperandTypes::IMM: + handler = &read_io_handlers[HyperCPU::bit_cast(op1)]; + break; + case OperandTypes::R: + handler = &read_io_handlers[HyperCPU::bit_cast_from(op1.ptr())]; + break; + default: + std::abort(); } if (handler) { *xlll0 = (*handler)(); } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp index 087b49a0..92783668 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp @@ -1,62 +1,59 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include - -#include void HyperCPU::CPU::ExecSHFL(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; - - case b16: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; - case b32: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; + case Mode::b16: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; - case b64: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; - } - break; - } + case Mode::b32: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - op1.deref() <<= val; + case Mode::b64: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; + } break; } - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - op1.deref() <<= val; + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; + break; + } + } break; } - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - op1.deref() <<= val; + default: break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - op1.deref() <<= val; - break; - } - } - break; - } - - default: - break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp index af9d0829..800ac2bc 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp @@ -1,63 +1,59 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#include - -#include void HyperCPU::CPU::ExecSHFR(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - op1.deref() >>= op2.deref(); - break; - - case b16: - op1.deref() >>= op2.deref(); - break; + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + op1.deref() >>= op2.deref(); + break; - case b32: - op1.deref() >>= op2.deref(); - break; + case Mode::b16: + op1.deref() >>= op2.deref(); + break; - case b64: - op1.deref() >>= op2.deref(); - break; - } - break; - } + case Mode::b32: + op1.deref() >>= op2.deref(); + break; - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - op1.deref() >>= val; + case Mode::b64: + op1.deref() >>= op2.deref(); + break; + } break; } - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - op1.deref() >>= val; + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; + break; + } + } break; } - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - op1.deref() >>= val; + default: break; - } - - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - op1.deref() >>= val; - break; - } - } - break; - } - - default: - break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp index cc117636..d92c885c 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp @@ -1,144 +1,142 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/ALU.hpp" -#include -#include +#include "Emulator/Misc/underflow.hpp" -#include -#include using namespace HyperALU; void HyperCPU::CPU::ExecSUB(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case R_R: { - switch (instr.m_opcode_mode) { - case b8: - udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b16: + udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b32: + udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b64: + udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } // TODO: mark defaults as std::unreachable() break; - - case b16: - udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b32: - udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case b64: - udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } // TODO: mark defaults as std::unreachable() - break; - } - - case R_RM: { - std::uint64_t ptr = op2.deref(); - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } } - break; - } - - case R_M: { - std::uint64_t ptr = op2; - - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = mem_controller->Read8(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b16: { - std::uint16_t val = mem_controller->Read16(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b32: { - std::uint32_t val = mem_controller->Read32(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case b64: { - std::uint64_t val = mem_controller->Read64(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - } - break; - } - case R_IMM: { - switch (instr.m_opcode_mode) { - case b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); + case OperandTypes::R_RM: { + std::uint64_t ptr = op2.deref(); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + } break; } - case b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); + case OperandTypes::R_M: { + std::uint64_t ptr = op2; + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + } break; } - case b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + } break; } - case b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); + default: break; - } - } - break; - } - - default: - break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp b/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp index 8073ad56..67f418fd 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp @@ -1,28 +1,19 @@ -#include "pch.hpp" +#include "Emulator/Core/CPU/CPU.hpp" -#include -#include -#include -#include - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" void HyperCPU::CPU::ExecWRITE(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { write_operation_handler& handler = write_io_handlers[*static_cast(op1)]; if (handler) { switch (instr.m_op_types) { - case R_R: - handler(*static_cast(op2)); - break; - case R_IMM: - handler(HyperCPU::bit_cast(op2)); - break; - default: - UNREACHABLE(); + case OperandTypes::R_R: + handler(*static_cast(op2)); + break; + case OperandTypes::R_IMM: + handler(HyperCPU::bit_cast(op2)); + break; + default: + std::abort(); } } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp b/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp index 7c02c43c..4bc5e05a 100644 --- a/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp +++ b/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp @@ -1,15 +1,14 @@ -#include "pch.hpp" +#include -#include -#include -#include -#include -#include +#include "PCH/CStd.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" +#include "Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp" void HyperCPU::CPU::TriggerInterrupt(HyperCPU::cpu_exceptions exception) { if (!ivt_initialized || pending_interrupt.has_value()) { - logger.Log(LogLevel::ERROR, "Interrupt was triggered, but failed to execute handler! XIP: {}", *xip); - ABORT(); + spdlog::error("Interrupt was triggered, but failed to execute handler! XIP: {}", *xip); + std::abort(); } pending_interrupt = std::make_optional(mem_controller->Read64((*xivt) + (8 * static_cast(exception)))); diff --git a/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp b/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp index b3cc0cab..cff97b36 100644 --- a/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp +++ b/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp @@ -1,6 +1,6 @@ #pragma once -#include "pch.hpp" +#include "PCH/CStd.hpp" namespace HyperCPU { enum class cpu_exceptions : std::uint_fast8_t { diff --git a/src/Emulator/Core/CPU/OperandsEvaluation.cpp b/src/Emulator/Core/CPU/OperandsEvaluation.cpp index 602ef8b7..2da7c9cd 100644 --- a/src/Emulator/Core/CPU/OperandsEvaluation.cpp +++ b/src/Emulator/Core/CPU/OperandsEvaluation.cpp @@ -1,102 +1,101 @@ -#include "pch.hpp" +#include "PCH/CStd.hpp" -#include -#include -#include -#include +#include "Emulator/Core/CPU/CPU.hpp" +#include "Common/LanguageSpec/Registers.hpp" +#include "Emulator/Misc/bit_cast.hpp" HyperCPU::OperandContainer HyperCPU::CPU::GetRegister(OperandContainer& op1) { - HyperCPU::Registers reg; - memcpy(®, &op1, sizeof(HyperCPU::Registers)); + HyperCPU::Reg reg; + memcpy(®, &op1, sizeof(HyperCPU::Reg)); switch (reg) { - case X0: + case HyperCPU::Reg::X0: return OperandContainer{x0}; - case X1: + case HyperCPU::Reg::X1: return OperandContainer{x1}; - case X2: + case HyperCPU::Reg::X2: return OperandContainer{x2}; - case X3: + case HyperCPU::Reg::X3: return OperandContainer{x3}; - case X4: + case HyperCPU::Reg::X4: return OperandContainer{x4}; - case X5: + case HyperCPU::Reg::X5: return OperandContainer{x5}; - case X6: + case HyperCPU::Reg::X6: return OperandContainer{x6}; - case X7: + case HyperCPU::Reg::X7: return OperandContainer{x7}; - case XH0: + case HyperCPU::Reg::XH0: return OperandContainer{xh0}; - case XH1: + case HyperCPU::Reg::XH1: return OperandContainer{xh1}; - case XH2: + case HyperCPU::Reg::XH2: return OperandContainer{xh2}; - case XH3: + case HyperCPU::Reg::XH3: return OperandContainer{xh3}; - case XH4: + case HyperCPU::Reg::XH4: return OperandContainer{xh4}; - case XH5: + case HyperCPU::Reg::XH5: return OperandContainer{xh5}; - case XH6: + case HyperCPU::Reg::XH6: return OperandContainer{xh6}; - case XH7: + case HyperCPU::Reg::XH7: return OperandContainer{xh7}; - case XL0: + case HyperCPU::Reg::XL0: return OperandContainer{xl0}; - case XL1: + case HyperCPU::Reg::XL1: return OperandContainer{xl1}; - case XL2: + case HyperCPU::Reg::XL2: return OperandContainer{xl2}; - case XL3: + case HyperCPU::Reg::XL3: return OperandContainer{xl3}; - case XL4: + case HyperCPU::Reg::XL4: return OperandContainer{xl4}; - case XL5: + case HyperCPU::Reg::XL5: return OperandContainer{xl5}; - case XL6: + case HyperCPU::Reg::XL6: return OperandContainer{xl6}; - case XL7: + case HyperCPU::Reg::XL7: return OperandContainer{xl7}; - case XLL0: + case HyperCPU::Reg::XLL0: return OperandContainer{xll0}; - case XLL1: + case HyperCPU::Reg::XLL1: return OperandContainer{xll1}; - case XLL2: + case HyperCPU::Reg::XLL2: return OperandContainer{xll2}; - case XLL3: + case HyperCPU::Reg::XLL3: return OperandContainer{xll3}; - case XLLH0: + case HyperCPU::Reg::XLLH0: return OperandContainer{xllh0}; - case XLLH1: + case HyperCPU::Reg::XLLH1: return OperandContainer{xllh1}; - case XLLH2: + case HyperCPU::Reg::XLLH2: return OperandContainer{xllh2}; - case XLLH3: + case HyperCPU::Reg::XLLH3: return OperandContainer{xllh3}; - case XLLL0: + case HyperCPU::Reg::XLLL0: return OperandContainer{xlll0}; - case XLLL1: + case HyperCPU::Reg::XLLL1: return OperandContainer{xlll1}; - case XLLL2: + case HyperCPU::Reg::XLLL2: return OperandContainer{xlll2}; - case XLLL3: + case HyperCPU::Reg::XLLL3: return OperandContainer{xlll3}; - case XBP: + case HyperCPU::Reg::XBP: return OperandContainer{xbp}; - case XSP: + case HyperCPU::Reg::XSP: return OperandContainer{xsp}; - case XIP: + case HyperCPU::Reg::XIP: return OperandContainer{xip}; - case XGDP: + case HyperCPU::Reg::XGDP: return OperandContainer{xgdp}; - case XIVT: + case HyperCPU::Reg::XIVT: return OperandContainer{xivt}; default: throw std::runtime_error("Invalid register"); @@ -105,38 +104,38 @@ HyperCPU::OperandContainer HyperCPU::CPU::GetRegister(OperandContainer& op1) { std::pair HyperCPU::CPU::GetOperands(OperandTypes op_types, Mode md, OperandContainer& op1, OperandContainer& op2) { switch (op_types) { - case R_R: - case R_RM: - case RM_R: { + case OperandTypes::R_R: + case OperandTypes::R_RM: + case OperandTypes::RM_R: { OperandContainer op_1, op_2; op_1 = GetRegister(op1); op_2 = GetRegister(op2); return std::make_pair(op_1, op_2); } - case RM_M: - case R_M: + case OperandTypes::RM_M: + case OperandTypes::R_M: return std::make_pair(GetRegister(op1), op2); - case RM_IMM: - case R_IMM: { + case OperandTypes::RM_IMM: + case OperandTypes::R_IMM: { switch (md) { - case b8: { + case Mode::b8: { std::uint8_t imm8; std::memcpy(&imm8, &op2, sizeof(std::uint8_t)); return std::make_pair(GetRegister(op1), OperandContainer{HyperCPU::bit_cast(imm8)}); } - case b16: { + case Mode::b16: { std::uint16_t imm16; std::memcpy(&imm16, &op2, sizeof(std::uint16_t)); return std::make_pair(GetRegister(op1), OperandContainer{HyperCPU::bit_cast(imm16)}); } - case b32: { + case Mode::b32: { std::uint32_t imm32; std::memcpy(&imm32, &op2, sizeof(std::uint32_t)); return std::make_pair(GetRegister(op1), OperandContainer{HyperCPU::bit_cast(imm32)}); } - case b64: { + case Mode::b64: { std::uint64_t imm64; std::memcpy(&imm64, &op2, sizeof(std::uint64_t)); return std::make_pair(GetRegister(op1), OperandContainer{HyperCPU::bit_cast(imm64)}); @@ -145,20 +144,20 @@ std::pair HyperCPU::CPU: break; } - case M_R: + case OperandTypes::M_R: return std::make_pair(op1, GetRegister(op2)); - case R: + case OperandTypes::R: return std::make_pair(GetRegister(op1), nullptr); - case IMM: - case M: + case OperandTypes::IMM: + case OperandTypes::M: return std::make_pair(op1, nullptr); - case NONE: + case OperandTypes::NONE: return std::make_pair(nullptr, nullptr); default: - ABORT(); + std::abort(); } return {}; } diff --git a/src/Emulator/Core/CPU/Stack.cpp b/src/Emulator/Core/CPU/Stack.cpp index 6c86ea4e..2415b4a0 100644 --- a/src/Emulator/Core/CPU/Stack.cpp +++ b/src/Emulator/Core/CPU/Stack.cpp @@ -1,7 +1,7 @@ -#include "pch.hpp" +#include "PCH/CStd.hpp" -#include -#include +#include "Emulator/Core/CPU/Assert.hpp" +#include "Emulator/Core/CPU/CPU.hpp" void HyperCPU::CPU::StackPush8(std::uint8_t val) noexcept { h_assert(*xsp > 1, { std::cout << "Stack pointer too low!\n"; exit(1); }); diff --git a/src/Emulator/Core/MemoryController/IMemoryController.hpp b/src/Emulator/Core/MemoryController/IMemoryController.hpp index a1b28a79..e915e4f5 100644 --- a/src/Emulator/Core/MemoryController/IMemoryController.hpp +++ b/src/Emulator/Core/MemoryController/IMemoryController.hpp @@ -1,12 +1,15 @@ #pragma once -#include "pch.hpp" +#include +#include "PCH/CStd.hpp" + +// TODO: позор партии, убрать и переделать в функцию #define mem_ctlr_assert(expr) \ do { \ if (!(expr) && (!cpu || !cpu->CanExecuteInterrupts())) [[unlikely]] { \ - HyperCPU::println("Assertion failed: {}", #expr); \ - ABORT(); \ + spdlog::error("Assertion failed: {}", #expr); \ + std::abort(); \ } else if (!(expr) && cpu && cpu->CanExecuteInterrupts()) { \ cpu->TriggerInterrupt(HyperCPU::cpu_exceptions::SEGF); \ } else [[likely]] { \ diff --git a/src/Emulator/Core/MemoryController/MemoryControllerST.hpp b/src/Emulator/Core/MemoryController/MemoryControllerST.hpp index ed375f0f..5289f292 100644 --- a/src/Emulator/Core/MemoryController/MemoryControllerST.hpp +++ b/src/Emulator/Core/MemoryController/MemoryControllerST.hpp @@ -1,10 +1,10 @@ #pragma once -#include "pch.hpp" +#include "PCH/CStd.hpp" -#include -#include -#include +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp" +#include "Emulator/Core/MemoryController/IMemoryController.hpp" namespace HyperCPU { class MemoryControllerST final : public IMemoryController { diff --git a/src/Emulator/Main/Main.cpp b/src/Emulator/Main/Main.cpp index efdf12e1..4e9b7c5e 100644 --- a/src/Emulator/Main/Main.cpp +++ b/src/Emulator/Main/Main.cpp @@ -1,19 +1,79 @@ -#include "pch.hpp" - -#include -#include -#include -#include -#include -#include - #include +#include "PCH/CStd.hpp" +#include "Assembler/Core/Compiler.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +// TODO: move this header (it needs some prefix, otherwise quotes look in this dir) +#include "Common/Version.hpp" + #ifdef HCPU_ENABLE_LIBUNWIND #include #endif -HyperCPU::GenericHeader ParseHeader(std::ifstream& binary); +HyperCPU::GenericHeader ParseHeader(std::ifstream& file) { + HyperCPU::GenericHeader header; + file.read(reinterpret_cast(&header), sizeof(header)); + + return header; +} + +std::uint64_t ParseMemoryString(const std::string& str) { + if (str.empty()) { + return std::numeric_limits::max(); + } + + std::size_t idx = 0; + // Validate digits + for (char c : str) { + if (!std::isdigit(c)) { + break; + } + ++idx; + } + + if (idx == 0) { + return std::numeric_limits::max(); + } + + std::string_view numeric_part = std::string_view(str).substr(0, idx); + + char suffix = str[idx]; + ++idx; + + if (idx != str.size()) { + return std::numeric_limits::max(); + } + + std::uint64_t multiplier; + switch (suffix) { + case 'K': + multiplier = 1024ULL; + break; + case 'M': + multiplier = 1024ULL * 1024; + break; + case 'G': + multiplier = 1024ULL * 1024 * 1024; + break; + case 'T': + multiplier = 1024ULL * 1024 * 1024 * 1024; + break; + default: + return std::numeric_limits::max(); + } + + std::uint64_t result; + auto [ptr, ec] = std::from_chars(numeric_part.data(), numeric_part.end(), result); + if (ec != std::errc() || ptr != numeric_part.end()) { + return std::numeric_limits::max(); + } + + if (multiplier != 0 && result > std::numeric_limits::max() / multiplier) { + return std::numeric_limits::max(); + } + + return result * multiplier; +} int main(int argc, char** argv) { #ifdef HCPU_ENABLE_LIBUNWIND @@ -22,7 +82,7 @@ int main(int argc, char** argv) { std::signal(SIGSEGV, SignalHandler); std::signal(SIGFPE, SignalHandler); #endif - HyperCPU::Logger logger{HyperCPU::LogLevel::ERROR}; + argparse::ArgumentParser program("hcemul", HCPU_VERSION); program.add_argument("binary") .help("binary file to execute") @@ -38,28 +98,27 @@ int main(int argc, char** argv) { program.parse_args(argc, argv); } catch (const std::exception& err) { std::cerr << err.what() << '\n'; - EXIT(1); + return 1; } auto source = program.get("binary"); if (!std::filesystem::exists(source)) { - logger.Log(HyperCPU::LogLevel::ERROR, fmt::format("Binary \"{}\" does not exist!", source)); - EXIT(1); + spdlog::error("Binary \"{}\" does not exist!", source); + return 1; } else if (!std::filesystem::is_regular_file(source)) { - logger.Log(HyperCPU::LogLevel::ERROR, fmt::format("Source path \"{}\" is not a regular file!", source)); - EXIT(1); + spdlog::error("Source path \"{}\" is not a regular file!", source); + return 1; } std::ifstream file(source); - std::int64_t binarysize = std::filesystem::file_size(source) - sizeof(HyperCPU::GenericHeader); HyperCPU::GenericHeader header = ParseHeader(file); // Validate header contents if (header.magic != HyperCPU::magic) { - logger.Log(HyperCPU::LogLevel::ERROR, "Invalid magic!"); - EXIT(1); + spdlog::error("Invalid magic!"); + return 1; } switch (header.version) { @@ -67,28 +126,28 @@ int main(int argc, char** argv) { case HyperCPU::Version::Release1_0: break; default: - logger.Log(HyperCPU::LogLevel::ERROR, "Invalid release field!"); - EXIT(1); + spdlog::error("Invalid release field!"); + return 1; } switch (header.type) { case HyperCPU::FileType::Binary: break; case HyperCPU::FileType::Object: - logger.Log(HyperCPU::LogLevel::ERROR, "Executing object files is not supported, please link it first!"); - EXIT(1); + spdlog::error("Executing object files is not supported, please link it first!"); + return 1; default: - logger.Log(HyperCPU::LogLevel::ERROR, "Invalid type field!"); - EXIT(1); + spdlog::error("Invalid type field!"); + return 1; } std::unique_ptr buf(new char[binarysize]); file.read(buf.get(), binarysize); - auto memory = HyperCPU::ParseMemoryString(program.get("-m")); + auto memory = ParseMemoryString(program.get("-m")); if (memory == std::numeric_limits::max()) { - logger.Log(HyperCPU::LogLevel::ERROR, "Failed to parse memory amount argument."); - EXIT(1); + spdlog::error("Failed to parse memory amount argument."); + return 1; } HyperCPU::CPU cpu{1, memory, buf.get(), static_cast(binarysize)}; @@ -96,68 +155,3 @@ int main(int argc, char** argv) { cpu.SetEntryPoint(header.entry_point); cpu.Run(); } - -HyperCPU::GenericHeader ParseHeader(std::ifstream& file) { - HyperCPU::GenericHeader header; - file.read(reinterpret_cast(&header), sizeof(header)); - - return header; -} - -std::uint64_t HyperCPU::ParseMemoryString(const std::string& str) { - if (str.empty()) { - return std::numeric_limits::max(); - } - - std::size_t idx = 0; - // Validate digits - for (char c : str) { - if (!std::isdigit(c)) { - break; - } - ++idx; - } - - if (idx == 0) { - return std::numeric_limits::max(); - } - - std::string_view numeric_part = std::string_view(str).substr(0, idx); - - char suffix = str[idx]; - ++idx; - - if (idx != str.size()) { - return std::numeric_limits::max(); - } - - std::uint64_t multiplier; - switch (suffix) { - case 'K': - multiplier = 1024ULL; - break; - case 'M': - multiplier = 1024ULL * 1024; - break; - case 'G': - multiplier = 1024ULL * 1024 * 1024; - break; - case 'T': - multiplier = 1024ULL * 1024 * 1024 * 1024; - break; - default: - return std::numeric_limits::max(); - } - - std::uint64_t result; - auto [ptr, ec] = std::from_chars(numeric_part.data(), numeric_part.end(), result); - if (ec != std::errc() || ptr != numeric_part.end()) { - return std::numeric_limits::max(); - } - - if (multiplier != 0 && result > std::numeric_limits::max() / multiplier) { - return std::numeric_limits::max(); - } - - return result * multiplier; -} diff --git a/src/Emulator/Misc/bit_cast.hpp b/src/Emulator/Misc/bit_cast.hpp index 27536acc..516edd4d 100644 --- a/src/Emulator/Misc/bit_cast.hpp +++ b/src/Emulator/Misc/bit_cast.hpp @@ -1,9 +1,6 @@ #pragma once -#include -#include - -#include +#include "PCH/CStd.hpp" namespace HyperCPU { template diff --git a/src/Emulator/Misc/byteswap.hpp b/src/Emulator/Misc/byteswap.hpp index c16370ef..3b787e52 100644 --- a/src/Emulator/Misc/byteswap.hpp +++ b/src/Emulator/Misc/byteswap.hpp @@ -1,8 +1,7 @@ #pragma once -#include "pch.hpp" - -#include +#include "PCH/CStd.hpp" +#include "Emulator/Misc/bit_cast.hpp" namespace HyperCPU { template diff --git a/src/Emulator/Misc/deref.hpp b/src/Emulator/Misc/deref.hpp index 8afb67e4..95c0b247 100644 --- a/src/Emulator/Misc/deref.hpp +++ b/src/Emulator/Misc/deref.hpp @@ -1,8 +1,10 @@ #pragma once +#include "PCH/CStd.hpp" + namespace HyperCPU { template constexpr T& deref(std::uint64_t ptr) { return *static_cast(ptr); } -} // namespace HyperCPU \ No newline at end of file +} // namespace HyperCPU diff --git a/src/Emulator/Misc/overflow.hpp b/src/Emulator/Misc/overflow.hpp index 0d329e6c..487ee116 100644 --- a/src/Emulator/Misc/overflow.hpp +++ b/src/Emulator/Misc/overflow.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include "PCH/CStd.hpp" namespace HyperCPU { template diff --git a/src/Emulator/Misc/print.hpp b/src/Emulator/Misc/print.hpp index 7bee3a90..e15766b5 100644 --- a/src/Emulator/Misc/print.hpp +++ b/src/Emulator/Misc/print.hpp @@ -1,7 +1,8 @@ #pragma once #include -#include + +#include "PCH/CStd.hpp" namespace HyperCPU { template diff --git a/src/PCH/CStd.hpp b/src/PCH/CStd.hpp index 479e713e..229019ba 100644 --- a/src/PCH/CStd.hpp +++ b/src/PCH/CStd.hpp @@ -32,3 +32,4 @@ #include #include #include +#include diff --git a/src/Pog/BUILD.bazel b/src/Pog/BUILD.bazel index 093f3c28..b8c26b65 100644 --- a/src/Pog/BUILD.bazel +++ b/src/Pog/BUILD.bazel @@ -9,8 +9,7 @@ package( cc_library( name = 'pog_core', - hdrs = glob(['**/*.hpp'], exclude = ['Pog.hpp']), - strip_include_prefix = '/src' + hdrs = glob(['**/*.hpp'], exclude = ['Pog.hpp']) ) precompiled_headers( diff --git a/tools/bazel/BUILD.bazel b/tools/bazel/BUILD.bazel index 387d54a6..b97ffb1d 100644 --- a/tools/bazel/BUILD.bazel +++ b/tools/bazel/BUILD.bazel @@ -1,9 +1 @@ 'Common macros, rules etc. used by HyperCPU' - -load('@bazel_skylib//rules:native_binary.bzl', 'native_binary') - -native_binary( - name = 'clang_tidy', - src = '@llvm_toolchain_llvm//:bin/clang-tidy', - out = 'clang_tidy', -) diff --git a/tools/bazel/linting.bzl b/tools/bazel/linting.bzl deleted file mode 100644 index f4008bcf..00000000 --- a/tools/bazel/linting.bzl +++ /dev/null @@ -1,11 +0,0 @@ -load('@aspect_rules_lint//lint:clang_tidy.bzl', 'lint_clang_tidy_aspect') - -clang_tidy = lint_clang_tidy_aspect( - binary = '//tools/bazel:clang_tidy', - # configs = [ - # '//:.clang-tidy', - # ], - lint_target_headers = True, - angle_includes_are_system = True, - verbose = True, -) From 78092d903426ce7076ab7ef534d4c216d8ad8dad Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 03:08:09 +0300 Subject: [PATCH 09/40] adjusted testing & docker image --- BUILD.bazel | 6 + docker/archlinux/Dockerfile | 16 +- docker/debian-stable/Dockerfile | 11 +- docker/debian-unstable/Dockerfile | 11 +- docker/ubuntu/Dockerfile | 11 +- .../MemoryController/IMemoryController.hpp | 51 +++++- .../MemoryController/MemoryControllerST.hpp | 9 +- tests/BUILD.bazel | 18 ++ .../AssemblerCore/AssemblerFail.cpp | 7 +- .../AssemblerCore/AssemblerSuccess.cpp | 104 ++++++----- .../AssemblerCore/FullAssembler.cpp | 32 ++-- .../AssemblerCore/TwoOperandsSuccess.cpp | 4 +- tests/Integration/BUILD.bazel | 11 ++ .../Integration/EmulatorCore/CPU/CPU_ADC.cpp | 164 +++++++++--------- .../Integration/EmulatorCore/CPU/CPU_ADD.cpp | 132 +++++++------- .../EmulatorCore/Exceptions/Exceptions.cpp | 10 +- tests/Pog/Automaton.cpp | 6 +- tests/Pog/BUILD.bazel | 14 ++ tests/Pog/FilterView.cpp | 5 +- tests/Pog/Grammar.cpp | 6 +- tests/Pog/Item.cpp | 6 +- tests/Pog/Parser.cpp | 6 +- tests/Pog/ParsingTable.cpp | 5 +- tests/Pog/PogTests.cpp | 6 - tests/Pog/Precedence.cpp | 5 +- tests/Pog/Rule.cpp | 5 +- tests/Pog/RuleBuilder.cpp | 5 +- tests/Pog/State.cpp | 5 +- tests/Pog/Symbol.cpp | 5 +- tests/Pog/Token.cpp | 5 +- tests/Pog/TokenBuilder.cpp | 5 +- tests/Pog/Tokenizer.cpp | 5 +- tests/Pog/Utils.cpp | 5 +- tests/fixtures.hpp | 51 +++--- tests/gtest.hpp | 3 + tests/main.cpp | 8 - 36 files changed, 436 insertions(+), 322 deletions(-) create mode 100644 tests/BUILD.bazel create mode 100644 tests/Integration/BUILD.bazel create mode 100644 tests/Pog/BUILD.bazel delete mode 100644 tests/Pog/PogTests.cpp create mode 100644 tests/gtest.hpp delete mode 100644 tests/main.cpp diff --git a/BUILD.bazel b/BUILD.bazel index beb53971..b3678328 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -3,6 +3,12 @@ load('@aspect_rules_lint//format:defs.bzl', 'format_multirun') load('@hedron_compile_commands//:refresh_compile_commands.bzl', 'refresh_compile_commands') +package( + default_visibility = [ + '//visibility:private', + ], +) + refresh_compile_commands( name = 'refresh_compile_commands', targets = { diff --git a/docker/archlinux/Dockerfile b/docker/archlinux/Dockerfile index 635e4611..bcb0397a 100644 --- a/docker/archlinux/Dockerfile +++ b/docker/archlinux/Dockerfile @@ -1,7 +1,19 @@ FROM archlinux:latest +ARG USER=bazel +ARG BAZELISK_TAG=v1.15.0 + RUN pacman -Syu --noconfirm --needed \ - python python-pip cmake git clang gcc \ - base-devel nodejs make \ + python python-pip git clang gcc \ + base-devel wget \ && pip install --no-cache-dir --break-system-packages conan \ && pacman -Scc --noconfirm + +RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG}/bazelisk-linux-amd64 && \ + chmod 755 bazelisk-linux-amd64 && \ + mv bazelisk-linux-amd64 /usr/bin/bazelisk + +RUN useradd -m ${USER} + +WORKDIR /home/${USER}/workspace +USER ${USER} diff --git a/docker/debian-stable/Dockerfile b/docker/debian-stable/Dockerfile index d67171a4..a48e29d8 100644 --- a/docker/debian-stable/Dockerfile +++ b/docker/debian-stable/Dockerfile @@ -1,6 +1,15 @@ FROM debian:latest RUN apt-get update && apt-get install -y --no-install-recommends \ - git cmake clang libre2-9 libre2-dev gnu-which nodejs python3 python3-pip make gcc g++ \ + git cmake clang libre2-9 libre2-dev python3 python3-pip make gcc g++ \ && pip3 install --no-cache-dir --break-system-packages conan \ && rm -rf /var/lib/apt/lists/* + +RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG}/bazelisk-linux-amd64 && \ + chmod 755 bazelisk-linux-amd64 && \ + mv bazelisk-linux-amd64 /usr/bin/bazelisk + +RUN useradd -m ${USER} + +WORKDIR /home/${USER}/workspace +USER ${USER} diff --git a/docker/debian-unstable/Dockerfile b/docker/debian-unstable/Dockerfile index ad2bf8a3..5eb9ae9a 100644 --- a/docker/debian-unstable/Dockerfile +++ b/docker/debian-unstable/Dockerfile @@ -1,6 +1,15 @@ FROM debian:unstable RUN apt-get update && apt-get install -y --no-install-recommends \ - git cmake clang libre2-11 libre2-dev gnu-which nodejs python3 python3-pip make gcc g++ \ + git cmake clang libre2-11 libre2-dev python3 python3-pip make gcc g++ \ && pip3 install --no-cache-dir --break-system-packages conan \ && rm -rf /var/lib/apt/lists/* + +RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG}/bazelisk-linux-amd64 && \ + chmod 755 bazelisk-linux-amd64 && \ + mv bazelisk-linux-amd64 /usr/bin/bazelisk + +RUN useradd -m ${USER} + +WORKDIR /home/${USER}/workspace +USER ${USER} diff --git a/docker/ubuntu/Dockerfile b/docker/ubuntu/Dockerfile index ffc77e18..d5d6705d 100644 --- a/docker/ubuntu/Dockerfile +++ b/docker/ubuntu/Dockerfile @@ -1,6 +1,15 @@ FROM ubuntu:latest RUN apt update && apt install -y --no-install-recommends \ - git cmake clang libre2-10 libre2-dev gnu-which nodejs python3 python3-pip make gcc g++ \ + git cmake clang libre2-10 libre2-dev python3 python3-pip make gcc g++ \ && pip3 install --no-cache-dir --break-system-packages conan \ && rm -rf /var/lib/apt/lists/* + +RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG}/bazelisk-linux-amd64 && \ + chmod 755 bazelisk-linux-amd64 && \ + mv bazelisk-linux-amd64 /usr/bin/bazelisk + +RUN useradd -m ${USER} + +WORKDIR /home/${USER}/workspace +USER ${USER} diff --git a/src/Emulator/Core/MemoryController/IMemoryController.hpp b/src/Emulator/Core/MemoryController/IMemoryController.hpp index e915e4f5..5aaeed13 100644 --- a/src/Emulator/Core/MemoryController/IMemoryController.hpp +++ b/src/Emulator/Core/MemoryController/IMemoryController.hpp @@ -29,14 +29,55 @@ namespace HyperCPU { virtual std::uint32_t Read32(std::uint64_t) = 0; virtual std::uint64_t Read64(std::uint64_t) = 0; - virtual void Load8(std::uint64_t, std::uint8_t) = 0; - virtual void Load16(std::uint64_t, std::uint16_t) = 0; - virtual void Load32(std::uint64_t, std::uint32_t) = 0; - virtual void Load64(std::uint64_t, std::uint64_t) = 0; + template + void Load8(std::uint64_t, T); + template + void Load16(std::uint64_t, T); + template + void Load32(std::uint64_t, T); + template + void Load64(std::uint64_t, T); virtual std::uint8_t* get_ptr() const noexcept = 0; + virtual ~IMemoryController() = default; - virtual ~IMemoryController() {}; + protected: + virtual void load8(std::uint64_t, std::uint8_t) = 0; + virtual void load16(std::uint64_t, std::uint16_t) = 0; + virtual void load32(std::uint64_t, std::uint32_t) = 0; + virtual void load64(std::uint64_t, std::uint64_t) = 0; }; } // namespace HyperCPU + +template +void HyperCPU::IMemoryController::Load8(std::uint64_t address, T value) { + using ActualFrom = std::conditional_t, std::underlying_type_t, T>; + static_assert(std::is_convertible_v, "Value must be convertable to integer type"); + + load8(address, static_cast(value)); +} + +template +void HyperCPU::IMemoryController::Load16(std::uint64_t address, T value) { + using ActualFrom = std::conditional_t, std::underlying_type_t, T>; + static_assert(std::is_convertible_v, "Value must be convertable to integer type"); + + load16(address, static_cast(value)); +} + +template +void HyperCPU::IMemoryController::Load32(std::uint64_t address, T value) { + using ActualFrom = std::conditional_t, std::underlying_type_t, T>; + static_assert(std::is_convertible_v, "Value must be convertable to integer type"); + + load32(address, static_cast(value)); +} + +template +void HyperCPU::IMemoryController::Load64(std::uint64_t address, T value) { + using ActualFrom = std::conditional_t, std::underlying_type_t, T>; + static_assert(std::is_convertible_v, "Value must be convertable to integer type"); + + load64(address, static_cast(value)); +} diff --git a/src/Emulator/Core/MemoryController/MemoryControllerST.hpp b/src/Emulator/Core/MemoryController/MemoryControllerST.hpp index 5289f292..98d71609 100644 --- a/src/Emulator/Core/MemoryController/MemoryControllerST.hpp +++ b/src/Emulator/Core/MemoryController/MemoryControllerST.hpp @@ -3,7 +3,6 @@ #include "PCH/CStd.hpp" #include "Emulator/Core/CPU/CPU.hpp" -#include "Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp" #include "Emulator/Core/MemoryController/IMemoryController.hpp" namespace HyperCPU { @@ -80,22 +79,22 @@ namespace HyperCPU { return data; } - inline void Load8(std::uint64_t ptr, std::uint8_t data) override { + inline void load8(std::uint64_t ptr, std::uint8_t data) override { mem_ctlr_assert(ptr + sizeof(std::uint8_t) - 1 < total_mem); memcpy(&memory[ptr], &data, sizeof(std::uint8_t)); } - inline void Load16(std::uint64_t ptr, std::uint16_t data) override { + inline void load16(std::uint64_t ptr, std::uint16_t data) override { mem_ctlr_assert(ptr + sizeof(std::uint16_t) - 1 < total_mem); memcpy(&memory[ptr], &data, sizeof(std::uint16_t)); } - inline void Load32(std::uint64_t ptr, std::uint32_t data) override { + inline void load32(std::uint64_t ptr, std::uint32_t data) override { mem_ctlr_assert(ptr + sizeof(std::uint32_t) - 1 < total_mem); memcpy(&memory[ptr], &data, sizeof(std::uint32_t)); } - inline void Load64(std::uint64_t ptr, std::uint64_t data) override { + inline void load64(std::uint64_t ptr, std::uint64_t data) override { mem_ctlr_assert(ptr + sizeof(std::uint64_t) - 1 < total_mem); memcpy(&memory[ptr], &data, sizeof(std::uint64_t)); } diff --git a/tests/BUILD.bazel b/tests/BUILD.bazel new file mode 100644 index 00000000..b900864a --- /dev/null +++ b/tests/BUILD.bazel @@ -0,0 +1,18 @@ +load('@rules_cc//cc:defs.bzl', 'cc_library') +load('//tools/bazel:pch.bzl', 'precompiled_headers') + +package( + default_visibility = [ + '//:__subpackages__', + ], +) + +precompiled_headers( + name = 'pch_gtest', + main = 'gtest.hpp' +) + +cc_library( + name = 'test_fixtures', + hdrs = ['fixtures.hpp'] +) diff --git a/tests/Integration/AssemblerCore/AssemblerFail.cpp b/tests/Integration/AssemblerCore/AssemblerFail.cpp index 1427f95d..c7a37fab 100644 --- a/tests/Integration/AssemblerCore/AssemblerFail.cpp +++ b/tests/Integration/AssemblerCore/AssemblerFail.cpp @@ -1,8 +1,7 @@ -#include "pch.hpp" +#include "PCH/CStd.hpp" +#include "tests/fixtures.hpp" -#include - -#ifdef __HCPU_DEBUG +#ifdef NDEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_EXIT(statement, x, regex) diff --git a/tests/Integration/AssemblerCore/AssemblerSuccess.cpp b/tests/Integration/AssemblerCore/AssemblerSuccess.cpp index 88d832be..97e89291 100644 --- a/tests/Integration/AssemblerCore/AssemblerSuccess.cpp +++ b/tests/Integration/AssemblerCore/AssemblerSuccess.cpp @@ -1,9 +1,5 @@ -#include -#include -#include -#include +#include "tests/fixtures.hpp" -#include TEST_F(ASSEMBLER, ASM_R_R_b8) { std::string data = "mov xlll0, xlll1;"; @@ -26,8 +22,8 @@ TEST_F(ASSEMBLER, ASM_R_R_b8) { EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_R); - EXPECT_EQ(static_cast(reg1), HyperCPU::Registers::XLLL0); - EXPECT_EQ(static_cast(reg2), HyperCPU::Registers::XLLL1); + EXPECT_EQ(static_cast(reg1), HyperCPU::Reg::XLLL0); + EXPECT_EQ(static_cast(reg2), HyperCPU::Reg::XLLL1); } TEST_F(ASSEMBLER, ASM_R_R_b16) { @@ -52,8 +48,8 @@ TEST_F(ASSEMBLER, ASM_R_R_b16) { EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_R); - EXPECT_EQ(static_cast(reg1), HyperCPU::Registers::XLL0); - EXPECT_EQ(static_cast(reg2), HyperCPU::Registers::XLL1); + EXPECT_EQ(static_cast(reg1), HyperCPU::Reg::XLL0); + EXPECT_EQ(static_cast(reg2), HyperCPU::Reg::XLL1); } TEST_F(ASSEMBLER, ASM_R_R_b32) { @@ -78,8 +74,8 @@ TEST_F(ASSEMBLER, ASM_R_R_b32) { EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_R); - EXPECT_EQ(static_cast(reg1), HyperCPU::Registers::XL0); - EXPECT_EQ(static_cast(reg2), HyperCPU::Registers::XL1); + EXPECT_EQ(static_cast(reg1), HyperCPU::Reg::XL0); + EXPECT_EQ(static_cast(reg2), HyperCPU::Reg::XL1); } TEST_F(ASSEMBLER, ASM_R_R_b64) { @@ -104,8 +100,8 @@ TEST_F(ASSEMBLER, ASM_R_R_b64) { EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_R); - EXPECT_EQ(static_cast(reg1), HyperCPU::Registers::X0); - EXPECT_EQ(static_cast(reg2), HyperCPU::Registers::X1); + EXPECT_EQ(static_cast(reg1), HyperCPU::Reg::X0); + EXPECT_EQ(static_cast(reg2), HyperCPU::Reg::X1); } TEST_F(ASSEMBLER, ASM_R_RM_b8) { @@ -130,8 +126,8 @@ TEST_F(ASSEMBLER, ASM_R_RM_b8) { EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_RM); - EXPECT_EQ(static_cast(reg1), HyperCPU::Registers::XLLL0); - EXPECT_EQ(static_cast(reg2), HyperCPU::Registers::X1); + EXPECT_EQ(static_cast(reg1), HyperCPU::Reg::XLLL0); + EXPECT_EQ(static_cast(reg2), HyperCPU::Reg::X1); } TEST_F(ASSEMBLER, ASM_R_RM_b16) { @@ -156,8 +152,8 @@ TEST_F(ASSEMBLER, ASM_R_RM_b16) { EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_RM); - EXPECT_EQ(static_cast(reg1), HyperCPU::Registers::XLL0); - EXPECT_EQ(static_cast(reg2), HyperCPU::Registers::X1); + EXPECT_EQ(static_cast(reg1), HyperCPU::Reg::XLL0); + EXPECT_EQ(static_cast(reg2), HyperCPU::Reg::X1); } TEST_F(ASSEMBLER, ASM_R_RM_b32) { @@ -182,8 +178,8 @@ TEST_F(ASSEMBLER, ASM_R_RM_b32) { EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_RM); - EXPECT_EQ(static_cast(reg1), HyperCPU::Registers::XL0); - EXPECT_EQ(static_cast(reg2), HyperCPU::Registers::X1); + EXPECT_EQ(static_cast(reg1), HyperCPU::Reg::XL0); + EXPECT_EQ(static_cast(reg2), HyperCPU::Reg::X1); } TEST_F(ASSEMBLER, ASM_R_RM_b64) { @@ -208,8 +204,8 @@ TEST_F(ASSEMBLER, ASM_R_RM_b64) { EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_RM); - EXPECT_EQ(static_cast(reg1), HyperCPU::Registers::X0); - EXPECT_EQ(static_cast(reg2), HyperCPU::Registers::X1); + EXPECT_EQ(static_cast(reg1), HyperCPU::Reg::X0); + EXPECT_EQ(static_cast(reg2), HyperCPU::Reg::X1); } TEST_F(ASSEMBLER, ASM_R_M_b8) { @@ -235,7 +231,7 @@ TEST_F(ASSEMBLER, ASM_R_M_b8) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_M); EXPECT_EQ(addr, 0); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::XLLL0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::XLLL0); } TEST_F(ASSEMBLER, ASM_R_M_b16) { @@ -261,7 +257,7 @@ TEST_F(ASSEMBLER, ASM_R_M_b16) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_M); EXPECT_EQ(addr, 0); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::XLL0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::XLL0); } TEST_F(ASSEMBLER, ASM_R_M_b32) { @@ -287,7 +283,7 @@ TEST_F(ASSEMBLER, ASM_R_M_b32) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_M); EXPECT_EQ(addr, 0); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::XL0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::XL0); } TEST_F(ASSEMBLER, ASM_R_M_b64) { @@ -313,7 +309,7 @@ TEST_F(ASSEMBLER, ASM_R_M_b64) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_M); EXPECT_EQ(addr, 0); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_R_IMM_b8) { @@ -339,7 +335,7 @@ TEST_F(ASSEMBLER, ASM_R_IMM_b8) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); EXPECT_EQ(num, 16); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::XLLL0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::XLLL0); } TEST_F(ASSEMBLER, ASM_R_IMM_b16) { @@ -365,7 +361,7 @@ TEST_F(ASSEMBLER, ASM_R_IMM_b16) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); EXPECT_EQ(num, 16); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::XLL0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::XLL0); } TEST_F(ASSEMBLER, ASM_R_IMM_b32) { @@ -391,7 +387,7 @@ TEST_F(ASSEMBLER, ASM_R_IMM_b32) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); EXPECT_EQ(num, 16); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::XL0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::XL0); } TEST_F(ASSEMBLER, ASM_R_IMM_b64) { @@ -417,7 +413,7 @@ TEST_F(ASSEMBLER, ASM_R_IMM_b64) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); EXPECT_EQ(num, 16); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_RM_R_b8) { @@ -442,8 +438,8 @@ TEST_F(ASSEMBLER, ASM_RM_R_b8) { EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_R); - EXPECT_EQ(static_cast(reg1), HyperCPU::Registers::X0); - EXPECT_EQ(static_cast(reg2), HyperCPU::Registers::XLLL1); + EXPECT_EQ(static_cast(reg1), HyperCPU::Reg::X0); + EXPECT_EQ(static_cast(reg2), HyperCPU::Reg::XLLL1); } TEST_F(ASSEMBLER, ASM_RM_R_b16) { @@ -468,8 +464,8 @@ TEST_F(ASSEMBLER, ASM_RM_R_b16) { EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_R); - EXPECT_EQ(static_cast(reg1), HyperCPU::Registers::X0); - EXPECT_EQ(static_cast(reg2), HyperCPU::Registers::XLL1); + EXPECT_EQ(static_cast(reg1), HyperCPU::Reg::X0); + EXPECT_EQ(static_cast(reg2), HyperCPU::Reg::XLL1); } TEST_F(ASSEMBLER, ASM_RM_R_b32) { @@ -494,8 +490,8 @@ TEST_F(ASSEMBLER, ASM_RM_R_b32) { EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_R); - EXPECT_EQ(static_cast(reg1), HyperCPU::Registers::X0); - EXPECT_EQ(static_cast(reg2), HyperCPU::Registers::XL1); + EXPECT_EQ(static_cast(reg1), HyperCPU::Reg::X0); + EXPECT_EQ(static_cast(reg2), HyperCPU::Reg::XL1); } TEST_F(ASSEMBLER, ASM_RM_R_b64) { @@ -520,8 +516,8 @@ TEST_F(ASSEMBLER, ASM_RM_R_b64) { EXPECT_EQ(flags & 0b11000000, 0); EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_R); - EXPECT_EQ(static_cast(reg1), HyperCPU::Registers::X0); - EXPECT_EQ(static_cast(reg2), HyperCPU::Registers::X1); + EXPECT_EQ(static_cast(reg1), HyperCPU::Reg::X0); + EXPECT_EQ(static_cast(reg2), HyperCPU::Reg::X1); } TEST_F(ASSEMBLER, ASM_RM_M_b8) { @@ -547,7 +543,7 @@ TEST_F(ASSEMBLER, ASM_RM_M_b8) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_M); EXPECT_EQ(addr, 0); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_RM_M_b16) { @@ -573,7 +569,7 @@ TEST_F(ASSEMBLER, ASM_RM_M_b16) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_M); EXPECT_EQ(addr, 0); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_RM_M_b32) { @@ -599,7 +595,7 @@ TEST_F(ASSEMBLER, ASM_RM_M_b32) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_M); EXPECT_EQ(addr, 0); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_RM_M_b64) { @@ -625,7 +621,7 @@ TEST_F(ASSEMBLER, ASM_RM_M_b64) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_M); EXPECT_EQ(addr, 0); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_RM_IMM_b8) { @@ -651,7 +647,7 @@ TEST_F(ASSEMBLER, ASM_RM_IMM_b8) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_IMM); EXPECT_EQ(num, 16); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_RM_IMM_b16) { @@ -677,7 +673,7 @@ TEST_F(ASSEMBLER, ASM_RM_IMM_b16) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_IMM); EXPECT_EQ(num, 16); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_RM_IMM_b32) { @@ -703,7 +699,7 @@ TEST_F(ASSEMBLER, ASM_RM_IMM_b32) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_IMM); EXPECT_EQ(num, 16); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_RM_IMM_b64) { @@ -729,7 +725,7 @@ TEST_F(ASSEMBLER, ASM_RM_IMM_b64) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::RM_IMM); EXPECT_EQ(num, 16); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_M_R_b8) { @@ -755,7 +751,7 @@ TEST_F(ASSEMBLER, ASM_M_R_b8) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b8); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::M_R); EXPECT_EQ(addr, 0); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::XLLL1); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::XLLL1); } TEST_F(ASSEMBLER, ASM_M_R_b16) { @@ -781,7 +777,7 @@ TEST_F(ASSEMBLER, ASM_M_R_b16) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b16); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::M_R); EXPECT_EQ(addr, 0); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::XLL1); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::XLL1); } TEST_F(ASSEMBLER, ASM_M_R_b32) { @@ -807,7 +803,7 @@ TEST_F(ASSEMBLER, ASM_M_R_b32) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b32); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::M_R); EXPECT_EQ(addr, 0); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::XL1); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::XL1); } TEST_F(ASSEMBLER, ASM_M_R_b64) { @@ -833,7 +829,7 @@ TEST_F(ASSEMBLER, ASM_M_R_b64) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::M_R); EXPECT_EQ(addr, 0); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X1); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X1); } TEST_F(ASSEMBLER, ASM_IMM_b64) { @@ -882,7 +878,7 @@ TEST_F(ASSEMBLER, ASM_REFERENCE_LABEL) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); EXPECT_EQ(num, 5); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_REFERENCE_ENTRY_LABEL) { @@ -908,7 +904,7 @@ TEST_F(ASSEMBLER, ASM_REFERENCE_ENTRY_LABEL) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); EXPECT_EQ(num, 5); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_COMPILE) { @@ -933,7 +929,7 @@ TEST_F(ASSEMBLER, ASM_COMPILE) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); EXPECT_EQ(num, 5); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); } TEST_F(ASSEMBLER, ASM_b8_str_DIRECTIVE) { @@ -1015,5 +1011,5 @@ TEST_F(ASSEMBLER, ASM_ENTRY_LABEL) { EXPECT_EQ(static_cast((flags & 0b00110000) >> 4), HyperCPU::Mode::b64); EXPECT_EQ(static_cast(flags & 0b00001111), HyperCPU::OperandTypes::R_IMM); EXPECT_EQ(num, 5); - EXPECT_EQ(static_cast(reg), HyperCPU::Registers::X0); -} \ No newline at end of file + EXPECT_EQ(static_cast(reg), HyperCPU::Reg::X0); +} diff --git a/tests/Integration/AssemblerCore/FullAssembler.cpp b/tests/Integration/AssemblerCore/FullAssembler.cpp index 538df6a5..33376b33 100644 --- a/tests/Integration/AssemblerCore/FullAssembler.cpp +++ b/tests/Integration/AssemblerCore/FullAssembler.cpp @@ -1,7 +1,5 @@ -#include "Main/Main.hpp" -#include "Misc/bit_cast.hpp" -#include "pch.hpp" -#include +#include "tests/fixtures.hpp" + TEST_F(FULL_ASSEMBLER, MULTUPLE_INSTRUCTIONS) { std::string data = "_start:\n\tmov x0, 0u1;\n\tmov x1, 0u2;\n\tadd x0, x1;"; @@ -28,19 +26,19 @@ TEST_F(FULL_ASSEMBLER, MULTUPLE_INSTRUCTIONS) { input.read(buf, code_size); ASSERT_EQ(HyperCPU::bit_cast_from(buf), HyperCPU::Opcode::MOV); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 2), (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 3), HyperCPU::Registers::X0); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 2), (static_cast(HyperCPU::Mode::b64) << 4) | static_cast(HyperCPU::OperandTypes::R_IMM)); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 3), HyperCPU::Reg::X0); ASSERT_EQ(HyperCPU::bit_cast_from(buf + 4), 1); ASSERT_EQ(HyperCPU::bit_cast_from(buf + 12), HyperCPU::Opcode::MOV); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 14), (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 15), HyperCPU::Registers::X1); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 14), (static_cast(HyperCPU::Mode::b64) << 4) | static_cast(HyperCPU::OperandTypes::R_IMM)); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 15), HyperCPU::Reg::X1); ASSERT_EQ(HyperCPU::bit_cast_from(buf + 16), 2); ASSERT_EQ(HyperCPU::bit_cast_from(buf + 24), HyperCPU::Opcode::ADD); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 26), (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 27), HyperCPU::Registers::X0); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 28), HyperCPU::Registers::X1); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 26), (static_cast(HyperCPU::Mode::b64) << 4) | static_cast(HyperCPU::OperandTypes::R_R)); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 27), HyperCPU::Reg::X0); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 28), HyperCPU::Reg::X1); delete[] buf; } @@ -70,17 +68,17 @@ TEST_F(FULL_ASSEMBLER, IRET) { input.read(buf, code_size); ASSERT_EQ(HyperCPU::bit_cast_from(buf), HyperCPU::Opcode::MOV); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 2), (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 3), HyperCPU::Registers::XBP); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 2), (static_cast(HyperCPU::Mode::b64) << 4) | static_cast(HyperCPU::OperandTypes::R_IMM)); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 3), HyperCPU::Reg::XBP); ASSERT_EQ(HyperCPU::bit_cast_from(buf + 4), 512); ASSERT_EQ(HyperCPU::bit_cast_from(buf + 12), HyperCPU::Opcode::MOV); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 14), (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 15), HyperCPU::Registers::XSP); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 16), HyperCPU::Registers::XBP); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 14), (static_cast(HyperCPU::Mode::b64) << 4) | static_cast(HyperCPU::OperandTypes::R_R)); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 15), HyperCPU::Reg::XSP); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 16), HyperCPU::Reg::XBP); ASSERT_EQ(HyperCPU::bit_cast_from(buf + 17), HyperCPU::Opcode::PUSH); - ASSERT_EQ(HyperCPU::bit_cast_from(buf + 19), (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + ASSERT_EQ(HyperCPU::bit_cast_from(buf + 19), (static_cast(HyperCPU::Mode::b64) << 4) | static_cast(HyperCPU::OperandTypes::IMM)); ASSERT_EQ(HyperCPU::bit_cast_from(buf + 20), 30); ASSERT_EQ(HyperCPU::bit_cast_from(buf + 28), HyperCPU::Opcode::IRET); diff --git a/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp b/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp index e56b64c8..a14e7dc8 100644 --- a/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp +++ b/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp @@ -1,5 +1,5 @@ -#include "pch.hpp" -#include +#include "tests/fixtures.hpp" + TEST_F(TWO_OPERANDS_SUCCESS, OPERANDS_R_R_b8) { std::string data = "mov xlll0, xlll1;"; diff --git a/tests/Integration/BUILD.bazel b/tests/Integration/BUILD.bazel new file mode 100644 index 00000000..0e5f6a98 --- /dev/null +++ b/tests/Integration/BUILD.bazel @@ -0,0 +1,11 @@ +# load('@rules_cc//cc:defs.bzl', 'cc_test') + + +# cc_test( +# name = 'integration-test', +# srcs = glob(['**/*.cpp']), +# deps = [ +# '//tests:pch_gtest', +# '@gtest//:gtest_main_precompiled' +# ] +# ) diff --git a/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp b/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp index 58672e59..f6929e41 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp @@ -1,7 +1,5 @@ -#include -#include +#include "tests/fixtures.hpp" -#include static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; @@ -31,9 +29,9 @@ static constexpr std::uint64_t QWORD_SUM_OF = QWORD_DATA1_OF + QWORD_DATA2_OF + TEST_F(CPU_TEST, INSTR_ADC_R_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -47,9 +45,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b8) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -63,9 +61,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b16) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -79,9 +77,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b32) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -95,9 +93,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b64) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -112,9 +110,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b8) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -129,9 +127,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b16) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -146,9 +144,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b32) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -163,8 +161,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b64) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -179,8 +177,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b8) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -195,8 +193,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b16) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -211,8 +209,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b32) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -227,8 +225,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b64) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -242,8 +240,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b8) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -257,8 +255,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b16) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -272,8 +270,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b32) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -287,9 +285,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b64) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1_OF; @@ -304,9 +302,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b8_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1_OF; @@ -321,9 +319,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b16_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1_OF; @@ -338,9 +336,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b32_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1_OF; @@ -355,9 +353,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b64_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1_OF; @@ -373,9 +371,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b8_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1_OF; @@ -391,9 +389,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b16_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1_OF; @@ -409,9 +407,9 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b32_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1_OF; @@ -427,8 +425,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b64_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -444,8 +442,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b8_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -461,8 +459,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b16_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -478,8 +476,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b32_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -495,8 +493,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b64_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -511,8 +509,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b8_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -527,8 +525,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b16_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -543,8 +541,8 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b32_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp b/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp index dffe8859..4e76b75e 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp @@ -1,7 +1,5 @@ -#include -#include +#include "tests/fixtures.hpp" -#include static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; @@ -31,9 +29,9 @@ static constexpr std::uint64_t QWORD_SUM_OF = QWORD_DATA1_OF + QWORD_DATA2_OF; TEST_F(CPU_TEST, INSTR_ADD_R_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -46,9 +44,9 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b8) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -61,9 +59,9 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b16) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -76,9 +74,9 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b32) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -91,9 +89,9 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b64) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -107,9 +105,9 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b8) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -123,9 +121,9 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b16) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -139,9 +137,9 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b32) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -155,8 +153,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b64) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -170,8 +168,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b8) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -185,8 +183,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b16) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -200,8 +198,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b32) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -215,8 +213,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b64) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -229,8 +227,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b8) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -243,8 +241,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b16) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -257,8 +255,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b32) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -272,8 +270,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b64) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1_OF; @@ -288,8 +286,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b8_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1_OF; @@ -304,8 +302,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b16_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1_OF; @@ -320,8 +318,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b32_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1_OF; @@ -336,8 +334,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b64_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1_OF; @@ -353,8 +351,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b8_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1_OF; @@ -370,8 +368,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b16_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1_OF; @@ -387,8 +385,8 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b32_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1_OF; @@ -404,7 +402,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b64_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -420,7 +418,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b8_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -436,7 +434,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b16_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -452,7 +450,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b32_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -468,7 +466,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b64_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -483,7 +481,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b8_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -498,7 +496,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b16_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -513,7 +511,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b32_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp b/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp index c5480ca0..49d6641e 100644 --- a/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp +++ b/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp @@ -1,7 +1,5 @@ -#include -#include +#include "tests/fixtures.hpp" -#include TEST_F(EXCEPTION_TEST, CPU_EXCEPTION_IO) { cpu.mem_controller->Load16(*cpu.xip, 8273); @@ -12,9 +10,9 @@ TEST_F(EXCEPTION_TEST, CPU_EXCEPTION_IO) { } TEST_F(EXCEPTION_TEST, CPU_EXCEPTION_ZRDIV) { - cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DIV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load16(*cpu.xip, static_cast(HyperCPU::Opcode::DIV)); + cpu.mem_controller->Load8(*cpu.xip + 2, (static_cast(HyperCPU::Mode::b8) << 4) | static_cast(HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, static_cast(HyperCPU::Reg::XLLL0)); *cpu.xlll0 = 0x55; *cpu.x2 = 0; diff --git a/tests/Pog/Automaton.cpp b/tests/Pog/Automaton.cpp index 1796ed9b..c1db89c6 100644 --- a/tests/Pog/Automaton.cpp +++ b/tests/Pog/Automaton.cpp @@ -1,8 +1,8 @@ -#include +#include "Pog/Automaton.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" -#include using namespace pog; diff --git a/tests/Pog/BUILD.bazel b/tests/Pog/BUILD.bazel new file mode 100644 index 00000000..77ff00fa --- /dev/null +++ b/tests/Pog/BUILD.bazel @@ -0,0 +1,14 @@ +load('@rules_cc//cc:defs.bzl', 'cc_test') + +cc_test( + name = 'test-pog', + srcs = glob(['**/*.cpp']), + deps = [ + '//tests:pch_gtest', + '//src/PCH:pch_cstd', + '//src/Pog:pog', + '@gtest//:gtest-gmock_main', + '@re2//:re2', + '@fmt//:fmt' + ] +) diff --git a/tests/Pog/FilterView.cpp b/tests/Pog/FilterView.cpp index 88624ac5..90862179 100644 --- a/tests/Pog/FilterView.cpp +++ b/tests/Pog/FilterView.cpp @@ -1,6 +1,7 @@ -#include +#include "Pog/FilterView.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" class TestFilterView : public ::testing::Test {}; diff --git a/tests/Pog/Grammar.cpp b/tests/Pog/Grammar.cpp index 3fb1d576..b63f26c0 100644 --- a/tests/Pog/Grammar.cpp +++ b/tests/Pog/Grammar.cpp @@ -1,6 +1,8 @@ -#include +#include "Pog/Grammar.hpp" + +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" -#include using namespace pog; diff --git a/tests/Pog/Item.cpp b/tests/Pog/Item.cpp index b1251bef..7c0e85ef 100644 --- a/tests/Pog/Item.cpp +++ b/tests/Pog/Item.cpp @@ -1,6 +1,8 @@ -#include +#include "Pog/Item.hpp" + +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" -#include using namespace pog; diff --git a/tests/Pog/Parser.cpp b/tests/Pog/Parser.cpp index cdc6922b..cb70586f 100644 --- a/tests/Pog/Parser.cpp +++ b/tests/Pog/Parser.cpp @@ -1,6 +1,8 @@ -#include +#include "Pog/Parser.hpp" + +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" -#include using namespace pog; using namespace ::testing; diff --git a/tests/Pog/ParsingTable.cpp b/tests/Pog/ParsingTable.cpp index 2e87e1b6..ac7f0033 100644 --- a/tests/Pog/ParsingTable.cpp +++ b/tests/Pog/ParsingTable.cpp @@ -1,6 +1,7 @@ -#include +#include "Pog/ParsingTable.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" using namespace pog; diff --git a/tests/Pog/PogTests.cpp b/tests/Pog/PogTests.cpp deleted file mode 100644 index 697a9d70..00000000 --- a/tests/Pog/PogTests.cpp +++ /dev/null @@ -1,6 +0,0 @@ -#include - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); -} diff --git a/tests/Pog/Precedence.cpp b/tests/Pog/Precedence.cpp index b729a64f..d2f81ce4 100644 --- a/tests/Pog/Precedence.cpp +++ b/tests/Pog/Precedence.cpp @@ -1,6 +1,7 @@ -#include +#include "Pog/Precedence.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" class TestPrecedence : public ::testing::Test {}; diff --git a/tests/Pog/Rule.cpp b/tests/Pog/Rule.cpp index f8656028..5d175b6d 100644 --- a/tests/Pog/Rule.cpp +++ b/tests/Pog/Rule.cpp @@ -1,6 +1,7 @@ -#include +#include "Pog/Rule.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" class TestRule : public ::testing::Test {}; diff --git a/tests/Pog/RuleBuilder.cpp b/tests/Pog/RuleBuilder.cpp index b71be55e..49ae793c 100644 --- a/tests/Pog/RuleBuilder.cpp +++ b/tests/Pog/RuleBuilder.cpp @@ -1,6 +1,7 @@ -#include +#include "Pog/RuleBuilder.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" using namespace pog; diff --git a/tests/Pog/State.cpp b/tests/Pog/State.cpp index dd936a59..a1850950 100644 --- a/tests/Pog/State.cpp +++ b/tests/Pog/State.cpp @@ -1,6 +1,7 @@ -#include +#include "Pog/State.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" using namespace pog; using namespace ::testing; diff --git a/tests/Pog/Symbol.cpp b/tests/Pog/Symbol.cpp index cf65c8e8..a75f9604 100644 --- a/tests/Pog/Symbol.cpp +++ b/tests/Pog/Symbol.cpp @@ -1,6 +1,7 @@ -#include +#include "Pog/Symbol.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" class TestSymbol : public ::testing::Test {}; diff --git a/tests/Pog/Token.cpp b/tests/Pog/Token.cpp index 1c19925f..3bc40e5f 100644 --- a/tests/Pog/Token.cpp +++ b/tests/Pog/Token.cpp @@ -1,6 +1,7 @@ -#include +#include "Pog/Token.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" using namespace pog; using namespace ::testing; diff --git a/tests/Pog/TokenBuilder.cpp b/tests/Pog/TokenBuilder.cpp index 1d16e831..9895d54f 100644 --- a/tests/Pog/TokenBuilder.cpp +++ b/tests/Pog/TokenBuilder.cpp @@ -1,6 +1,7 @@ -#include +#include "Pog/TokenBuilder.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" using namespace pog; diff --git a/tests/Pog/Tokenizer.cpp b/tests/Pog/Tokenizer.cpp index 7ebfcea6..62e2b865 100644 --- a/tests/Pog/Tokenizer.cpp +++ b/tests/Pog/Tokenizer.cpp @@ -1,6 +1,7 @@ -#include +#include "Pog/Tokenizer.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" using namespace pog; diff --git a/tests/Pog/Utils.cpp b/tests/Pog/Utils.cpp index a012da50..0eaae892 100644 --- a/tests/Pog/Utils.cpp +++ b/tests/Pog/Utils.cpp @@ -1,6 +1,7 @@ -#include +#include "Pog/Utils.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" class TestUtils : public ::testing::Test {}; diff --git a/tests/fixtures.hpp b/tests/fixtures.hpp index 2b94bdf3..7774e2c3 100644 --- a/tests/fixtures.hpp +++ b/tests/fixtures.hpp @@ -1,18 +1,16 @@ #pragma once -#include -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" #define private public -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "Assembler/Core/Compiler.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" +#include "Emulator/Core/MemoryController/MemoryControllerST.hpp" +#undef private static constexpr std::uint64_t MEM_SIZE = 4096; static constexpr std::uint64_t MEM_FIXTURE_MEM_SIZE = 1024; @@ -91,32 +89,29 @@ class DECODER_TEST : public ::testing::Test { class CPU_TEST : public ::testing::Test { protected: - HyperCPU::Logger logger; HyperCPU::CPU cpu; CPU_TEST() - : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { + : cpu(1, 4096) { } }; class OPERAND_EVAL_TEST : public ::testing::Test { protected: - HyperCPU::Logger logger; HyperCPU::CPU cpu; std::pair result; OPERAND_EVAL_TEST() - : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { + : cpu(1, 4096) { } }; class STACK_TEST : public ::testing::Test { protected: - HyperCPU::Logger logger; HyperCPU::CPU cpu; STACK_TEST() - : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { + : cpu(1, 4096) { *cpu.xbp = 1024; *cpu.xsp = 1024; } @@ -124,21 +119,19 @@ class STACK_TEST : public ::testing::Test { class IVT_INIT_TEST : public ::testing::Test { protected: - HyperCPU::Logger logger; HyperCPU::CPU cpu; IVT_INIT_TEST() - : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { + : cpu(1, 4096) { } }; class EXCEPTION_TEST : public ::testing::Test { protected: - HyperCPU::Logger logger; HyperCPU::CPU cpu; EXCEPTION_TEST() - : logger(HyperCPU::LogLevel::ERROR), cpu(1, 4096) { + : cpu(1, 4096) { } virtual void SetUp() { @@ -148,8 +141,8 @@ class EXCEPTION_TEST : public ::testing::Test { cpu.mem_controller->Load64(2048, 1536); cpu.mem_controller->Load64(2056, 1536); cpu.mem_controller->Load64(2064, 1536); - cpu.mem_controller->Load64(1536, HyperCPU::Opcode::HALT); - cpu.mem_controller->Load64(1538, HyperCPU::OperandTypes::NONE); + cpu.mem_controller->Load64(1536, static_cast(HyperCPU::Opcode::HALT)); + cpu.mem_controller->Load64(1538, static_cast(HyperCPU::OperandTypes::NONE)); cpu.ivt_initialized = true; } }; @@ -161,7 +154,7 @@ class ASM_PARSER_TEST : public ::testing::Test { pog::Parser& parser; ASM_PARSER_TEST() - : compiler(HyperCPU::LogLevel::ERROR), _state(compiler.pool), parser(compiler.parser) { + : compiler(), _state(compiler.pool), parser(compiler.parser) { parser.set_compiler_state(&_state); } }; @@ -171,7 +164,7 @@ class ASM_PARSER_STMT_TEST : public ::testing::Test { HCAsm::HCAsmCompiler compiler; ASM_PARSER_STMT_TEST() - : compiler(HyperCPU::LogLevel::ERROR) { + : compiler() { } virtual void TearDown() { @@ -184,7 +177,7 @@ class ASSEMBLER : public ::testing::Test { HCAsm::HCAsmCompiler compiler; ASSEMBLER() - : compiler(HyperCPU::LogLevel::ERROR) { + : compiler() { } virtual void TearDown() { @@ -198,7 +191,7 @@ class FULL_ASSEMBLER : public ::testing::Test { TempDir dir; FULL_ASSEMBLER() - : compiler(HyperCPU::LogLevel::ERROR), dir(::testing::UnitTest::GetInstance()->current_test_info()->test_case_name()) { + : compiler(), dir(::testing::UnitTest::GetInstance()->current_test_info()->test_case_name()) { } virtual void TearDown() { @@ -211,7 +204,7 @@ class TWO_OPERANDS_SUCCESS : public ::testing::Test { HCAsm::HCAsmCompiler compiler; TWO_OPERANDS_SUCCESS() - : compiler(HyperCPU::LogLevel::ERROR) { + : compiler() { } virtual void TearDown() { @@ -224,7 +217,7 @@ class TWO_OPERANDS_FAILURE : public ::testing::Test { HCAsm::HCAsmCompiler compiler; TWO_OPERANDS_FAILURE() - : compiler(HyperCPU::LogLevel::ERROR) { + : compiler() { } virtual void TearDown() { diff --git a/tests/gtest.hpp b/tests/gtest.hpp new file mode 100644 index 00000000..4829be8f --- /dev/null +++ b/tests/gtest.hpp @@ -0,0 +1,3 @@ +/* precompiled gtest header, used by our unit & integration tests */ +#include +#include diff --git a/tests/main.cpp b/tests/main.cpp deleted file mode 100644 index 5863b3eb..00000000 --- a/tests/main.cpp +++ /dev/null @@ -1,8 +0,0 @@ -#include "pch.hpp" -#include - -int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); - - return RUN_ALL_TESTS(); -} From 63312ca221d752d936165327b674ba9e5f4e379d Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 03:08:26 +0300 Subject: [PATCH 10/40] bazelrc --- .bazelrc | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/.bazelrc b/.bazelrc index 2bce9d49..4b2bcc38 100644 --- a/.bazelrc +++ b/.bazelrc @@ -40,3 +40,13 @@ build:linux-opt --cxxopt=-O3 # ---------------------------- # Distro-specific configurations +# ... + +# --- Testing --- +# Linux, Debug +test:linux --config=dbg-linux +# Verbose output +test:linux --test_summary=detailed +# Stream test results to stdout +test:linux --test_output=streamed +# --------------- From 42eda09180fa119ed53f9926adb902ff19a8977c Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 03:11:48 +0300 Subject: [PATCH 11/40] add wget --- docker/debian-stable/Dockerfile | 2 +- docker/debian-unstable/Dockerfile | 2 +- docker/ubuntu/Dockerfile | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docker/debian-stable/Dockerfile b/docker/debian-stable/Dockerfile index a48e29d8..dbdb81af 100644 --- a/docker/debian-stable/Dockerfile +++ b/docker/debian-stable/Dockerfile @@ -1,7 +1,7 @@ FROM debian:latest RUN apt-get update && apt-get install -y --no-install-recommends \ - git cmake clang libre2-9 libre2-dev python3 python3-pip make gcc g++ \ + git cmake clang libre2-9 libre2-dev python3 python3-pip wget make gcc g++ \ && pip3 install --no-cache-dir --break-system-packages conan \ && rm -rf /var/lib/apt/lists/* diff --git a/docker/debian-unstable/Dockerfile b/docker/debian-unstable/Dockerfile index 5eb9ae9a..dfcfd48a 100644 --- a/docker/debian-unstable/Dockerfile +++ b/docker/debian-unstable/Dockerfile @@ -1,7 +1,7 @@ FROM debian:unstable RUN apt-get update && apt-get install -y --no-install-recommends \ - git cmake clang libre2-11 libre2-dev python3 python3-pip make gcc g++ \ + git cmake clang libre2-11 libre2-dev python3 python3-pip wget make gcc g++ \ && pip3 install --no-cache-dir --break-system-packages conan \ && rm -rf /var/lib/apt/lists/* diff --git a/docker/ubuntu/Dockerfile b/docker/ubuntu/Dockerfile index d5d6705d..96934583 100644 --- a/docker/ubuntu/Dockerfile +++ b/docker/ubuntu/Dockerfile @@ -1,7 +1,7 @@ FROM ubuntu:latest RUN apt update && apt install -y --no-install-recommends \ - git cmake clang libre2-10 libre2-dev python3 python3-pip make gcc g++ \ + git cmake clang libre2-10 libre2-dev python3 python3-pip wget make gcc g++ \ && pip3 install --no-cache-dir --break-system-packages conan \ && rm -rf /var/lib/apt/lists/* From 1bf9792dc2efde8a4ad05ecfe7f07dfbcdc97599 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 03:18:26 +0300 Subject: [PATCH 12/40] add missing args --- docker/debian-stable/Dockerfile | 3 +++ docker/debian-unstable/Dockerfile | 3 +++ docker/ubuntu/Dockerfile | 3 +++ 3 files changed, 9 insertions(+) diff --git a/docker/debian-stable/Dockerfile b/docker/debian-stable/Dockerfile index dbdb81af..42f63bff 100644 --- a/docker/debian-stable/Dockerfile +++ b/docker/debian-stable/Dockerfile @@ -1,5 +1,8 @@ FROM debian:latest +ARG USER=bazel +ARG BAZELISK_TAG=v1.15.0 + RUN apt-get update && apt-get install -y --no-install-recommends \ git cmake clang libre2-9 libre2-dev python3 python3-pip wget make gcc g++ \ && pip3 install --no-cache-dir --break-system-packages conan \ diff --git a/docker/debian-unstable/Dockerfile b/docker/debian-unstable/Dockerfile index dfcfd48a..e80c3e1d 100644 --- a/docker/debian-unstable/Dockerfile +++ b/docker/debian-unstable/Dockerfile @@ -1,5 +1,8 @@ FROM debian:unstable +ARG USER=bazel +ARG BAZELISK_TAG=v1.15.0 + RUN apt-get update && apt-get install -y --no-install-recommends \ git cmake clang libre2-11 libre2-dev python3 python3-pip wget make gcc g++ \ && pip3 install --no-cache-dir --break-system-packages conan \ diff --git a/docker/ubuntu/Dockerfile b/docker/ubuntu/Dockerfile index 96934583..86ea81ae 100644 --- a/docker/ubuntu/Dockerfile +++ b/docker/ubuntu/Dockerfile @@ -1,5 +1,8 @@ FROM ubuntu:latest +ARG USER=bazel +ARG BAZELISK_TAG=v1.15.0 + RUN apt update && apt install -y --no-install-recommends \ git cmake clang libre2-10 libre2-dev python3 python3-pip wget make gcc g++ \ && pip3 install --no-cache-dir --break-system-packages conan \ From f9b5a6e889af3aeb88e61939ad4a49ccf23fe72d Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 03:50:45 +0300 Subject: [PATCH 13/40] midnight fixes --- docker/archlinux/Dockerfile | 8 +++++--- docker/debian-stable/Dockerfile | 8 +++++--- docker/debian-unstable/Dockerfile | 8 +++++--- docker/ubuntu/Dockerfile | 8 +++++--- src/Pog/BUILD.bazel | 6 +++++- 5 files changed, 25 insertions(+), 13 deletions(-) diff --git a/docker/archlinux/Dockerfile b/docker/archlinux/Dockerfile index bcb0397a..48a0c6d0 100644 --- a/docker/archlinux/Dockerfile +++ b/docker/archlinux/Dockerfile @@ -4,7 +4,7 @@ ARG USER=bazel ARG BAZELISK_TAG=v1.15.0 RUN pacman -Syu --noconfirm --needed \ - python python-pip git clang gcc \ + python python-pip git cmake clang gcc \ base-devel wget \ && pip install --no-cache-dir --break-system-packages conan \ && pacman -Scc --noconfirm @@ -13,7 +13,9 @@ RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG chmod 755 bazelisk-linux-amd64 && \ mv bazelisk-linux-amd64 /usr/bin/bazelisk -RUN useradd -m ${USER} +RUN useradd -m ${USER} && \ + mkdir /home/${USER}/workspace && \ + chown ${USER}:${USER} /home/${USER}/workspace -WORKDIR /home/${USER}/workspace USER ${USER} +WORKDIR /home/${USER}/workspace diff --git a/docker/debian-stable/Dockerfile b/docker/debian-stable/Dockerfile index 42f63bff..045c3280 100644 --- a/docker/debian-stable/Dockerfile +++ b/docker/debian-stable/Dockerfile @@ -4,7 +4,7 @@ ARG USER=bazel ARG BAZELISK_TAG=v1.15.0 RUN apt-get update && apt-get install -y --no-install-recommends \ - git cmake clang libre2-9 libre2-dev python3 python3-pip wget make gcc g++ \ + git cmake clang libre2-9 libre2-dev python3 python3-pip cmake wget make gcc g++ \ && pip3 install --no-cache-dir --break-system-packages conan \ && rm -rf /var/lib/apt/lists/* @@ -12,7 +12,9 @@ RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG chmod 755 bazelisk-linux-amd64 && \ mv bazelisk-linux-amd64 /usr/bin/bazelisk -RUN useradd -m ${USER} +RUN useradd -m ${USER} && \ + mkdir /home/${USER}/workspace && \ + chown ${USER}:${USER} /home/${USER}/workspace -WORKDIR /home/${USER}/workspace USER ${USER} +WORKDIR /home/${USER}/workspace diff --git a/docker/debian-unstable/Dockerfile b/docker/debian-unstable/Dockerfile index e80c3e1d..ce0335e6 100644 --- a/docker/debian-unstable/Dockerfile +++ b/docker/debian-unstable/Dockerfile @@ -4,7 +4,7 @@ ARG USER=bazel ARG BAZELISK_TAG=v1.15.0 RUN apt-get update && apt-get install -y --no-install-recommends \ - git cmake clang libre2-11 libre2-dev python3 python3-pip wget make gcc g++ \ + git cmake clang libre2-11 libre2-dev python3 python3-pip cmake wget make gcc g++ \ && pip3 install --no-cache-dir --break-system-packages conan \ && rm -rf /var/lib/apt/lists/* @@ -12,7 +12,9 @@ RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG chmod 755 bazelisk-linux-amd64 && \ mv bazelisk-linux-amd64 /usr/bin/bazelisk -RUN useradd -m ${USER} +RUN useradd -m ${USER} && \ + mkdir /home/${USER}/workspace && \ + chown ${USER}:${USER} /home/${USER}/workspace -WORKDIR /home/${USER}/workspace USER ${USER} +WORKDIR /home/${USER}/workspace diff --git a/docker/ubuntu/Dockerfile b/docker/ubuntu/Dockerfile index 86ea81ae..25c13150 100644 --- a/docker/ubuntu/Dockerfile +++ b/docker/ubuntu/Dockerfile @@ -4,7 +4,7 @@ ARG USER=bazel ARG BAZELISK_TAG=v1.15.0 RUN apt update && apt install -y --no-install-recommends \ - git cmake clang libre2-10 libre2-dev python3 python3-pip wget make gcc g++ \ + git cmake clang libre2-10 libre2-dev python3 python3-pip cmake wget make gcc g++ \ && pip3 install --no-cache-dir --break-system-packages conan \ && rm -rf /var/lib/apt/lists/* @@ -12,7 +12,9 @@ RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG chmod 755 bazelisk-linux-amd64 && \ mv bazelisk-linux-amd64 /usr/bin/bazelisk -RUN useradd -m ${USER} +RUN useradd -m ${USER} && \ + mkdir /home/${USER}/workspace && \ + chown ${USER}:${USER} /home/${USER}/workspace -WORKDIR /home/${USER}/workspace USER ${USER} +WORKDIR /home/${USER}/workspace diff --git a/src/Pog/BUILD.bazel b/src/Pog/BUILD.bazel index b8c26b65..d0ee2d9d 100644 --- a/src/Pog/BUILD.bazel +++ b/src/Pog/BUILD.bazel @@ -9,7 +9,11 @@ package( cc_library( name = 'pog_core', - hdrs = glob(['**/*.hpp'], exclude = ['Pog.hpp']) + hdrs = glob(['**/*.hpp'], exclude = ['Pog.hpp']), + deps = [ + '@re2//:re2', + '@fmt//:fmt' + ] ) precompiled_headers( From 03cc487176b96811a42de59fe0fb7704a5576c39 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 03:55:12 +0300 Subject: [PATCH 14/40] try this --- .bazelignore | 2 ++ src/Emulator/Core/MemoryController/IMemoryController.hpp | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 .bazelignore diff --git a/.bazelignore b/.bazelignore new file mode 100644 index 00000000..abb3484b --- /dev/null +++ b/.bazelignore @@ -0,0 +1,2 @@ +# Conan packages cannot be built directly +conan/ diff --git a/src/Emulator/Core/MemoryController/IMemoryController.hpp b/src/Emulator/Core/MemoryController/IMemoryController.hpp index 5aaeed13..8afb4aca 100644 --- a/src/Emulator/Core/MemoryController/IMemoryController.hpp +++ b/src/Emulator/Core/MemoryController/IMemoryController.hpp @@ -52,7 +52,7 @@ namespace HyperCPU { template void HyperCPU::IMemoryController::Load8(std::uint64_t address, T value) { - using ActualFrom = std::conditional_t, std::underlying_type_t, T>; + using ActualFrom = std::conditional_t, typename std::underlying_type_t, T>; static_assert(std::is_convertible_v, "Value must be convertable to integer type"); load8(address, static_cast(value)); From 69f4b4c566c521812333251f9c6022c2e31e88f1 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 03:56:42 +0300 Subject: [PATCH 15/40] it broke my build --- .bazelignore | 2 -- 1 file changed, 2 deletions(-) delete mode 100644 .bazelignore diff --git a/.bazelignore b/.bazelignore deleted file mode 100644 index abb3484b..00000000 --- a/.bazelignore +++ /dev/null @@ -1,2 +0,0 @@ -# Conan packages cannot be built directly -conan/ From 37bf00bba0d63ea19a742e08550ccdc1fa16c562 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 03:59:06 +0300 Subject: [PATCH 16/40] hop this works --- src/Emulator/Core/MemoryController/IMemoryController.hpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Emulator/Core/MemoryController/IMemoryController.hpp b/src/Emulator/Core/MemoryController/IMemoryController.hpp index 8afb4aca..7d13dad4 100644 --- a/src/Emulator/Core/MemoryController/IMemoryController.hpp +++ b/src/Emulator/Core/MemoryController/IMemoryController.hpp @@ -52,7 +52,7 @@ namespace HyperCPU { template void HyperCPU::IMemoryController::Load8(std::uint64_t address, T value) { - using ActualFrom = std::conditional_t, typename std::underlying_type_t, T>; + using ActualFrom = std::conditional_t, typename std::underlying_type_t::type, T>; static_assert(std::is_convertible_v, "Value must be convertable to integer type"); load8(address, static_cast(value)); @@ -60,7 +60,7 @@ void HyperCPU::IMemoryController::Load8(std::uint64_t address, T value) { template void HyperCPU::IMemoryController::Load16(std::uint64_t address, T value) { - using ActualFrom = std::conditional_t, std::underlying_type_t, T>; + using ActualFrom = std::conditional_t, typename std::underlying_type_t::type, T>; static_assert(std::is_convertible_v, "Value must be convertable to integer type"); load16(address, static_cast(value)); @@ -68,7 +68,7 @@ void HyperCPU::IMemoryController::Load16(std::uint64_t address, T value) { template void HyperCPU::IMemoryController::Load32(std::uint64_t address, T value) { - using ActualFrom = std::conditional_t, std::underlying_type_t, T>; + using ActualFrom = std::conditional_t, typename std::underlying_type_t::type, T>; static_assert(std::is_convertible_v, "Value must be convertable to integer type"); load32(address, static_cast(value)); @@ -76,7 +76,7 @@ void HyperCPU::IMemoryController::Load32(std::uint64_t address, T value) { template void HyperCPU::IMemoryController::Load64(std::uint64_t address, T value) { - using ActualFrom = std::conditional_t, std::underlying_type_t, T>; + using ActualFrom = std::conditional_t, typename std::underlying_type_t::type, T>; static_assert(std::is_convertible_v, "Value must be convertable to integer type"); load64(address, static_cast(value)); From 8cacf91ad81b5e334121900e834e9a004b09beca Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 04:11:21 +0300 Subject: [PATCH 17/40] i am template god --- .../MemoryController/IMemoryController.hpp | 21 +++++++++++++++---- 1 file changed, 17 insertions(+), 4 deletions(-) diff --git a/src/Emulator/Core/MemoryController/IMemoryController.hpp b/src/Emulator/Core/MemoryController/IMemoryController.hpp index 7d13dad4..1638ff91 100644 --- a/src/Emulator/Core/MemoryController/IMemoryController.hpp +++ b/src/Emulator/Core/MemoryController/IMemoryController.hpp @@ -29,6 +29,19 @@ namespace HyperCPU { virtual std::uint32_t Read32(std::uint64_t) = 0; virtual std::uint64_t Read64(std::uint64_t) = 0; + template + struct loadTypeChooser; + + template + struct loadTypeChooser { + using type = T; + }; + + template + struct loadTypeChooser { + using type = std::underlying_type_t; + }; + template void Load8(std::uint64_t, T); template @@ -52,7 +65,7 @@ namespace HyperCPU { template void HyperCPU::IMemoryController::Load8(std::uint64_t address, T value) { - using ActualFrom = std::conditional_t, typename std::underlying_type_t::type, T>; + using ActualFrom = typename loadTypeChooser, T>::type; static_assert(std::is_convertible_v, "Value must be convertable to integer type"); load8(address, static_cast(value)); @@ -60,7 +73,7 @@ void HyperCPU::IMemoryController::Load8(std::uint64_t address, T value) { template void HyperCPU::IMemoryController::Load16(std::uint64_t address, T value) { - using ActualFrom = std::conditional_t, typename std::underlying_type_t::type, T>; + using ActualFrom = typename loadTypeChooser, T>::type; static_assert(std::is_convertible_v, "Value must be convertable to integer type"); load16(address, static_cast(value)); @@ -68,7 +81,7 @@ void HyperCPU::IMemoryController::Load16(std::uint64_t address, T value) { template void HyperCPU::IMemoryController::Load32(std::uint64_t address, T value) { - using ActualFrom = std::conditional_t, typename std::underlying_type_t::type, T>; + using ActualFrom = typename loadTypeChooser, T>::type; static_assert(std::is_convertible_v, "Value must be convertable to integer type"); load32(address, static_cast(value)); @@ -76,7 +89,7 @@ void HyperCPU::IMemoryController::Load32(std::uint64_t address, T value) { template void HyperCPU::IMemoryController::Load64(std::uint64_t address, T value) { - using ActualFrom = std::conditional_t, typename std::underlying_type_t::type, T>; + using ActualFrom = typename loadTypeChooser, T>::type; static_assert(std::is_convertible_v, "Value must be convertable to integer type"); load64(address, static_cast(value)); From 940dbb5b31e1b2a682934488ee57a4cae9423518 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 04:14:18 +0300 Subject: [PATCH 18/40] gtest --- tests/BUILD.bazel | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tests/BUILD.bazel b/tests/BUILD.bazel index b900864a..0fee7ff9 100644 --- a/tests/BUILD.bazel +++ b/tests/BUILD.bazel @@ -14,5 +14,8 @@ precompiled_headers( cc_library( name = 'test_fixtures', - hdrs = ['fixtures.hpp'] + hdrs = ['fixtures.hpp'], + deps = [ + '@gtest//:gtest-gmock_main' + ] ) From 7ea4d0bb01a14547ee2e8c9cd261d93309ca3bd4 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 04:15:51 +0300 Subject: [PATCH 19/40] i love fixtures --- tests/Pog/BUILD.bazel | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/Pog/BUILD.bazel b/tests/Pog/BUILD.bazel index 77ff00fa..06c9e805 100644 --- a/tests/Pog/BUILD.bazel +++ b/tests/Pog/BUILD.bazel @@ -5,6 +5,7 @@ cc_test( srcs = glob(['**/*.cpp']), deps = [ '//tests:pch_gtest', + '//tests:test_fixtures', '//src/PCH:pch_cstd', '//src/Pog:pog', '@gtest//:gtest-gmock_main', From b2f30b3eed77a1e6303236f5cabd04b39197473b Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 04:17:04 +0300 Subject: [PATCH 20/40] gtest --- tests/BUILD.bazel | 10 +++++----- tests/Pog/BUILD.bazel | 1 - 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/tests/BUILD.bazel b/tests/BUILD.bazel index 0fee7ff9..210a8669 100644 --- a/tests/BUILD.bazel +++ b/tests/BUILD.bazel @@ -9,13 +9,13 @@ package( precompiled_headers( name = 'pch_gtest', - main = 'gtest.hpp' + main = 'gtest.hpp', + deps = [ + '@gtest//:gtest-gmock_main' + ] ) cc_library( name = 'test_fixtures', - hdrs = ['fixtures.hpp'], - deps = [ - '@gtest//:gtest-gmock_main' - ] + hdrs = ['fixtures.hpp'] ) diff --git a/tests/Pog/BUILD.bazel b/tests/Pog/BUILD.bazel index 06c9e805..77ff00fa 100644 --- a/tests/Pog/BUILD.bazel +++ b/tests/Pog/BUILD.bazel @@ -5,7 +5,6 @@ cc_test( srcs = glob(['**/*.cpp']), deps = [ '//tests:pch_gtest', - '//tests:test_fixtures', '//src/PCH:pch_cstd', '//src/Pog:pog', '@gtest//:gtest-gmock_main', From cb274a7bc583dfb474b61b27cc17af1f1c219323 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Fri, 9 May 2025 04:20:56 +0300 Subject: [PATCH 21/40] remove this for now --- .bazelrc | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/.bazelrc b/.bazelrc index 4b2bcc38..8416da9f 100644 --- a/.bazelrc +++ b/.bazelrc @@ -43,8 +43,7 @@ build:linux-opt --cxxopt=-O3 # ... # --- Testing --- -# Linux, Debug -test:linux --config=dbg-linux +# Linux # Verbose output test:linux --test_summary=detailed # Stream test results to stdout From 2816b0b7d32017e83be5daefa094732d56ac441a Mon Sep 17 00:00:00 2001 From: HyperWinX Date: Fri, 9 May 2025 20:19:27 +0400 Subject: [PATCH 22/40] 'Fix' integration tests - libfmt linkage fix required --- .bazelrc | 5 +- BUILD.bazel | 1 + src/Assembler/BUILD.bazel | 4 + src/Common/LanguageSpec/AllowedFlags.hpp | 15 +- src/Common/LanguageSpec/Flags.hpp | 2 +- src/Emulator/BUILD.bazel | 3 + tests/Integration/BUILD.bazel | 23 +- .../Integration/EmulatorCore/CPU/CPU_ADC.cpp | 64 +-- .../Integration/EmulatorCore/CPU/CPU_ADD.cpp | 64 +-- .../Integration/EmulatorCore/CPU/CPU_AND.cpp | 86 ++-- .../Integration/EmulatorCore/CPU/CPU_ANDN.cpp | 86 ++-- .../EmulatorCore/CPU/CPU_BSWAP.cpp | 24 +- .../Integration/EmulatorCore/CPU/CPU_CALL.cpp | 12 +- .../EmulatorCore/CPU/CPU_CALLE.cpp | 20 +- .../EmulatorCore/CPU/CPU_CALLGR.cpp | 20 +- .../EmulatorCore/CPU/CPU_CALLL.cpp | 20 +- .../Integration/EmulatorCore/CPU/CPU_CCRF.cpp | 6 +- .../Integration/EmulatorCore/CPU/CPU_CMP.cpp | 410 +++++++++--------- .../Integration/EmulatorCore/CPU/CPU_COVF.cpp | 6 +- .../Integration/EmulatorCore/CPU/CPU_CUDF.cpp | 6 +- .../Integration/EmulatorCore/CPU/CPU_DEC.cpp | 40 +- .../Integration/EmulatorCore/CPU/CPU_DIV.cpp | 22 +- .../Integration/EmulatorCore/CPU/CPU_HID.cpp | 8 +- .../Integration/EmulatorCore/CPU/CPU_INC.cpp | 40 +- .../Integration/EmulatorCore/CPU/CPU_INTR.cpp | 14 +- .../Integration/EmulatorCore/CPU/CPU_IRET.cpp | 8 +- .../Integration/EmulatorCore/CPU/CPU_JME.cpp | 20 +- .../Integration/EmulatorCore/CPU/CPU_JMGR.cpp | 20 +- .../Integration/EmulatorCore/CPU/CPU_JML.cpp | 19 +- .../Integration/EmulatorCore/CPU/CPU_JMP.cpp | 12 +- .../EmulatorCore/CPU/CPU_LOIVT.cpp | 10 +- .../Integration/EmulatorCore/CPU/CPU_MOV.cpp | 139 +++--- .../Integration/EmulatorCore/CPU/CPU_MUL.cpp | 166 +++---- tests/Integration/EmulatorCore/CPU/CPU_OR.cpp | 86 ++-- .../Integration/EmulatorCore/CPU/CPU_POP.cpp | 23 +- .../Integration/EmulatorCore/CPU/CPU_PUSH.cpp | 30 +- .../Integration/EmulatorCore/CPU/CPU_READ.cpp | 6 +- .../Integration/EmulatorCore/CPU/CPU_SHFL.cpp | 46 +- .../Integration/EmulatorCore/CPU/CPU_SHFR.cpp | 46 +- .../Integration/EmulatorCore/CPU/CPU_SUB.cpp | 166 +++---- .../EmulatorCore/CPU/CPU_WRITE.cpp | 9 +- .../EmulatorCore/CPU/OperandsEvaluation.cpp | 118 ++--- tests/fixtures.hpp | 4 + 43 files changed, 959 insertions(+), 970 deletions(-) diff --git a/.bazelrc b/.bazelrc index 8416da9f..a0c9d848 100644 --- a/.bazelrc +++ b/.bazelrc @@ -16,8 +16,9 @@ build:linux --cxxopt=-Wno-missing-field-initializers build:linux --cxxopt=-Wno-stringop-overflow # LTO, see: https://gcc.gnu.org/wiki/LinkTimeOptimization -build:linux --cxxopt=-flto -build:linux --linkopt=-flto +# TODO: make conan build all dependencies with LTO - right now triggers "final link failed: bad value" errors +# build:linux --cxxopt=-flto +# build:linux --linkopt=-flto # Optimize for native (host) architecture # Be warned - might break distribution builds diff --git a/BUILD.bazel b/BUILD.bazel index b3678328..ff2f40be 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -13,6 +13,7 @@ refresh_compile_commands( name = 'refresh_compile_commands', targets = { '//src/...': '', + '//tests/...': '' } ) diff --git a/src/Assembler/BUILD.bazel b/src/Assembler/BUILD.bazel index 74cb07cd..e94fef21 100644 --- a/src/Assembler/BUILD.bazel +++ b/src/Assembler/BUILD.bazel @@ -11,6 +11,10 @@ cc_library( srcs = glob(['**/*.cpp'], exclude = ['Main']), hdrs = glob(['**/*.hpp'], exclude = ['Main']), strip_include_prefix = '/src', + visibility = [ + '//tests:__subpackages__', + '//src/Emulator:__pkg__' + ], deps = [ '//src/PCH:pch_cstd', '//src/Pog:pog', diff --git a/src/Common/LanguageSpec/AllowedFlags.hpp b/src/Common/LanguageSpec/AllowedFlags.hpp index 4300fe4e..23f37444 100644 --- a/src/Common/LanguageSpec/AllowedFlags.hpp +++ b/src/Common/LanguageSpec/AllowedFlags.hpp @@ -33,20 +33,7 @@ namespace HyperCPU { {0b11000000, 0, 0, 0b11000000, 0, 0, 0, 0, 0, 0, 0}, // WRITE {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // JMP {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, SUPPORT_ALL, 0}, // PUSH - { - 0, - 0, - 0, - 0, - 0, - 0, - 0, - 0, - SUPPORT_ALL, - 0, - 0, - 0, - }, // POP + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // POP {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALLE {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALLGR {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALLL diff --git a/src/Common/LanguageSpec/Flags.hpp b/src/Common/LanguageSpec/Flags.hpp index ae12dc14..f3afb30f 100644 --- a/src/Common/LanguageSpec/Flags.hpp +++ b/src/Common/LanguageSpec/Flags.hpp @@ -3,7 +3,7 @@ #include "PCH/CStd.hpp" namespace HyperCPU { - enum class Mode { + enum class Mode : std::uint8_t { b8 = 0, b16, b32, diff --git a/src/Emulator/BUILD.bazel b/src/Emulator/BUILD.bazel index a3d64af0..39ce029f 100644 --- a/src/Emulator/BUILD.bazel +++ b/src/Emulator/BUILD.bazel @@ -4,6 +4,9 @@ cc_library( name = 'emulator_core', srcs = glob(['**/*.cpp']), hdrs = glob(['**/*.hpp']), + visibility = [ + '//tests:__subpackages__' + ], deps = [ '@fmt//:fmt', '@argparse//:argparse', diff --git a/tests/Integration/BUILD.bazel b/tests/Integration/BUILD.bazel index 0e5f6a98..93949404 100644 --- a/tests/Integration/BUILD.bazel +++ b/tests/Integration/BUILD.bazel @@ -1,11 +1,16 @@ -# load('@rules_cc//cc:defs.bzl', 'cc_test') +load('@rules_cc//cc:defs.bzl', 'cc_test') -# cc_test( -# name = 'integration-test', -# srcs = glob(['**/*.cpp']), -# deps = [ -# '//tests:pch_gtest', -# '@gtest//:gtest_main_precompiled' -# ] -# ) +cc_test( + name = 'integration-test', + srcs = glob(['**/*.cpp']), + deps = [ + '//src/PCH:pch_cstd', + '//tests:pch_gtest', + '//src/Assembler:assembler_core', + '//src/Emulator:emulator_core', + '//tests:test_fixtures', + '@gtest//:gtest', + '@fmt//:fmt' + ] +) diff --git a/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp b/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp index f6929e41..5098223a 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp @@ -29,7 +29,7 @@ static constexpr std::uint64_t QWORD_SUM_OF = QWORD_DATA1_OF + QWORD_DATA2_OF + TEST_F(CPU_TEST, INSTR_ADC_R_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -45,7 +45,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b8) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -61,7 +61,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b16) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -77,7 +77,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b32) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -93,7 +93,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b64) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -110,7 +110,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b8) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -127,7 +127,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b16) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -144,7 +144,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b32) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -161,7 +161,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b64) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -177,7 +177,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b8) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -193,7 +193,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b16) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -209,7 +209,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b32) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -225,7 +225,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b64) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -240,7 +240,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b8) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); @@ -255,7 +255,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b16) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); @@ -270,7 +270,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b32) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -285,7 +285,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b64) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -302,7 +302,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b8_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -319,7 +319,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b16_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -336,7 +336,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b32_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_R_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -353,7 +353,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_R_b64_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -371,7 +371,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b8_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -389,7 +389,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b16_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -407,7 +407,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b32_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_RM_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -425,7 +425,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_RM_b64_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -442,7 +442,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b8_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -459,7 +459,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b16_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -476,7 +476,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b32_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_M_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -493,7 +493,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_M_b64_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -509,7 +509,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b8_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); @@ -525,7 +525,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b16_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); @@ -541,7 +541,7 @@ TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b32_OF) { TEST_F(CPU_TEST, INSTR_ADC_R_IMM_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADC); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp b/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp index 4e76b75e..0121dffa 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp @@ -29,7 +29,7 @@ static constexpr std::uint64_t QWORD_SUM_OF = QWORD_DATA1_OF + QWORD_DATA2_OF; TEST_F(CPU_TEST, INSTR_ADD_R_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -44,7 +44,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b8) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -59,7 +59,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b16) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -74,7 +74,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b32) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_R))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -89,7 +89,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b64) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -105,7 +105,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b8) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -121,7 +121,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b16) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -137,7 +137,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b32) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_RM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -153,7 +153,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b64) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -168,7 +168,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b8) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -183,7 +183,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b16) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -198,7 +198,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b32) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_M))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -213,7 +213,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b64) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b8) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -227,7 +227,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b8) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b16) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); @@ -241,7 +241,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b16) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b32) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); @@ -255,7 +255,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b32) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, static_cast(static_cast(HyperCPU::Mode::b64) << 4 | static_cast(HyperCPU::OperandTypes::R_IMM))); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -269,7 +269,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b64) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -285,7 +285,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b8_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -301,7 +301,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b16_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -317,7 +317,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b32_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_R_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -333,7 +333,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_R_b64_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -350,7 +350,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b8_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -367,7 +367,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b16_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -384,7 +384,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b32_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_RM_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -401,7 +401,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_RM_b64_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -417,7 +417,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b8_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -433,7 +433,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b16_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -449,7 +449,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b32_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_M_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); @@ -465,7 +465,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_M_b64_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); @@ -480,7 +480,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b8_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); @@ -495,7 +495,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b16_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); @@ -510,7 +510,7 @@ TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b32_OF) { TEST_F(CPU_TEST, INSTR_ADD_R_IMM_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ADD); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_AND.cpp b/tests/Integration/EmulatorCore/CPU/CPU_AND.cpp index 90337e53..317374b8 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_AND.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_AND.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; @@ -18,9 +18,9 @@ static constexpr std::uint64_t QWORD_SUM = QWORD_DATA1 & QWORD_DATA2; TEST_F(CPU_TEST, INSTR_AND_R_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -33,9 +33,9 @@ TEST_F(CPU_TEST, INSTR_AND_R_R_b8) { TEST_F(CPU_TEST, INSTR_AND_R_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -48,9 +48,9 @@ TEST_F(CPU_TEST, INSTR_AND_R_R_b16) { TEST_F(CPU_TEST, INSTR_AND_R_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -63,9 +63,9 @@ TEST_F(CPU_TEST, INSTR_AND_R_R_b32) { TEST_F(CPU_TEST, INSTR_AND_R_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -78,9 +78,9 @@ TEST_F(CPU_TEST, INSTR_AND_R_R_b64) { TEST_F(CPU_TEST, INSTR_AND_R_RM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -94,9 +94,9 @@ TEST_F(CPU_TEST, INSTR_AND_R_RM_b8) { TEST_F(CPU_TEST, INSTR_AND_R_RM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -110,9 +110,9 @@ TEST_F(CPU_TEST, INSTR_AND_R_RM_b16) { TEST_F(CPU_TEST, INSTR_AND_R_RM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -126,9 +126,9 @@ TEST_F(CPU_TEST, INSTR_AND_R_RM_b32) { TEST_F(CPU_TEST, INSTR_AND_R_RM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -142,8 +142,8 @@ TEST_F(CPU_TEST, INSTR_AND_R_RM_b64) { TEST_F(CPU_TEST, INSTR_AND_R_M_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -157,8 +157,8 @@ TEST_F(CPU_TEST, INSTR_AND_R_M_b8) { TEST_F(CPU_TEST, INSTR_AND_R_M_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -172,8 +172,8 @@ TEST_F(CPU_TEST, INSTR_AND_R_M_b16) { TEST_F(CPU_TEST, INSTR_AND_R_M_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -187,8 +187,8 @@ TEST_F(CPU_TEST, INSTR_AND_R_M_b32) { TEST_F(CPU_TEST, INSTR_AND_R_M_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -202,8 +202,8 @@ TEST_F(CPU_TEST, INSTR_AND_R_M_b64) { TEST_F(CPU_TEST, INSTR_AND_R_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -216,8 +216,8 @@ TEST_F(CPU_TEST, INSTR_AND_R_IMM_b8) { TEST_F(CPU_TEST, INSTR_AND_R_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -230,8 +230,8 @@ TEST_F(CPU_TEST, INSTR_AND_R_IMM_b16) { TEST_F(CPU_TEST, INSTR_AND_R_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -244,8 +244,8 @@ TEST_F(CPU_TEST, INSTR_AND_R_IMM_b32) { TEST_F(CPU_TEST, INSTR_AND_R_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::AND); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_ANDN.cpp b/tests/Integration/EmulatorCore/CPU/CPU_ANDN.cpp index 300e9207..abefd4a0 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ANDN.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ANDN.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; @@ -18,9 +18,9 @@ static constexpr std::uint64_t QWORD_SUM = ~QWORD_DATA1 & QWORD_DATA2; TEST_F(CPU_TEST, INSTR_ANDN_R_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -33,9 +33,9 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_R_b8) { TEST_F(CPU_TEST, INSTR_ANDN_R_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -48,9 +48,9 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_R_b16) { TEST_F(CPU_TEST, INSTR_ANDN_R_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -63,9 +63,9 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_R_b32) { TEST_F(CPU_TEST, INSTR_ANDN_R_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -78,9 +78,9 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_R_b64) { TEST_F(CPU_TEST, INSTR_ANDN_R_RM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -94,9 +94,9 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_RM_b8) { TEST_F(CPU_TEST, INSTR_ANDN_R_RM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -110,9 +110,9 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_RM_b16) { TEST_F(CPU_TEST, INSTR_ANDN_R_RM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -126,9 +126,9 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_RM_b32) { TEST_F(CPU_TEST, INSTR_ANDN_R_RM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -142,8 +142,8 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_RM_b64) { TEST_F(CPU_TEST, INSTR_ANDN_R_M_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -157,8 +157,8 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_M_b8) { TEST_F(CPU_TEST, INSTR_ANDN_R_M_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -172,8 +172,8 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_M_b16) { TEST_F(CPU_TEST, INSTR_ANDN_R_M_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -187,8 +187,8 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_M_b32) { TEST_F(CPU_TEST, INSTR_ANDN_R_M_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -202,8 +202,8 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_M_b64) { TEST_F(CPU_TEST, INSTR_ANDN_R_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -216,8 +216,8 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_IMM_b8) { TEST_F(CPU_TEST, INSTR_ANDN_R_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -230,8 +230,8 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_IMM_b16) { TEST_F(CPU_TEST, INSTR_ANDN_R_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -244,8 +244,8 @@ TEST_F(CPU_TEST, INSTR_ANDN_R_IMM_b32) { TEST_F(CPU_TEST, INSTR_ANDN_R_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::ANDN); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_BSWAP.cpp b/tests/Integration/EmulatorCore/CPU/CPU_BSWAP.cpp index fca3ebaf..286985b8 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_BSWAP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_BSWAP.cpp @@ -1,10 +1,10 @@ #include -#include -#include -#include +#include "Emulator/Misc/byteswap.hpp" +#include +#include -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x12; static constexpr std::uint8_t BYTE_RESULT = BYTE_DATA1; @@ -17,8 +17,8 @@ static std::uint64_t QWORD_RESULT = HyperCPU::byteswap(QWORD_DATA1); TEST_F(CPU_TEST, INSTR_BSWAP_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::BSWAP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -30,8 +30,8 @@ TEST_F(CPU_TEST, INSTR_BSWAP_R_b8) { TEST_F(CPU_TEST, INSTR_BSWAP_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::BSWAP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -43,8 +43,8 @@ TEST_F(CPU_TEST, INSTR_BSWAP_R_b16) { TEST_F(CPU_TEST, INSTR_BSWAP_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::BSWAP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -56,8 +56,8 @@ TEST_F(CPU_TEST, INSTR_BSWAP_R_b32) { TEST_F(CPU_TEST, INSTR_BSWAP_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::BSWAP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp index 58c3f9d7..5aa1506b 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp @@ -1,12 +1,12 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_CALL_R) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALL); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.xbp = 512; @@ -20,7 +20,7 @@ TEST_F(CPU_TEST, INSTR_CALL_R) { TEST_F(CPU_TEST, INSTR_CALL_IMM) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALL); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CALLE.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CALLE.cpp index a6b6da3e..05bfc830 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALLE.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALLE.cpp @@ -1,12 +1,12 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_CALLE_R_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLE); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.xbp = 512; @@ -21,8 +21,8 @@ TEST_F(CPU_TEST, INSTR_CALLE_R_TRUE) { TEST_F(CPU_TEST, INSTR_CALLE_R_FALSE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLE); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); @@ -38,7 +38,7 @@ TEST_F(CPU_TEST, INSTR_CALLE_R_FALSE) { TEST_F(CPU_TEST, INSTR_CALLE_IMM_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLE); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); @@ -53,7 +53,7 @@ TEST_F(CPU_TEST, INSTR_CALLE_IMM_TRUE) { TEST_F(CPU_TEST, INSTR_CALLE_IMM_FALSE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLE); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(*cpu.xip + 11, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 13, HyperCPU::OperandTypes::NONE); @@ -65,4 +65,4 @@ TEST_F(CPU_TEST, INSTR_CALLE_IMM_FALSE) { cpu.Run(); ASSERT_EQ(*cpu.xip, 14); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CALLGR.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CALLGR.cpp index be3a3890..b7037654 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALLGR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALLGR.cpp @@ -1,12 +1,12 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_CALLGR_R_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLGR); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.xbp = 512; @@ -20,8 +20,8 @@ TEST_F(CPU_TEST, INSTR_CALLGR_R_TRUE) { TEST_F(CPU_TEST, INSTR_CALLGR_R_FALSE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLGR); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); @@ -38,7 +38,7 @@ TEST_F(CPU_TEST, INSTR_CALLGR_R_FALSE) { TEST_F(CPU_TEST, INSTR_CALLGR_IMM_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLGR); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); @@ -52,7 +52,7 @@ TEST_F(CPU_TEST, INSTR_CALLGR_IMM_TRUE) { TEST_F(CPU_TEST, INSTR_CALLGR_IMM_FALSE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLGR); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(*cpu.xip + 11, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 13, HyperCPU::OperandTypes::NONE); @@ -65,4 +65,4 @@ TEST_F(CPU_TEST, INSTR_CALLGR_IMM_FALSE) { cpu.Run(); ASSERT_EQ(*cpu.xip, 14); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CALLL.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CALLL.cpp index c3b2c9e2..695358a8 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALLL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALLL.cpp @@ -1,12 +1,12 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_CALLL_R_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLL); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.xbp = 512; @@ -21,8 +21,8 @@ TEST_F(CPU_TEST, INSTR_CALLL_R_TRUE) { TEST_F(CPU_TEST, INSTR_CALLL_R_FALSE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLL); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); @@ -38,7 +38,7 @@ TEST_F(CPU_TEST, INSTR_CALLL_R_FALSE) { TEST_F(CPU_TEST, INSTR_CALLL_IMM_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLL); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); @@ -53,7 +53,7 @@ TEST_F(CPU_TEST, INSTR_CALLL_IMM_TRUE) { TEST_F(CPU_TEST, INSTR_CALLL_IMM_FALSE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALLL); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(*cpu.xip + 11, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 13, HyperCPU::OperandTypes::NONE); @@ -65,4 +65,4 @@ TEST_F(CPU_TEST, INSTR_CALLL_IMM_FALSE) { cpu.Run(); ASSERT_EQ(*cpu.xip, 14); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CCRF.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CCRF.cpp index 8c3d36d4..f5a81b99 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CCRF.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CCRF.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_CCRF_SET) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CCRF); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CMP.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CMP.cpp index 3270560b..0aefabcf 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CMP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CMP.cpp @@ -1,13 +1,13 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_CMP_R_R_b8_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = 0x0F; @@ -21,9 +21,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b8_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_R_b8_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = 0x1F; @@ -37,9 +37,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b8_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_R_b8_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = 0x1F; @@ -53,9 +53,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b8_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_R_b16_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = 0x0F; @@ -69,9 +69,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b16_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_R_b16_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = 0x1F; @@ -85,9 +85,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b16_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_R_b16_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = 0x1F; @@ -101,9 +101,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b16_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_R_b32_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = 0x0F; @@ -117,9 +117,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b32_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_R_b32_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = 0x1F; @@ -133,9 +133,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b32_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_R_b32_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = 0x1F; @@ -149,9 +149,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b32_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_R_b64_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = 0x0F; @@ -165,9 +165,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b64_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_R_b64_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = 0x1F; @@ -181,9 +181,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b64_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_R_b64_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = 0x1F; @@ -197,9 +197,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_R_b64_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_RM_b8_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load8(*cpu.xip + 1024, 0x1F); @@ -214,9 +214,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_RM_b8_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_RM_b8_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load8(*cpu.xip + 1024, 0x0F); @@ -231,9 +231,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_RM_b8_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_RM_b8_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load8(*cpu.xip + 1024, 0x1F); @@ -248,9 +248,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_RM_b8_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_RM_b16_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(*cpu.xip + 1024, 0x1F); @@ -265,9 +265,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_RM_b16_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_RM_b16_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(*cpu.xip + 1024, 0x0F); @@ -282,9 +282,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_RM_b16_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_RM_b16_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(*cpu.xip + 1024, 0x1F); @@ -299,9 +299,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_RM_b16_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_RM_b32_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load32(*cpu.xip + 1024, 0x1F); @@ -316,9 +316,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_RM_b32_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_RM_b32_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load32(*cpu.xip + 1024, 0x0F); @@ -333,9 +333,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_RM_b32_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_RM_b32_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load32(*cpu.xip + 1024, 0x1F); @@ -350,9 +350,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_RM_b32_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_RM_b64_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load64(*cpu.xip + 1024, 0x1F); @@ -367,9 +367,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_RM_b64_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_RM_b64_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load64(*cpu.xip + 1024, 0x0F); @@ -384,9 +384,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_RM_b64_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_RM_b64_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load64(*cpu.xip + 1024, 0x0F); @@ -401,8 +401,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_RM_b64_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_M_b8_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -417,8 +417,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_M_b8_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_M_b8_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -433,8 +433,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_M_b8_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_M_b8_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -449,8 +449,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_M_b8_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_M_b16_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -465,8 +465,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_M_b16_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_M_b16_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -481,8 +481,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_M_b16_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_M_b16_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -497,8 +497,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_M_b16_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_M_b32_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -513,8 +513,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_M_b32_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_M_b32_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -529,8 +529,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_M_b32_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_M_b32_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -545,8 +545,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_M_b32_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_M_b64_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -561,8 +561,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_M_b64_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_M_b64_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -577,8 +577,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_M_b64_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_M_b64_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -593,8 +593,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_M_b64_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b8_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, 0x1F); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -608,8 +608,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b8_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b8_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, 0x0F); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -623,8 +623,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b8_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b8_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, 0x0F); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -638,8 +638,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b8_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b16_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, 0x1F); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -653,8 +653,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b16_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b16_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, 0x0F); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -668,8 +668,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b16_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b16_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, 0x0F); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -683,8 +683,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b16_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b32_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, 0x1F); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -698,8 +698,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b32_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b32_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, 0x0F); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -713,8 +713,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b32_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b32_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, 0x0F); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -728,8 +728,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b32_EQ) { TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b64_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 0x1F); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -743,8 +743,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b64_LE) { TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b64_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 0x0F); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -758,8 +758,8 @@ TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b64_GR) { TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b64_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 0x0F); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -773,9 +773,9 @@ TEST_F(CPU_TEST, INSTR_CMP_R_IMM_b64_EQ) { TEST_F(CPU_TEST, INSTR_CMP_RM_R_b8_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load8(1024, 0x0F); @@ -790,9 +790,9 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_R_b8_LE) { TEST_F(CPU_TEST, INSTR_CMP_RM_R_b8_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load8(1024, 0x1F); @@ -807,9 +807,9 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_R_b8_GR) { TEST_F(CPU_TEST, INSTR_CMP_RM_R_b8_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load8(1024, 0x0F); @@ -824,9 +824,9 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_R_b8_EQ) { TEST_F(CPU_TEST, INSTR_CMP_RM_R_b16_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(1024, 0x0F); @@ -841,9 +841,9 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_R_b16_LE) { TEST_F(CPU_TEST, INSTR_CMP_RM_R_b16_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(1024, 0x1F); @@ -858,9 +858,9 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_R_b16_GR) { TEST_F(CPU_TEST, INSTR_CMP_RM_R_b16_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(1024, 0x0F); @@ -875,9 +875,9 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_R_b16_EQ) { TEST_F(CPU_TEST, INSTR_CMP_RM_R_b32_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load32(1024, 0x0F); @@ -892,9 +892,9 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_R_b32_LE) { TEST_F(CPU_TEST, INSTR_CMP_RM_R_b32_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load32(1024, 0x1F); @@ -909,9 +909,9 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_R_b32_GR) { TEST_F(CPU_TEST, INSTR_CMP_RM_R_b32_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load32(1024, 0x0F); @@ -926,9 +926,9 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_R_b32_EQ) { TEST_F(CPU_TEST, INSTR_CMP_RM_R_b64_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load64(1024, 0x0F); @@ -943,9 +943,9 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_R_b64_LE) { TEST_F(CPU_TEST, INSTR_CMP_RM_R_b64_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load64(1024, 0x1F); @@ -960,9 +960,9 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_R_b64_GR) { TEST_F(CPU_TEST, INSTR_CMP_RM_R_b64_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load64(1024, 0x0F); @@ -977,8 +977,8 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_R_b64_EQ) { TEST_F(CPU_TEST, INSTR_CMP_RM_M_b8_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -994,8 +994,8 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_M_b8_LE) { TEST_F(CPU_TEST, INSTR_CMP_RM_M_b8_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -1011,8 +1011,8 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_M_b8_GR) { TEST_F(CPU_TEST, INSTR_CMP_RM_M_b8_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -1028,8 +1028,8 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_M_b8_EQ) { TEST_F(CPU_TEST, INSTR_CMP_RM_M_b16_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -1045,8 +1045,8 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_M_b16_LE) { TEST_F(CPU_TEST, INSTR_CMP_RM_M_b16_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -1062,8 +1062,8 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_M_b16_GR) { TEST_F(CPU_TEST, INSTR_CMP_RM_M_b16_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -1079,8 +1079,8 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_M_b16_EQ) { TEST_F(CPU_TEST, INSTR_CMP_RM_M_b32_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -1096,8 +1096,8 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_M_b32_LE) { TEST_F(CPU_TEST, INSTR_CMP_RM_M_b32_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -1113,8 +1113,8 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_M_b32_GR) { TEST_F(CPU_TEST, INSTR_CMP_RM_M_b32_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -1130,8 +1130,8 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_M_b32_EQ) { TEST_F(CPU_TEST, INSTR_CMP_RM_M_b64_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -1147,8 +1147,8 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_M_b64_LE) { TEST_F(CPU_TEST, INSTR_CMP_RM_M_b64_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -1164,9 +1164,9 @@ TEST_F(CPU_TEST, INSTR_CMP_RM_M_b64_GR) { TEST_F(CPU_TEST, INSTR_CMP_M_R_b8_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load8(1024, 0x0F); @@ -1180,9 +1180,9 @@ TEST_F(CPU_TEST, INSTR_CMP_M_R_b8_LE) { TEST_F(CPU_TEST, INSTR_CMP_M_R_b8_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load8(1024, 0x1F); @@ -1196,9 +1196,9 @@ TEST_F(CPU_TEST, INSTR_CMP_M_R_b8_GR) { TEST_F(CPU_TEST, INSTR_CMP_M_R_b8_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load8(1024, 0x0F); @@ -1212,9 +1212,9 @@ TEST_F(CPU_TEST, INSTR_CMP_M_R_b8_EQ) { TEST_F(CPU_TEST, INSTR_CMP_M_R_b16_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(1024, 0x0F); @@ -1228,9 +1228,9 @@ TEST_F(CPU_TEST, INSTR_CMP_M_R_b16_LE) { TEST_F(CPU_TEST, INSTR_CMP_M_R_b16_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(1024, 0x1F); @@ -1244,9 +1244,9 @@ TEST_F(CPU_TEST, INSTR_CMP_M_R_b16_GR) { TEST_F(CPU_TEST, INSTR_CMP_M_R_b16_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(1024, 0x0F); @@ -1260,9 +1260,9 @@ TEST_F(CPU_TEST, INSTR_CMP_M_R_b16_EQ) { TEST_F(CPU_TEST, INSTR_CMP_M_R_b32_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::XL0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load32(1024, 0x0F); @@ -1276,9 +1276,9 @@ TEST_F(CPU_TEST, INSTR_CMP_M_R_b32_LE) { TEST_F(CPU_TEST, INSTR_CMP_M_R_b32_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::XL0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load32(1024, 0x1F); @@ -1292,9 +1292,9 @@ TEST_F(CPU_TEST, INSTR_CMP_M_R_b32_GR) { TEST_F(CPU_TEST, INSTR_CMP_M_R_b32_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::XL0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load32(1024, 0x0F); @@ -1308,9 +1308,9 @@ TEST_F(CPU_TEST, INSTR_CMP_M_R_b32_EQ) { TEST_F(CPU_TEST, INSTR_CMP_M_R_b64_LE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load64(1024, 0x0F); @@ -1324,9 +1324,9 @@ TEST_F(CPU_TEST, INSTR_CMP_M_R_b64_LE) { TEST_F(CPU_TEST, INSTR_CMP_M_R_b64_GR) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load64(1024, 0x1F); @@ -1340,9 +1340,9 @@ TEST_F(CPU_TEST, INSTR_CMP_M_R_b64_GR) { TEST_F(CPU_TEST, INSTR_CMP_M_R_b64_EQ) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CMP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load64(1024, 0x0F); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_COVF.cpp b/tests/Integration/EmulatorCore/CPU/CPU_COVF.cpp index 022bcb70..a707b687 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_COVF.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_COVF.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_COVF_SET) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::COVF); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CUDF.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CUDF.cpp index 53b67e89..60ae2432 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CUDF.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CUDF.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_CUDF_SET) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CUDF); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp b/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp index 18ba0d7c..df72062c 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_RESULT = BYTE_DATA1 - 1; @@ -19,8 +19,8 @@ static constexpr std::uint64_t QWORD_RESULT_UF = 0xFFFFFFFFFFFFFFFF; TEST_F(CPU_TEST, INSTR_DEC_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DEC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -33,8 +33,8 @@ TEST_F(CPU_TEST, INSTR_DEC_R_b8) { TEST_F(CPU_TEST, INSTR_DEC_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DEC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -47,8 +47,8 @@ TEST_F(CPU_TEST, INSTR_DEC_R_b16) { TEST_F(CPU_TEST, INSTR_DEC_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DEC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -61,8 +61,8 @@ TEST_F(CPU_TEST, INSTR_DEC_R_b32) { TEST_F(CPU_TEST, INSTR_DEC_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DEC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -75,8 +75,8 @@ TEST_F(CPU_TEST, INSTR_DEC_R_b64) { TEST_F(CPU_TEST, INSTR_DEC_R_b8_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DEC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = 0; @@ -89,8 +89,8 @@ TEST_F(CPU_TEST, INSTR_DEC_R_b8_UF) { TEST_F(CPU_TEST, INSTR_DEC_R_b16_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DEC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xll0 = 0; @@ -103,8 +103,8 @@ TEST_F(CPU_TEST, INSTR_DEC_R_b16_UF) { TEST_F(CPU_TEST, INSTR_DEC_R_b32_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DEC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xl0 = 0; @@ -117,8 +117,8 @@ TEST_F(CPU_TEST, INSTR_DEC_R_b32_UF) { TEST_F(CPU_TEST, INSTR_DEC_R_b64_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DEC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.x0 = 0; @@ -127,4 +127,4 @@ TEST_F(CPU_TEST, INSTR_DEC_R_b64_UF) { ASSERT_EQ(*cpu.x0, QWORD_RESULT_UF); ASSERT_TRUE(cpu.udf); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp b/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp index 851ab938..895d596c 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DIVIDER = 0x5; @@ -25,8 +25,8 @@ static constexpr std::uint64_t QWORD_REMAINDER = DWORD_DATA1 % DWORD_DIVIDER; TEST_F(CPU_TEST, INSTR_DIV_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DIV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -40,8 +40,8 @@ TEST_F(CPU_TEST, INSTR_DIV_R_b8) { TEST_F(CPU_TEST, INSTR_DIV_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DIV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -55,8 +55,8 @@ TEST_F(CPU_TEST, INSTR_DIV_R_b16) { TEST_F(CPU_TEST, INSTR_DIV_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DIV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -70,8 +70,8 @@ TEST_F(CPU_TEST, INSTR_DIV_R_b32) { TEST_F(CPU_TEST, INSTR_DIV_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DIV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_HID.cpp b/tests/Integration/EmulatorCore/CPU/CPU_HID.cpp index 2be0163e..b9e3eca3 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_HID.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_HID.cpp @@ -1,8 +1,6 @@ -#include -#include -#include +#include "Emulator/Core/CPU/Version.hpp" -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_HID_0) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::HID); @@ -38,4 +36,4 @@ TEST_F(CPU_TEST, INSTR_HID_2) { cpu.Run(); ASSERT_EQ(*cpu.x0, 0); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp b/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp index f3da00e5..92762507 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_RESULT = BYTE_DATA1 + 1; @@ -19,8 +19,8 @@ static constexpr std::uint64_t QWORD_DATA1_OF = 0xFFFFFFFFFFFFFFFF; TEST_F(CPU_TEST, INSTR_INC_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::INC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -33,8 +33,8 @@ TEST_F(CPU_TEST, INSTR_INC_R_b8) { TEST_F(CPU_TEST, INSTR_INC_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::INC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -47,8 +47,8 @@ TEST_F(CPU_TEST, INSTR_INC_R_b16) { TEST_F(CPU_TEST, INSTR_INC_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::INC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -61,8 +61,8 @@ TEST_F(CPU_TEST, INSTR_INC_R_b32) { TEST_F(CPU_TEST, INSTR_INC_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::INC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -75,8 +75,8 @@ TEST_F(CPU_TEST, INSTR_INC_R_b64) { TEST_F(CPU_TEST, INSTR_INC_R_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::INC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1_OF; @@ -89,8 +89,8 @@ TEST_F(CPU_TEST, INSTR_INC_R_b8_OF) { TEST_F(CPU_TEST, INSTR_INC_R_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::INC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1_OF; @@ -103,8 +103,8 @@ TEST_F(CPU_TEST, INSTR_INC_R_b16_OF) { TEST_F(CPU_TEST, INSTR_INC_R_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::INC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1_OF; @@ -117,8 +117,8 @@ TEST_F(CPU_TEST, INSTR_INC_R_b32_OF) { TEST_F(CPU_TEST, INSTR_INC_R_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::INC); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1_OF; @@ -127,4 +127,4 @@ TEST_F(CPU_TEST, INSTR_INC_R_b64_OF) { ASSERT_EQ(*cpu.x0, 0); ASSERT_TRUE(cpu.ovf); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_INTR.cpp b/tests/Integration/EmulatorCore/CPU/CPU_INTR.cpp index 5ff0a59c..4c1eb166 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_INTR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_INTR.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_INTR_R_b64) { // Setup stack @@ -12,11 +12,11 @@ TEST_F(CPU_TEST, INSTR_INTR_R_b64) { cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); // Code for interrupt handler cpu.mem_controller->Load16(1538, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::LOIVT); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::INTR); - cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 6, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::Reg::X1); *cpu.x0 = 2048; *cpu.x1 = 0; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_IRET.cpp b/tests/Integration/EmulatorCore/CPU/CPU_IRET.cpp index 6dbbc931..1c344c4f 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_IRET.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_IRET.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_IRET_NONE) { *cpu.xbp = 512; @@ -16,4 +16,4 @@ TEST_F(CPU_TEST, INSTR_IRET_NONE) { cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_JME.cpp b/tests/Integration/EmulatorCore/CPU/CPU_JME.cpp index a4a6001c..54eb5459 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_JME.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_JME.cpp @@ -1,12 +1,12 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_JME_R_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JME); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1536; @@ -19,8 +19,8 @@ TEST_F(CPU_TEST, INSTR_JME_R_TRUE) { TEST_F(CPU_TEST, INSTR_JME_R_FALSE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JME); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); @@ -34,7 +34,7 @@ TEST_F(CPU_TEST, INSTR_JME_R_FALSE) { TEST_F(CPU_TEST, INSTR_JME_IMM_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JME); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); @@ -47,7 +47,7 @@ TEST_F(CPU_TEST, INSTR_JME_IMM_TRUE) { TEST_F(CPU_TEST, INSTR_JME_IMM_FALSE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JME); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(*cpu.xip + 11, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 13, HyperCPU::OperandTypes::NONE); @@ -57,4 +57,4 @@ TEST_F(CPU_TEST, INSTR_JME_IMM_FALSE) { cpu.Run(); ASSERT_EQ(*cpu.xip, 14); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_JMGR.cpp b/tests/Integration/EmulatorCore/CPU/CPU_JMGR.cpp index c328bb54..c4429896 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_JMGR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_JMGR.cpp @@ -1,12 +1,12 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_JMGR_R_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JMGR); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1536; @@ -18,8 +18,8 @@ TEST_F(CPU_TEST, INSTR_JMGR_R_TRUE) { TEST_F(CPU_TEST, INSTR_JMGR_R_FALSE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JMGR); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); @@ -34,7 +34,7 @@ TEST_F(CPU_TEST, INSTR_JMGR_R_FALSE) { TEST_F(CPU_TEST, INSTR_JMGR_IMM_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JMGR); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); @@ -46,7 +46,7 @@ TEST_F(CPU_TEST, INSTR_JMGR_IMM_TRUE) { TEST_F(CPU_TEST, INSTR_JMGR_IMM_FALSE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JMGR); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(*cpu.xip + 11, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 13, HyperCPU::OperandTypes::NONE); @@ -57,4 +57,4 @@ TEST_F(CPU_TEST, INSTR_JMGR_IMM_FALSE) { cpu.Run(); ASSERT_EQ(*cpu.xip, 14); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_JML.cpp b/tests/Integration/EmulatorCore/CPU/CPU_JML.cpp index 2c2869af..568255da 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_JML.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_JML.cpp @@ -1,12 +1,9 @@ -#include -#include - -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_JML_R_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JML); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1536; @@ -19,8 +16,8 @@ TEST_F(CPU_TEST, INSTR_JML_R_TRUE) { TEST_F(CPU_TEST, INSTR_JML_R_FALSE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JML); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); @@ -34,7 +31,7 @@ TEST_F(CPU_TEST, INSTR_JML_R_FALSE) { TEST_F(CPU_TEST, INSTR_JML_IMM_TRUE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JML); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); @@ -47,7 +44,7 @@ TEST_F(CPU_TEST, INSTR_JML_IMM_TRUE) { TEST_F(CPU_TEST, INSTR_JML_IMM_FALSE) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JML); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(*cpu.xip + 11, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 13, HyperCPU::OperandTypes::NONE); @@ -57,4 +54,4 @@ TEST_F(CPU_TEST, INSTR_JML_IMM_FALSE) { cpu.Run(); ASSERT_EQ(*cpu.xip, 14); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_JMP.cpp b/tests/Integration/EmulatorCore/CPU/CPU_JMP.cpp index 20ad92b9..67a25284 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_JMP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_JMP.cpp @@ -1,12 +1,12 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_JMP_R) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JMP); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1536; @@ -18,7 +18,7 @@ TEST_F(CPU_TEST, INSTR_JMP_R) { TEST_F(CPU_TEST, INSTR_JMP_IMM) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::JMP); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp b/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp index d0917422..6f44cd69 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp @@ -1,12 +1,12 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_LOIVT_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::LOIVT); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.x1 = 2048; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp b/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp index 6bf3ea92..61fbd4c0 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA = 0x55; static constexpr std::uint16_t WORD_DATA = 0x5555; @@ -11,8 +11,9 @@ static constexpr std::uint64_t RND_QWORD_DATA = 0x0102030405060708; TEST_F(CPU_TEST, INSTR_MOV_R_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load16(*cpu.xip + 3, HyperCPU::Registers::XLLL0 << 8 | HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x1 = RND_QWORD_DATA; @@ -24,8 +25,9 @@ TEST_F(CPU_TEST, INSTR_MOV_R_R_b8) { TEST_F(CPU_TEST, INSTR_MOV_R_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load16(*cpu.xip + 3, HyperCPU::Registers::XLL0 << 8 | HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x1 = RND_QWORD_DATA; @@ -37,8 +39,9 @@ TEST_F(CPU_TEST, INSTR_MOV_R_R_b16) { TEST_F(CPU_TEST, INSTR_MOV_R_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load16(*cpu.xip + 3, HyperCPU::Registers::XL0 << 8 | HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x1 = RND_QWORD_DATA; @@ -50,9 +53,9 @@ TEST_F(CPU_TEST, INSTR_MOV_R_R_b32) { TEST_F(CPU_TEST, INSTR_MOV_R_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x1 = RND_QWORD_DATA; @@ -64,9 +67,9 @@ TEST_F(CPU_TEST, INSTR_MOV_R_R_b64) { TEST_F(CPU_TEST, INSTR_MOV_R_RM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load8(*cpu.xip + 1024, BYTE_DATA); @@ -79,9 +82,9 @@ TEST_F(CPU_TEST, INSTR_MOV_R_RM_b8) { TEST_F(CPU_TEST, INSTR_MOV_R_RM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load16(*cpu.xip + 1024, WORD_DATA); @@ -94,9 +97,9 @@ TEST_F(CPU_TEST, INSTR_MOV_R_RM_b16) { TEST_F(CPU_TEST, INSTR_MOV_R_RM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load32(*cpu.xip + 1024, DWORD_DATA); @@ -109,9 +112,9 @@ TEST_F(CPU_TEST, INSTR_MOV_R_RM_b32) { TEST_F(CPU_TEST, INSTR_MOV_R_RM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); cpu.mem_controller->Load64(*cpu.xip + 1024, QWORD_DATA); @@ -124,8 +127,8 @@ TEST_F(CPU_TEST, INSTR_MOV_R_RM_b64) { TEST_F(CPU_TEST, INSTR_MOV_R_M_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -139,8 +142,8 @@ TEST_F(CPU_TEST, INSTR_MOV_R_M_b8) { TEST_F(CPU_TEST, INSTR_MOV_R_M_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -154,8 +157,8 @@ TEST_F(CPU_TEST, INSTR_MOV_R_M_b16) { TEST_F(CPU_TEST, INSTR_MOV_R_M_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -169,8 +172,8 @@ TEST_F(CPU_TEST, INSTR_MOV_R_M_b32) { TEST_F(CPU_TEST, INSTR_MOV_R_M_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -184,8 +187,8 @@ TEST_F(CPU_TEST, INSTR_MOV_R_M_b64) { TEST_F(CPU_TEST, INSTR_MOV_R_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -197,8 +200,8 @@ TEST_F(CPU_TEST, INSTR_MOV_R_IMM_b8) { TEST_F(CPU_TEST, INSTR_MOV_R_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -210,8 +213,8 @@ TEST_F(CPU_TEST, INSTR_MOV_R_IMM_b16) { TEST_F(CPU_TEST, INSTR_MOV_R_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -223,8 +226,8 @@ TEST_F(CPU_TEST, INSTR_MOV_R_IMM_b32) { TEST_F(CPU_TEST, INSTR_MOV_R_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -236,9 +239,9 @@ TEST_F(CPU_TEST, INSTR_MOV_R_IMM_b64) { TEST_F(CPU_TEST, INSTR_MOV_RM_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1024; @@ -251,9 +254,9 @@ TEST_F(CPU_TEST, INSTR_MOV_RM_R_b8) { TEST_F(CPU_TEST, INSTR_MOV_RM_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1024; @@ -266,9 +269,9 @@ TEST_F(CPU_TEST, INSTR_MOV_RM_R_b16) { TEST_F(CPU_TEST, INSTR_MOV_RM_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1024; @@ -281,9 +284,9 @@ TEST_F(CPU_TEST, INSTR_MOV_RM_R_b32) { TEST_F(CPU_TEST, INSTR_MOV_RM_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::RM_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1024; @@ -296,8 +299,8 @@ TEST_F(CPU_TEST, INSTR_MOV_RM_R_b64) { TEST_F(CPU_TEST, INSTR_MOV_RM_M_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -311,8 +314,8 @@ TEST_F(CPU_TEST, INSTR_MOV_RM_M_b8) { TEST_F(CPU_TEST, INSTR_MOV_RM_M_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -326,8 +329,8 @@ TEST_F(CPU_TEST, INSTR_MOV_RM_M_b16) { TEST_F(CPU_TEST, INSTR_MOV_RM_M_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -341,8 +344,8 @@ TEST_F(CPU_TEST, INSTR_MOV_RM_M_b32) { TEST_F(CPU_TEST, INSTR_MOV_RM_M_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::RM_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1536); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -356,9 +359,9 @@ TEST_F(CPU_TEST, INSTR_MOV_RM_M_b64) { TEST_F(CPU_TEST, INSTR_MOV_M_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA; @@ -370,9 +373,9 @@ TEST_F(CPU_TEST, INSTR_MOV_M_R_b8) { TEST_F(CPU_TEST, INSTR_MOV_M_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA; @@ -384,9 +387,9 @@ TEST_F(CPU_TEST, INSTR_MOV_M_R_b16) { TEST_F(CPU_TEST, INSTR_MOV_M_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::XL0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA; @@ -398,9 +401,9 @@ TEST_F(CPU_TEST, INSTR_MOV_M_R_b32) { TEST_F(CPU_TEST, INSTR_MOV_M_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MOV); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::M_R); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); cpu.mem_controller->Load64(*cpu.xip + 3, 1024); - cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 11, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_MUL.cpp b/tests/Integration/EmulatorCore/CPU/CPU_MUL.cpp index 3b286cf7..898372db 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_MUL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_MUL.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x2; static constexpr std::uint8_t BYTE_DATA2 = 0x60; @@ -31,9 +31,9 @@ static constexpr std::uint64_t QWORD_SUM_OF = QWORD_DATA1_OF * QWORD_DATA2_OF; TEST_F(CPU_TEST, INSTR_MUL_R_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -46,9 +46,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_R_b8) { TEST_F(CPU_TEST, INSTR_MUL_R_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -61,9 +61,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_R_b16) { TEST_F(CPU_TEST, INSTR_MUL_R_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -76,9 +76,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_R_b32) { TEST_F(CPU_TEST, INSTR_MUL_R_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -91,9 +91,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_R_b64) { TEST_F(CPU_TEST, INSTR_MUL_R_RM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -107,9 +107,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_RM_b8) { TEST_F(CPU_TEST, INSTR_MUL_R_RM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -123,9 +123,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_RM_b16) { TEST_F(CPU_TEST, INSTR_MUL_R_RM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -139,9 +139,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_RM_b32) { TEST_F(CPU_TEST, INSTR_MUL_R_RM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -155,8 +155,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_RM_b64) { TEST_F(CPU_TEST, INSTR_MUL_R_M_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -170,8 +170,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_M_b8) { TEST_F(CPU_TEST, INSTR_MUL_R_M_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -185,8 +185,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_M_b16) { TEST_F(CPU_TEST, INSTR_MUL_R_M_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -200,8 +200,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_M_b32) { TEST_F(CPU_TEST, INSTR_MUL_R_M_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -215,8 +215,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_M_b64) { TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -229,8 +229,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b8) { TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -243,8 +243,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b16) { TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -257,8 +257,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b32) { TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -271,9 +271,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b64) { TEST_F(CPU_TEST, INSTR_MUL_R_R_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1_OF; @@ -287,9 +287,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_R_b8_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_R_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1_OF; @@ -303,9 +303,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_R_b16_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_R_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1_OF; @@ -319,9 +319,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_R_b32_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_R_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1_OF; @@ -335,9 +335,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_R_b64_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_RM_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1_OF; @@ -352,9 +352,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_RM_b8_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_RM_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1_OF; @@ -369,9 +369,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_RM_b16_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_RM_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1_OF; @@ -386,9 +386,9 @@ TEST_F(CPU_TEST, INSTR_MUL_R_RM_b32_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_RM_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1_OF; @@ -403,8 +403,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_RM_b64_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_M_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -419,8 +419,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_M_b8_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_M_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -435,8 +435,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_M_b16_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_M_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -451,8 +451,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_M_b32_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_M_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -467,8 +467,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_M_b64_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -482,8 +482,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b8_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -497,8 +497,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b16_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b32_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -512,8 +512,8 @@ TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b32_OF) { TEST_F(CPU_TEST, INSTR_MUL_R_IMM_b64_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::MUL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2_OF); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_OR.cpp b/tests/Integration/EmulatorCore/CPU/CPU_OR.cpp index 5cc1a2d9..840cd780 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_OR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_OR.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; @@ -18,9 +18,9 @@ static constexpr std::uint64_t QWORD_SUM = QWORD_DATA1 | QWORD_DATA2; TEST_F(CPU_TEST, INSTR_OR_R_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -33,9 +33,9 @@ TEST_F(CPU_TEST, INSTR_OR_R_R_b8) { TEST_F(CPU_TEST, INSTR_OR_R_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -48,9 +48,9 @@ TEST_F(CPU_TEST, INSTR_OR_R_R_b16) { TEST_F(CPU_TEST, INSTR_OR_R_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -63,9 +63,9 @@ TEST_F(CPU_TEST, INSTR_OR_R_R_b32) { TEST_F(CPU_TEST, INSTR_OR_R_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -78,9 +78,9 @@ TEST_F(CPU_TEST, INSTR_OR_R_R_b64) { TEST_F(CPU_TEST, INSTR_OR_R_RM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -94,9 +94,9 @@ TEST_F(CPU_TEST, INSTR_OR_R_RM_b8) { TEST_F(CPU_TEST, INSTR_OR_R_RM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -110,9 +110,9 @@ TEST_F(CPU_TEST, INSTR_OR_R_RM_b16) { TEST_F(CPU_TEST, INSTR_OR_R_RM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -126,9 +126,9 @@ TEST_F(CPU_TEST, INSTR_OR_R_RM_b32) { TEST_F(CPU_TEST, INSTR_OR_R_RM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -142,8 +142,8 @@ TEST_F(CPU_TEST, INSTR_OR_R_RM_b64) { TEST_F(CPU_TEST, INSTR_OR_R_M_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -157,8 +157,8 @@ TEST_F(CPU_TEST, INSTR_OR_R_M_b8) { TEST_F(CPU_TEST, INSTR_OR_R_M_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -172,8 +172,8 @@ TEST_F(CPU_TEST, INSTR_OR_R_M_b16) { TEST_F(CPU_TEST, INSTR_OR_R_M_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -187,8 +187,8 @@ TEST_F(CPU_TEST, INSTR_OR_R_M_b32) { TEST_F(CPU_TEST, INSTR_OR_R_M_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -202,8 +202,8 @@ TEST_F(CPU_TEST, INSTR_OR_R_M_b64) { TEST_F(CPU_TEST, INSTR_OR_R_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -216,8 +216,8 @@ TEST_F(CPU_TEST, INSTR_OR_R_IMM_b8) { TEST_F(CPU_TEST, INSTR_OR_R_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -230,8 +230,8 @@ TEST_F(CPU_TEST, INSTR_OR_R_IMM_b16) { TEST_F(CPU_TEST, INSTR_OR_R_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -244,8 +244,8 @@ TEST_F(CPU_TEST, INSTR_OR_R_IMM_b32) { TEST_F(CPU_TEST, INSTR_OR_R_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::OR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp b/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp index 03ca14c8..87217dad 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp @@ -1,9 +1,4 @@ -#include "Core/CPU/Instructions/Registers.hpp" -#include "pch.hpp" -#include -#include -#include -// TODO: fix include order +#include "tests/fixtures.hpp" // TODO: fix constexpr naming static constexpr std::uint8_t BYTE_DATA1 = 0x55; @@ -13,8 +8,8 @@ static constexpr std::uint64_t QWORD_DATA1 = 0x555555555555555; TEST_F(CPU_TEST, INSTR_POP_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::POP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -29,8 +24,8 @@ TEST_F(CPU_TEST, INSTR_POP_R_b8) { TEST_F(CPU_TEST, INSTR_POP_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::POP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -45,8 +40,8 @@ TEST_F(CPU_TEST, INSTR_POP_R_b16) { TEST_F(CPU_TEST, INSTR_POP_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::POP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -61,8 +56,8 @@ TEST_F(CPU_TEST, INSTR_POP_R_b32) { TEST_F(CPU_TEST, INSTR_POP_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::POP); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp b/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp index ffb4f0cd..68e680d6 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp @@ -1,8 +1,4 @@ -#include "Core/CPU/Instructions/Registers.hpp" -#include "pch.hpp" -#include -#include -#include +#include "tests/fixtures.hpp" // TODO: fix include order // TODO: fix constexpr naming @@ -13,8 +9,8 @@ static constexpr std::uint64_t QWORD_DATA1 = 0x555555555555555; TEST_F(CPU_TEST, INSTR_PUSH_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::PUSH); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -28,8 +24,8 @@ TEST_F(CPU_TEST, INSTR_PUSH_R_b8) { TEST_F(CPU_TEST, INSTR_PUSH_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::PUSH); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -43,8 +39,8 @@ TEST_F(CPU_TEST, INSTR_PUSH_R_b16) { TEST_F(CPU_TEST, INSTR_PUSH_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::PUSH); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -58,8 +54,8 @@ TEST_F(CPU_TEST, INSTR_PUSH_R_b32) { TEST_F(CPU_TEST, INSTR_PUSH_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::PUSH); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -73,7 +69,7 @@ TEST_F(CPU_TEST, INSTR_PUSH_R_b64) { TEST_F(CPU_TEST, INSTR_PUSH_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::PUSH); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, BYTE_DATA1); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); @@ -87,7 +83,7 @@ TEST_F(CPU_TEST, INSTR_PUSH_IMM_b8) { TEST_F(CPU_TEST, INSTR_PUSH_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::PUSH); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load16(*cpu.xip + 3, WORD_DATA1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -101,7 +97,7 @@ TEST_F(CPU_TEST, INSTR_PUSH_IMM_b16) { TEST_F(CPU_TEST, INSTR_PUSH_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::PUSH); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load32(*cpu.xip + 3, DWORD_DATA1); cpu.mem_controller->Load16(*cpu.xip + 7, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 9, HyperCPU::OperandTypes::NONE); @@ -115,7 +111,7 @@ TEST_F(CPU_TEST, INSTR_PUSH_IMM_b32) { TEST_F(CPU_TEST, INSTR_PUSH_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::PUSH); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, QWORD_DATA1); cpu.mem_controller->Load16(*cpu.xip + 11, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 13, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_READ.cpp b/tests/Integration/EmulatorCore/CPU/CPU_READ.cpp index ae0fc62a..75b4df26 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_READ.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_READ.cpp @@ -1,6 +1,4 @@ -#include "Core/CPU/Instructions/Flags.hpp" -#include "pch.hpp" -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_READ) { cpu.read_io_handlers[1] = []() -> std::uint8_t { @@ -8,7 +6,7 @@ TEST_F(CPU_TEST, INSTR_READ) { }; cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::READ); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::IMM); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load8(*cpu.xip + 3, 1); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_SHFL.cpp b/tests/Integration/EmulatorCore/CPU/CPU_SHFL.cpp index 9e2dbe42..40601912 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_SHFL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_SHFL.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x4; @@ -18,9 +18,9 @@ static constexpr std::uint64_t QWORD_SUM = static_cast(QWORD_DATA TEST_F(CPU_TEST, INSTR_SHFL_R_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -33,9 +33,9 @@ TEST_F(CPU_TEST, INSTR_SHFL_R_R_b8) { TEST_F(CPU_TEST, INSTR_SHFL_R_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -48,9 +48,9 @@ TEST_F(CPU_TEST, INSTR_SHFL_R_R_b16) { TEST_F(CPU_TEST, INSTR_SHFL_R_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -63,9 +63,9 @@ TEST_F(CPU_TEST, INSTR_SHFL_R_R_b32) { TEST_F(CPU_TEST, INSTR_SHFL_R_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -78,8 +78,8 @@ TEST_F(CPU_TEST, INSTR_SHFL_R_R_b64) { TEST_F(CPU_TEST, INSTR_SHFL_R_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -92,8 +92,8 @@ TEST_F(CPU_TEST, INSTR_SHFL_R_IMM_b8) { TEST_F(CPU_TEST, INSTR_SHFL_R_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -106,8 +106,8 @@ TEST_F(CPU_TEST, INSTR_SHFL_R_IMM_b16) { TEST_F(CPU_TEST, INSTR_SHFL_R_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -120,8 +120,8 @@ TEST_F(CPU_TEST, INSTR_SHFL_R_IMM_b32) { TEST_F(CPU_TEST, INSTR_SHFL_R_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFL); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_SHFR.cpp b/tests/Integration/EmulatorCore/CPU/CPU_SHFR.cpp index cea64726..774046b3 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_SHFR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_SHFR.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x4; @@ -18,9 +18,9 @@ static constexpr std::uint64_t QWORD_SUM = static_cast(QWORD_DATA TEST_F(CPU_TEST, INSTR_SHFR_R_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -33,9 +33,9 @@ TEST_F(CPU_TEST, INSTR_SHFR_R_R_b8) { TEST_F(CPU_TEST, INSTR_SHFR_R_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -48,9 +48,9 @@ TEST_F(CPU_TEST, INSTR_SHFR_R_R_b16) { TEST_F(CPU_TEST, INSTR_SHFR_R_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -63,9 +63,9 @@ TEST_F(CPU_TEST, INSTR_SHFR_R_R_b32) { TEST_F(CPU_TEST, INSTR_SHFR_R_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -78,8 +78,8 @@ TEST_F(CPU_TEST, INSTR_SHFR_R_R_b64) { TEST_F(CPU_TEST, INSTR_SHFR_R_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -92,8 +92,8 @@ TEST_F(CPU_TEST, INSTR_SHFR_R_IMM_b8) { TEST_F(CPU_TEST, INSTR_SHFR_R_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -106,8 +106,8 @@ TEST_F(CPU_TEST, INSTR_SHFR_R_IMM_b16) { TEST_F(CPU_TEST, INSTR_SHFR_R_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -120,8 +120,8 @@ TEST_F(CPU_TEST, INSTR_SHFR_R_IMM_b32) { TEST_F(CPU_TEST, INSTR_SHFR_R_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SHFR); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_SUB.cpp b/tests/Integration/EmulatorCore/CPU/CPU_SUB.cpp index bfb178b2..65180c8d 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_SUB.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_SUB.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x60; static constexpr std::uint8_t BYTE_DATA2 = 0x55; @@ -31,9 +31,9 @@ static constexpr std::uint64_t QWORD_RESULT_UF = QWORD_DATA1_UF - QWORD_DATA2_UF TEST_F(CPU_TEST, INSTR_SUB_R_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -46,9 +46,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_R_b8) { TEST_F(CPU_TEST, INSTR_SUB_R_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -61,9 +61,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_R_b16) { TEST_F(CPU_TEST, INSTR_SUB_R_R_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -76,9 +76,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_R_b32) { TEST_F(CPU_TEST, INSTR_SUB_R_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -91,9 +91,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_R_b64) { TEST_F(CPU_TEST, INSTR_SUB_R_RM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1; @@ -107,9 +107,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_RM_b8) { TEST_F(CPU_TEST, INSTR_SUB_R_RM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1; @@ -123,9 +123,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_RM_b16) { TEST_F(CPU_TEST, INSTR_SUB_R_RM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1; @@ -139,9 +139,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_RM_b32) { TEST_F(CPU_TEST, INSTR_SUB_R_RM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1; @@ -155,8 +155,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_RM_b64) { TEST_F(CPU_TEST, INSTR_SUB_R_M_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -170,8 +170,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_M_b8) { TEST_F(CPU_TEST, INSTR_SUB_R_M_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -185,8 +185,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_M_b16) { TEST_F(CPU_TEST, INSTR_SUB_R_M_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -200,8 +200,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_M_b32) { TEST_F(CPU_TEST, INSTR_SUB_R_M_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -215,8 +215,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_M_b64) { TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -229,8 +229,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b8) { TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -243,8 +243,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b16) { TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b32) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -257,8 +257,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b32) { TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -271,9 +271,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b64) { TEST_F(CPU_TEST, INSTR_SUB_R_R_b8_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1_UF; @@ -287,9 +287,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_R_b8_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_R_b16_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XLL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XLL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1_UF; @@ -303,9 +303,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_R_b16_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_R_b32_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::XL1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::XL1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1_UF; @@ -319,9 +319,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_R_b32_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_R_b64_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_R); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1_UF; @@ -335,9 +335,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_R_b64_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_RM_b8_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xlll0 = BYTE_DATA1_UF; @@ -352,9 +352,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_RM_b8_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_RM_b16_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xll0 = WORD_DATA1_UF; @@ -369,9 +369,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_RM_b16_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_RM_b32_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.xl0 = DWORD_DATA1_UF; @@ -386,9 +386,9 @@ TEST_F(CPU_TEST, INSTR_SUB_R_RM_b32_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_RM_b64_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_RM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); - cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Registers::X1); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); + cpu.mem_controller->Load8(*cpu.xip + 4, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); *cpu.x0 = QWORD_DATA1_UF; @@ -403,8 +403,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_RM_b64_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_M_b8_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -419,8 +419,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_M_b8_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_M_b16_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -435,8 +435,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_M_b16_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_M_b32_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -451,8 +451,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_M_b32_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_M_b64_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_M); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, 1024); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); @@ -467,8 +467,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_M_b64_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b8_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b8 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, BYTE_DATA2_UF); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); @@ -482,8 +482,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b8_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b16_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b16 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, WORD_DATA2_UF); cpu.mem_controller->Load16(*cpu.xip + 6, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 8, HyperCPU::OperandTypes::NONE); @@ -497,8 +497,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b16_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b32_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b32 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XL0); cpu.mem_controller->Load32(*cpu.xip + 4, DWORD_DATA2_UF); cpu.mem_controller->Load16(*cpu.xip + 8, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 10, HyperCPU::OperandTypes::NONE); @@ -512,8 +512,8 @@ TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b32_UF) { TEST_F(CPU_TEST, INSTR_SUB_R_IMM_b64_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::SUB); - cpu.mem_controller->Load8(*cpu.xip + 2, HyperCPU::Mode::b64 << 4 | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::X0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X0); cpu.mem_controller->Load64(*cpu.xip + 4, QWORD_DATA2_UF); cpu.mem_controller->Load16(*cpu.xip + 12, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 14, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_WRITE.cpp b/tests/Integration/EmulatorCore/CPU/CPU_WRITE.cpp index 8679dbc4..982582ff 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_WRITE.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_WRITE.cpp @@ -1,7 +1,4 @@ -#include "Core/CPU/Instructions/Registers.hpp" -#include "pch.hpp" -#include -#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_WRITE) { std::uint8_t t = 0; @@ -11,8 +8,8 @@ TEST_F(CPU_TEST, INSTR_WRITE) { }; cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::WRITE); - cpu.mem_controller->Load8(*cpu.xip + 2, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); - cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Registers::XLLL0); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); + cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load8(*cpu.xip + 4, 0x55); cpu.mem_controller->Load16(*cpu.xip + 5, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 7, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/OperandsEvaluation.cpp b/tests/Integration/EmulatorCore/CPU/OperandsEvaluation.cpp index 3491436d..f60a7c53 100644 --- a/tests/Integration/EmulatorCore/CPU/OperandsEvaluation.cpp +++ b/tests/Integration/EmulatorCore/CPU/OperandsEvaluation.cpp @@ -1,172 +1,172 @@ -#include -#include +#include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" +#include -#include +#include "tests/fixtures.hpp" TEST_F(OPERAND_EVAL_TEST, PROPER_REGISTERS_EVALUATION) { HyperCPU::OperandContainer arg = 0; - HyperCPU::Registers reg; + HyperCPU::Reg reg; - reg = HyperCPU::Registers::X0; + reg = HyperCPU::Reg::X0; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.x0); - reg = HyperCPU::Registers::X1; + reg = HyperCPU::Reg::X1; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.x1); - reg = HyperCPU::Registers::X2; + reg = HyperCPU::Reg::X2; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.x2); - reg = HyperCPU::Registers::X3; + reg = HyperCPU::Reg::X3; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.x3); - reg = HyperCPU::Registers::X4; + reg = HyperCPU::Reg::X4; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.x4); - reg = HyperCPU::Registers::X5; + reg = HyperCPU::Reg::X5; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.x5); - reg = HyperCPU::Registers::X6; + reg = HyperCPU::Reg::X6; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.x6); - reg = HyperCPU::Registers::X7; + reg = HyperCPU::Reg::X7; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.x7); - reg = HyperCPU::Registers::XH0; + reg = HyperCPU::Reg::XH0; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xh0); - reg = HyperCPU::Registers::XH1; + reg = HyperCPU::Reg::XH1; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xh1); - reg = HyperCPU::Registers::XH2; + reg = HyperCPU::Reg::XH2; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xh2); - reg = HyperCPU::Registers::XH3; + reg = HyperCPU::Reg::XH3; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xh3); - reg = HyperCPU::Registers::XH4; + reg = HyperCPU::Reg::XH4; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xh4); - reg = HyperCPU::Registers::XH5; + reg = HyperCPU::Reg::XH5; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xh5); - reg = HyperCPU::Registers::XH6; + reg = HyperCPU::Reg::XH6; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xh6); - reg = HyperCPU::Registers::XH7; + reg = HyperCPU::Reg::XH7; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xh7); - reg = HyperCPU::Registers::XL0; + reg = HyperCPU::Reg::XL0; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xl0); - reg = HyperCPU::Registers::XL1; + reg = HyperCPU::Reg::XL1; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xl1); - reg = HyperCPU::Registers::XL2; + reg = HyperCPU::Reg::XL2; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xl2); - reg = HyperCPU::Registers::XL3; + reg = HyperCPU::Reg::XL3; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xl3); - reg = HyperCPU::Registers::XL4; + reg = HyperCPU::Reg::XL4; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xl4); - reg = HyperCPU::Registers::XL5; + reg = HyperCPU::Reg::XL5; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xl5); - reg = HyperCPU::Registers::XL6; + reg = HyperCPU::Reg::XL6; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xl6); - reg = HyperCPU::Registers::XL7; + reg = HyperCPU::Reg::XL7; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xl7); - reg = HyperCPU::Registers::XLL0; + reg = HyperCPU::Reg::XLL0; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xll0); - reg = HyperCPU::Registers::XLL1; + reg = HyperCPU::Reg::XLL1; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xll1); - reg = HyperCPU::Registers::XLL2; + reg = HyperCPU::Reg::XLL2; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xll2); - reg = HyperCPU::Registers::XLL3; + reg = HyperCPU::Reg::XLL3; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xll3); - reg = HyperCPU::Registers::XLLL0; + reg = HyperCPU::Reg::XLLL0; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xlll0); - reg = HyperCPU::Registers::XLLL1; + reg = HyperCPU::Reg::XLLL1; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xlll1); - reg = HyperCPU::Registers::XLLL2; + reg = HyperCPU::Reg::XLLL2; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xlll2); - reg = HyperCPU::Registers::XLLL3; + reg = HyperCPU::Reg::XLLL3; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xlll3); - reg = HyperCPU::Registers::XLLH0; + reg = HyperCPU::Reg::XLLH0; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xllh0); - reg = HyperCPU::Registers::XLLH1; + reg = HyperCPU::Reg::XLLH1; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xllh1); - reg = HyperCPU::Registers::XLLH2; + reg = HyperCPU::Reg::XLLH2; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xllh2); - reg = HyperCPU::Registers::XLLH3; + reg = HyperCPU::Reg::XLLH3; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xllh3); - reg = HyperCPU::Registers::XBP; + reg = HyperCPU::Reg::XBP; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xbp); - reg = HyperCPU::Registers::XSP; + reg = HyperCPU::Reg::XSP; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xsp); - reg = HyperCPU::Registers::XIP; + reg = HyperCPU::Reg::XIP; arg = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg)}; ASSERT_EQ(cpu.GetRegister(arg), cpu.xip); } TEST_F(OPERAND_EVAL_TEST, PROPER_R_R_EVALUATION) { HyperCPU::OperandContainer arg1, arg2; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0, reg2 = HyperCPU::Registers::X1; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0, reg2 = HyperCPU::Reg::X1; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg2)}; @@ -179,7 +179,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_R_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_R_RM_EVALUATION) { HyperCPU::OperandContainer arg1, arg2; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0, reg2 = HyperCPU::Registers::X1; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0, reg2 = HyperCPU::Reg::X1; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg2)}; @@ -192,7 +192,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_RM_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_RM_R_EVALUATION) { HyperCPU::OperandContainer arg1, arg2; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0, reg2 = HyperCPU::Registers::X1; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0, reg2 = HyperCPU::Reg::X1; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg2)}; @@ -205,7 +205,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_RM_R_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_RM_M_EVALUATION) { HyperCPU::OperandContainer arg1, arg2 = HyperCPU::OperandContainer{1024ULL}; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; result = cpu.GetOperands(HyperCPU::OperandTypes::RM_M, @@ -217,7 +217,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_RM_M_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_R_M_EVALUATION) { HyperCPU::OperandContainer arg1, arg2 = HyperCPU::OperandContainer{1024}; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; result = cpu.GetOperands(HyperCPU::OperandTypes::R_M, @@ -230,7 +230,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_M_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_RM_IMM_B8_EVALUATION) { HyperCPU::OperandContainer arg1, arg2, arg3 = HyperCPU::OperandContainer{0xFF}; std::uint8_t imm; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; @@ -245,7 +245,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_RM_IMM_B8_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_RM_IMM_B16_EVALUATION) { HyperCPU::OperandContainer arg1, arg2, arg3 = HyperCPU::OperandContainer{0xFFFF}; std::uint16_t imm; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; result = cpu.GetOperands(HyperCPU::OperandTypes::RM_IMM, @@ -259,7 +259,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_RM_IMM_B16_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_RM_IMM_B32_EVALUATION) { HyperCPU::OperandContainer arg1, arg2, arg3 = HyperCPU::OperandContainer{0xFFFFFFFF}; std::uint32_t imm; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; @@ -274,7 +274,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_RM_IMM_B32_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_RM_IMM_B64_EVALUATION) { HyperCPU::OperandContainer arg1, arg2, arg3 = HyperCPU::OperandContainer{0xFFFFFFFFFFFFFFFF}; std::uint64_t imm; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; @@ -289,7 +289,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_RM_IMM_B64_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_R_IMM_B8_EVALUATION) { HyperCPU::OperandContainer arg1, arg2, arg3 = HyperCPU::OperandContainer{0xFF}; std::uint8_t imm; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; @@ -304,7 +304,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_IMM_B8_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_R_IMM_B16_EVALUATION) { HyperCPU::OperandContainer arg1, arg2, arg3 = HyperCPU::OperandContainer{0xFFFF}; std::uint16_t imm; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; @@ -319,7 +319,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_IMM_B16_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_R_IMM_B32_EVALUATION) { HyperCPU::OperandContainer arg1, arg2, arg3 = HyperCPU::OperandContainer{0xFFFFFFFF}; std::uint32_t imm; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; @@ -334,7 +334,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_IMM_B32_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_R_IMM_B64_EVALUATION) { HyperCPU::OperandContainer arg1, arg2, arg3 = HyperCPU::OperandContainer{0xFFFFFFFFFFFFFFFF}; std::uint64_t imm; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(arg3)}; @@ -348,7 +348,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_R_IMM_B64_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_M_R_EVALUATION) { HyperCPU::OperandContainer arg1 = HyperCPU::OperandContainer{1024}, arg2; - HyperCPU::Registers reg2 = HyperCPU::Registers::X0; + HyperCPU::Reg reg2 = HyperCPU::Reg::X0; arg2 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg2)}; result = cpu.GetOperands(HyperCPU::OperandTypes::M_R, @@ -360,7 +360,7 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_M_R_EVALUATION) { TEST_F(OPERAND_EVAL_TEST, PROPER_R_EVALUATION) { HyperCPU::OperandContainer arg1, arg2; - HyperCPU::Registers reg1 = HyperCPU::Registers::X0; + HyperCPU::Reg reg1 = HyperCPU::Reg::X0; arg1 = HyperCPU::OperandContainer{HyperCPU::bit_cast(reg1)}; result = cpu.GetOperands(HyperCPU::OperandTypes::R, @@ -388,4 +388,4 @@ TEST_F(OPERAND_EVAL_TEST, PROPER_NONE_EVALUATION) { ASSERT_EQ(result.first.ptr(), nullptr); ASSERT_EQ(result.second.ptr(), nullptr); -} \ No newline at end of file +} diff --git a/tests/fixtures.hpp b/tests/fixtures.hpp index 7774e2c3..2f234c5f 100644 --- a/tests/fixtures.hpp +++ b/tests/fixtures.hpp @@ -224,3 +224,7 @@ class TWO_OPERANDS_FAILURE : public ::testing::Test { HCAsm::current_index = 0; } }; + +constexpr inline std::uint8_t EncodeTestFlags(HyperCPU::Mode md, HyperCPU::OperandTypes types) { + return (static_cast(md) << 4) | static_cast(types); +} From ad323899790f5cc532e6b59e98189e4e07779372 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sat, 10 May 2025 14:41:13 +0300 Subject: [PATCH 23/40] added versioning --- MODULE.bazel | 1 + tools/increment_version.py | 133 +++++++++++++++++++++++++++++++++++++ 2 files changed, 134 insertions(+) create mode 100644 tools/increment_version.py diff --git a/MODULE.bazel b/MODULE.bazel index 90887760..5174fa20 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -2,6 +2,7 @@ module( name = 'hyper-cpu', + version = '0.4.13', compatibility_level = 1 ) diff --git a/tools/increment_version.py b/tools/increment_version.py new file mode 100644 index 00000000..e7a456f4 --- /dev/null +++ b/tools/increment_version.py @@ -0,0 +1,133 @@ +from dataclasses import dataclass +from pathlib import Path +from typing import Callable, Union +from functools import wraps +from io import StringIO +import re +import argparse +import inspect + + +# version increment happens to files, so each method +# that updates version has a certain file that it processes +def dispatching_file(file: Union[Path, str]): + def factory(func: Callable): + nonlocal file + if not isinstance(file, Path): + file = Path(file) + setattr(func, 'is_dispatcher', True) + setattr(func, 'file', file) + + @wraps(func) + def dispatcher(*args, **kwargs): + return func(*args, file=file, **kwargs) + + return factory + + +# We follow SemVer: https://semver.org/ +@dataclass +class Version: + major: int + minor: int + patch: int + + def __str__(self) -> str: + return f'{self.major}.{self.minor}.{self.patch}' + + @classmethod + def from_str(cls, s: str) -> 'Version': + major, minor, patch = map(int, s.split('.')) + return cls(major=major, minor=minor, patch=patch) + + +class Incrementors: + def fetch_version(self) -> Version: + # we fetch current version from bazel module + with open('MODULE.bazel', 'r') as fd: + contents = fd.read() + + module = self.__bazel_find_module(contents) + current_version = self.__bazel_find_version(module) + + grouping = r'(.*)=[\'\"](.*)[\'\"]' + if (result := re.search(grouping, current_version)) is None: + raise ValueError(f'could not apply grouping: {grouping}') + + version_str = result.group(1) + return Version.from_str(version_str) + + @dispatching_file('src/Common/Version.hpp') + def update_version_file(self, file: Path, version: Version): + contents = StringIO() + version_matches = 0 + + with open(file, 'r') as fd: + for line in fd: + if 'HCPU_VERSION' not in line.upper(): + contents.write(line + '\n') + continue + + version_matches += 1 + prefix, _ = line.split('=') + contents.write(f'{prefix} = "{str(version)}";\n') + + if version_matches < 1: + raise ValueError('could not find a line with version string') + if version_matches > 1: + raise ValueError(f'found {version_matches} lines with version string, expected a single line') + + with open(file, 'w') as fd: + fd.write(contents.getvalue()) + + @dispatching_file('MODULE.bazel') + def update_module_file(self, file: Path, version = Version): + with open(file, 'r') as fd: + contents = fd.read() + + module = self.__bazel_find_module(contents) + current_version = self.__bazel_find_version(module) + newly_versioned_module = module.replace(current_version, 'version = ' + str(version)) + contents = contents.replace(module, newly_versioned_module) + + with open(file, 'w') as fd: + fd.write(contents) + + def __bazel_find_module(self, contents: str) -> str: + module_pattern = r'module\(.*\)' + matches = re.findall(module_pattern, contents) + if len(matches) != 1: + raise ValueError(f'regex {module_pattern} matched {len(matches)} times, expected to match only once') + + return matches[0] + + def __bazel_find_version(self, module: str) -> str: + version_pattern = r'version\s*=\s*[\'\"].*[\'\"]' + matches = re.findall(version_pattern, module) + if len(matches) != 1: + raise ValueError(f'regex {version_pattern} matched {len(matches)} times, expected to match only once') + + return matches[0] + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--increment', action='store', dest='target', choices=['patch', 'minor']) + args = parser.parse_args() + + incrementors = Incrementors() + new_version = incrementors.fetch_version() + match args.target: + case 'patch': + new_version.patch += 1 + case 'minor': + new_version.patch = 0 + new_version.minor += 1 + + for name, method in inspect.getmembers(incrementors, predicate=inspect.ismethod): + if hasattr(method, 'is_dispatcher'): + method(version=new_version) + + +if __name__ == '__main__': + main() From 64fbb2af2cd14ca4bd6e138f73b3ef8df1f12a77 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sat, 10 May 2025 15:43:47 +0300 Subject: [PATCH 24/40] renew incrementor script --- .github/workflows/version-increment.yml | 21 ++++++++++----------- tools/increment_minor.sh | 20 -------------------- tools/increment_patch.sh | 19 ------------------- tools/increment_version.py | 20 ++++++++++++-------- 4 files changed, 22 insertions(+), 58 deletions(-) delete mode 100755 tools/increment_minor.sh delete mode 100755 tools/increment_patch.sh mode change 100644 => 100755 tools/increment_version.py diff --git a/.github/workflows/version-increment.yml b/.github/workflows/version-increment.yml index c63d7919..b221fad3 100644 --- a/.github/workflows/version-increment.yml +++ b/.github/workflows/version-increment.yml @@ -12,20 +12,20 @@ jobs: if: "contains(github.event.head_commit.message, '[ci patch inc]')" permissions: contents: write - + steps: - name: Checkout code uses: actions/checkout@v4 with: - fetch-depth: '0' + fetch-depth: "0" - name: Setup git user uses: fregante/setup-git-user@v1 - - name: Increment version + - name: Increment version (patch) run: | - scripts/increment_patch.sh - + tools/increment_version.py --increment patch + - name: Push changes to master branch run: | git config --global --add safe.directory '*' @@ -39,24 +39,23 @@ jobs: if: "contains(github.event.head_commit.message, '[ci minor inc]')" permissions: contents: write - + steps: - name: Checkout code uses: actions/checkout@v4 with: - fetch-depth: '0' + fetch-depth: "0" - name: Setup git user uses: fregante/setup-git-user@v1 - - name: Increment version + - name: Increment version (minor) run: | - scripts/increment_minor.sh - + tools/increment_version.py --increment minor + - name: Push changes to master branch run: | git config --global --add safe.directory '*' git add . git commit -m "[auto]: Increment minor version" git push origin master - diff --git a/tools/increment_minor.sh b/tools/increment_minor.sh deleted file mode 100755 index dc745e35..00000000 --- a/tools/increment_minor.sh +++ /dev/null @@ -1,20 +0,0 @@ -#!/bin/bash - -# Setup variables -HEADER="src/Version.hpp" -STR=$(cat $HEADER) -LEN=${#STR} - -# Split version using custom delimiter -IFS='.' read -r VMAJOR VMINOR VPATCH <<< $(echo $STR | awk '{print $6}' | cut -b 2-$((LEN - 41)) -) - -# Increment minor version, resetting patch -VMINOR=$((VMINOR + 1)) -VPATCH=0 - -# Build string and write it back -STR="static constexpr char HCPU_VERSION[] = \"$VMAJOR.$VMINOR.$VPATCH\";" -echo "$STR" > "$HEADER" - -# Update version in README -sed -i 's/ "$HEADER" - -# Update version in README -sed -i 's/ Version: module = self.__bazel_find_module(contents) current_version = self.__bazel_find_version(module) - grouping = r'(.*)=[\'\"](.*)[\'\"]' - if (result := re.search(grouping, current_version)) is None: + grouping = r'(.*)=\s*[\'\"](.*)[\'\"]' + if (result := re.search(grouping, current_version, flags=re.DOTALL)) is None: raise ValueError(f'could not apply grouping: {grouping}') - version_str = result.group(1) + version_str = result.group(2) return Version.from_str(version_str) @dispatching_file('src/Common/Version.hpp') @@ -70,7 +74,7 @@ def update_version_file(self, file: Path, version: Version): version_matches += 1 prefix, _ = line.split('=') - contents.write(f'{prefix} = "{str(version)}";\n') + contents.write(f'{prefix.strip()} = "{str(version)}";\n') if version_matches < 1: raise ValueError('could not find a line with version string') @@ -87,15 +91,15 @@ def update_module_file(self, file: Path, version = Version): module = self.__bazel_find_module(contents) current_version = self.__bazel_find_version(module) - newly_versioned_module = module.replace(current_version, 'version = ' + str(version)) + newly_versioned_module = module.replace(current_version, f'version = \'{str(version)}\'') contents = contents.replace(module, newly_versioned_module) with open(file, 'w') as fd: fd.write(contents) def __bazel_find_module(self, contents: str) -> str: - module_pattern = r'module\(.*\)' - matches = re.findall(module_pattern, contents) + module_pattern = r'module\(.*?\)' + matches = re.findall(module_pattern, contents, flags=re.DOTALL) if len(matches) != 1: raise ValueError(f'regex {module_pattern} matched {len(matches)} times, expected to match only once') @@ -103,7 +107,7 @@ def __bazel_find_module(self, contents: str) -> str: def __bazel_find_version(self, module: str) -> str: version_pattern = r'version\s*=\s*[\'\"].*[\'\"]' - matches = re.findall(version_pattern, module) + matches = re.findall(version_pattern, module, flags=re.DOTALL) if len(matches) != 1: raise ValueError(f'regex {version_pattern} matched {len(matches)} times, expected to match only once') From 8263ee77b6b7cdb21b36432b138b301020303269 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sat, 10 May 2025 16:32:58 +0300 Subject: [PATCH 25/40] fix linking --- src/Assembler/BUILD.bazel | 6 +++--- src/Assembler/{Main => }/Main.cpp | 0 src/Emulator/BUILD.bazel | 4 ++-- src/Emulator/{Main => }/Main.cpp | 0 tests/BUILD.bazel | 5 ++++- tests/Integration/BUILD.bazel | 3 ++- 6 files changed, 11 insertions(+), 7 deletions(-) rename src/Assembler/{Main => }/Main.cpp (100%) rename src/Emulator/{Main => }/Main.cpp (100%) diff --git a/src/Assembler/BUILD.bazel b/src/Assembler/BUILD.bazel index e94fef21..b8238991 100644 --- a/src/Assembler/BUILD.bazel +++ b/src/Assembler/BUILD.bazel @@ -8,8 +8,8 @@ package( cc_library( name = 'assembler_core', - srcs = glob(['**/*.cpp'], exclude = ['Main']), - hdrs = glob(['**/*.hpp'], exclude = ['Main']), + srcs = glob(['**/*.cpp'], exclude = ['Main.cpp']), + hdrs = glob(['**/*.hpp']), strip_include_prefix = '/src', visibility = [ '//tests:__subpackages__', @@ -30,7 +30,7 @@ cc_library( cc_binary( name = 'hcasm', - srcs = glob(['Main/**/*.cpp']), + srcs = ['Main.cpp'], deps = [ ':assembler_core', # TODO: research why direct deps do not provide system headers diff --git a/src/Assembler/Main/Main.cpp b/src/Assembler/Main.cpp similarity index 100% rename from src/Assembler/Main/Main.cpp rename to src/Assembler/Main.cpp diff --git a/src/Emulator/BUILD.bazel b/src/Emulator/BUILD.bazel index 39ce029f..125af838 100644 --- a/src/Emulator/BUILD.bazel +++ b/src/Emulator/BUILD.bazel @@ -2,7 +2,7 @@ load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') cc_library( name = 'emulator_core', - srcs = glob(['**/*.cpp']), + srcs = glob(['**/*.cpp'], exclude = ['Main.cpp']), hdrs = glob(['**/*.hpp']), visibility = [ '//tests:__subpackages__' @@ -19,7 +19,7 @@ cc_library( cc_binary( name = 'hcemul', - srcs = glob(['**/*.cpp']), + srcs = ['Main.cpp'], deps = [ ':emulator_core' ] diff --git a/src/Emulator/Main/Main.cpp b/src/Emulator/Main.cpp similarity index 100% rename from src/Emulator/Main/Main.cpp rename to src/Emulator/Main.cpp diff --git a/tests/BUILD.bazel b/tests/BUILD.bazel index 210a8669..8752a762 100644 --- a/tests/BUILD.bazel +++ b/tests/BUILD.bazel @@ -17,5 +17,8 @@ precompiled_headers( cc_library( name = 'test_fixtures', - hdrs = ['fixtures.hpp'] + hdrs = ['fixtures.hpp'], + deps = [ + '//src/PCH:pch_cstd' + ] ) diff --git a/tests/Integration/BUILD.bazel b/tests/Integration/BUILD.bazel index 93949404..10679124 100644 --- a/tests/Integration/BUILD.bazel +++ b/tests/Integration/BUILD.bazel @@ -3,6 +3,7 @@ load('@rules_cc//cc:defs.bzl', 'cc_test') cc_test( name = 'integration-test', + linkstatic = True, srcs = glob(['**/*.cpp']), deps = [ '//src/PCH:pch_cstd', @@ -10,7 +11,7 @@ cc_test( '//src/Assembler:assembler_core', '//src/Emulator:emulator_core', '//tests:test_fixtures', - '@gtest//:gtest', + '@gtest//:gtest-gmock_main', '@fmt//:fmt' ] ) From b459cb9dda23af22308cc3fc6ca569c521b79188 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sun, 11 May 2025 00:34:14 +0300 Subject: [PATCH 26/40] refactor stuff a little --- CMakeLists.txt | 102 ------------- src/Assembler/BUILD.bazel | 30 ++-- src/Assembler/CMakeLists.txt | 35 ----- src/BacktraceProvider/BUILD.bazel | 15 +- src/BacktraceProvider/CMakeLists.txt | 22 --- src/CMakeLists.txt | 8 - src/Common/BUILD.bazel | 9 +- src/Common/CMakeLists.txt | 17 --- src/Emulator/BUILD.bazel | 11 +- src/Emulator/CMakeLists.txt | 98 ------------ src/PCH/BUILD.bazel | 9 +- src/PCH/CMakeLists.txt | 4 - src/Pog/BUILD.bazel | 12 +- src/Pog/CMakeLists.txt | 41 ----- tests/CMakeLists.txt | 10 -- tests/Integration/CMakeLists.txt | 67 --------- tests/Modular/CMakeLists.txt | 141 ------------------ tests/Pog/CMakeLists.txt | 44 ------ tests/Python/Buildsystem/CMakeLists.txt | 21 --- .../Buildsystem/DummyProject/CMakeLists.txt | 21 --- .../Buildsystem/DummyProject/conanfile.py | 20 --- .../Python/Buildsystem/DummyProject/main.cpp | 13 -- tests/Python/Buildsystem/test_build.py | 99 ------------ 23 files changed, 28 insertions(+), 821 deletions(-) delete mode 100644 CMakeLists.txt delete mode 100644 src/Assembler/CMakeLists.txt delete mode 100644 src/BacktraceProvider/CMakeLists.txt delete mode 100644 src/CMakeLists.txt delete mode 100644 src/Common/CMakeLists.txt delete mode 100644 src/Emulator/CMakeLists.txt delete mode 100644 src/PCH/CMakeLists.txt delete mode 100644 src/Pog/CMakeLists.txt delete mode 100644 tests/CMakeLists.txt delete mode 100644 tests/Integration/CMakeLists.txt delete mode 100644 tests/Modular/CMakeLists.txt delete mode 100644 tests/Pog/CMakeLists.txt delete mode 100644 tests/Python/Buildsystem/CMakeLists.txt delete mode 100644 tests/Python/Buildsystem/DummyProject/CMakeLists.txt delete mode 100644 tests/Python/Buildsystem/DummyProject/conanfile.py delete mode 100644 tests/Python/Buildsystem/DummyProject/main.cpp delete mode 100644 tests/Python/Buildsystem/test_build.py diff --git a/CMakeLists.txt b/CMakeLists.txt deleted file mode 100644 index 2a7e3ea5..00000000 --- a/CMakeLists.txt +++ /dev/null @@ -1,102 +0,0 @@ -cmake_minimum_required(VERSION 3.22..3.25) - -project(HyperCPU CXX) - -option(HCPU_LTO "HCPU: Enable LTO if possible" OFF) -option(HCPU_NATIVE_OPTIMIZATIONS "HCPU: Optimize for current ISA implementation" OFF) -option(HCPU_SANITIZERS "HCPU: Enable sanitizers" OFF) -option(HCPU_BUILD_TESTS "HCPU: Build tests" ON) -option(HCPU_BUILD_BENCHMARKS "HCPU: Build benchmarks" OFF) - -find_package(GTest 1.14.0 REQUIRED) # GoogleTest -find_package(benchmark 1.9.1 REQUIRED) # Google Benchmark -find_package(absl 20240116.1 REQUIRED) # Abseil (CMake target: absl::absl) -find_package(libbacktrace CONFIG REQUIRED) # libbacktrace (CMake target: libbacktrace::libbacktrace) -find_package(argparse 3.2 REQUIRED) # argparse.cpp (CMake target: argparse::argparse) -find_package(eternal 1.0.1 REQUIRED) # Eternal (CMake target: eternal::eternal) -find_package(RE2 20230801 REQUIRED) # RE2 (CMake target: re2::re2) -find_package(fmt 11.1.4 REQUIRED) # fmtlib (CMake target: fmt::fmt) -find_package(libunwind 1.8.1 REQUIRED) # libunwind (CMake target: libunwind::libunwind) -find_package(Threads REQUIRED) # pthread support (Threads::Threads) -find_package(Boost 1.87.0 REQUIRED) # Boost - -set(CMAKE_CXX_STANDARD 20) -set(CMAKE_CXX_STANDARD_REQUIRED ON) - -# FIXME: remove later -# retained for backwards comparability, should be supplied in CLI or presets -set(CMAKE_EXPORT_COMPILE_COMMANDS ON) - -# Fix -Wstrinop-overflow warning -set(FMT_SYSTEM_HEADER ON) - -# FIXME: patch hpool to enable -Werror -add_compile_options( - -Wall - -Wextra - # -Werror - -Wno-pointer-arith - -Wno-unused-const-variable - -Wno-missing-field-initializers - -Wno-stringop-overflow -) - -add_compile_options( - $<$:-ggdb3> - $<$:-D__HCPU_DEBUG> - $<$:-O3> -) - -# FIXME: enable this by default when this becomes operational -if(HCPU_LTO) - check_ipo_supported(RESULT result OUTPUT output) - if(result) - set(CMAKE_INTERPROCEDURAL_OPTIMIZATION ON) - message(STATUS "HCPU: Enabled LTO") - else() - message(WARNING "HCPU: LTO is not supported: ${output}") - endif() -else() - message(STATUS "HCPU: Skipping LTO") -endif() - -if(HCPU_NATIVE_OPTIMIZATIONS) - add_compile_options(-march=native) - message(STATUS "HCPU: Enabled optimizations for current ISA implementation") -else() - message(STATUS "HCPU: Skipping current ISA optimizations") -endif() - -if(HCPU_SANITIZERS) - add_compile_options(-fsanitize=address,leak) - add_link_options(-fsanitize=address,leak) - message(STATUS "HCPU: Enabling sanitizers") -else() - message(STATUS "HCPU: Skipping sanitizers") -endif() - -include(CTest) -enable_testing() - -add_library(hcpu_unwind INTERFACE) -target_link_libraries( - hcpu_unwind - INTERFACE - libunwind::libunwind libbacktrace::libbacktrace -) -target_compile_definitions( - hcpu_unwind - INTERFACE - HCPU_ENABLE_LIBUNWIND -) - -add_subdirectory(dist) -add_subdirectory(src) - -if(HCPU_BUILD_BENCHMARKS) - add_subdirectory(bench) -endif() - -if(HCPU_BUILD_TESTS) - add_subdirectory(tests) -endif() \ No newline at end of file diff --git a/src/Assembler/BUILD.bazel b/src/Assembler/BUILD.bazel index b8238991..0a9cead2 100644 --- a/src/Assembler/BUILD.bazel +++ b/src/Assembler/BUILD.bazel @@ -1,38 +1,28 @@ load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') -package( - default_visibility = [ - '//src/Emulator:__pkg__', - ], -) - cc_library( name = 'assembler_core', srcs = glob(['**/*.cpp'], exclude = ['Main.cpp']), hdrs = glob(['**/*.hpp']), - strip_include_prefix = '/src', - visibility = [ - '//tests:__subpackages__', - '//src/Emulator:__pkg__' - ], deps = [ - '//src/PCH:pch_cstd', - '//src/Pog:pog', - '//src/Common:hcpu_common', - '//dist:hpool', '@fmt//:fmt', '@re2//:re2', '@eternal//:eternal', '@spdlog//:spdlog', - '@argparse//:argparse' - ] + '//dist:hpool', + '//src/PCH:pch_cstd', + '//src/Pog:pog', + '//src/Common:hcpu_common' + ], + visibility = ['//visibility:public'] ) cc_binary( name = 'hcasm', srcs = ['Main.cpp'], deps = [ - ':assembler_core', - # TODO: research why direct deps do not provide system headers - ] + '@argparse//:argparse', + ':assembler_core' + ], + visibility = ['//visibility:private'] ) diff --git a/src/Assembler/CMakeLists.txt b/src/Assembler/CMakeLists.txt deleted file mode 100644 index 1f2180d1..00000000 --- a/src/Assembler/CMakeLists.txt +++ /dev/null @@ -1,35 +0,0 @@ -cmake_minimum_required(VERSION 3.22) - -add_library( - hcpu::assembler-core - STATIC - Core/StatementCompilers.cpp - Core/Parsers.cpp - Core/Tokenizers.cpp - Core/Compiler.cpp - Core/BinaryTransformer.cpp - Utils/Extension.hpp - Core/BinaryTransformer.hpp - Core/OpcodeNameAssoc.hpp - Core/RegNameAssoc.hpp - Core/Compiler.hpp - Core/ModeNameAssoc.hpp -) - -target_include_directories(hcpu::assembler-core PUBLIC ${CMAKE_SOURCE_DIR}/src) - -target_link_libraries( - hcpu::assembler-core - PUBLIC - fmt::fmt - argparse::argparse - eternal::eternal - re2::re2 - pch - pog - hpool -) - -add_executable(hcasm Main/Main.cpp) - -target_link_libraries(hcasm PRIVATE hcpu::assembler-core) diff --git a/src/BacktraceProvider/BUILD.bazel b/src/BacktraceProvider/BUILD.bazel index ba62a0fe..3e36da4b 100644 --- a/src/BacktraceProvider/BUILD.bazel +++ b/src/BacktraceProvider/BUILD.bazel @@ -1,19 +1,14 @@ load('@rules_cc//cc:defs.bzl', 'cc_library') - cc_library( name = 'backtrace_provider', - srcs = [ - 'BacktraceProvider.cpp' - ], - hdrs = [ - 'BacktraceProvider.hpp' - ], - strip_include_prefix = '/src', + srcs = ['BacktraceProvider.cpp'], + hdrs = ['BacktraceProvider.hpp'], deps = [ '@fmt//:fmt', - '//src/PCH:pch_cstd', '@libbacktrace//:libbacktrace', '@libunwind//:libunwind', - ] + '//src/PCH:pch_cstd' + ], + visibility = ['//visibility:public'] ) diff --git a/src/BacktraceProvider/CMakeLists.txt b/src/BacktraceProvider/CMakeLists.txt deleted file mode 100644 index ab15e40e..00000000 --- a/src/BacktraceProvider/CMakeLists.txt +++ /dev/null @@ -1,22 +0,0 @@ -cmake_minimum_required(VERSION 3.25) - -add_library( - hcpu::backtrace-provider - STATIC - BacktraceProvider.cpp - BacktraceProvider.hpp -) - -target_include_directories( - hcpu::backtrace-provider - PUBLIC - ${CMAKE_SOURCE_DIR}/src -) - -target_link_libraries( - hcpu::backtrace-provider - PUBLIC - fmt::fmt - hcpu_unwind - pch_cstd -) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt deleted file mode 100644 index 9a2d95b7..00000000 --- a/src/CMakeLists.txt +++ /dev/null @@ -1,8 +0,0 @@ -cmake_minimum_required(VERSION 3.22) - -add_subdirectory(Pog) -add_subdirectory(PCH) -add_subdirectory(Common) -add_subdirectory(Emulator) -add_subdirectory(Assembler) -add_subdirectory(BacktraceProvider) diff --git a/src/Common/BUILD.bazel b/src/Common/BUILD.bazel index 075a33ed..3a338f08 100644 --- a/src/Common/BUILD.bazel +++ b/src/Common/BUILD.bazel @@ -1,11 +1,5 @@ load('@rules_cc//cc:defs.bzl', 'cc_library') -package( - default_visibility = [ - '//:__subpackages__', - ], -) - cc_library( name = 'hcpu_common', srcs = glob(['**/*.cpp'], allow_empty = True), @@ -14,5 +8,6 @@ cc_library( deps = [ '@spdlog//:spdlog', '//src/PCH:pch_cstd' - ] + ], + visibility = ['//visibility:public'] ) diff --git a/src/Common/CMakeLists.txt b/src/Common/CMakeLists.txt deleted file mode 100644 index d1267ec9..00000000 --- a/src/Common/CMakeLists.txt +++ /dev/null @@ -1,17 +0,0 @@ -cmake_minimum_required(VERSION 3.22) - - -add_library( - hcpu::common - INTERFACE - Defs.hpp - NotImplemented.hpp - LanguageSpec/AllowedFlags.hpp - LanguageSpec/Flags.hpp - LanguageSpec/Opcodes.hpp - LanguageSpec/Registers.hpp -) - -target_include_directories(hcpu::common INTERFACE ${CMAKE_SOURCE_DIR}) - -target_link_libraries(hcpu::Common INTERFACE spdlog::spdlog hcpu::pch) diff --git a/src/Emulator/BUILD.bazel b/src/Emulator/BUILD.bazel index 125af838..52138c00 100644 --- a/src/Emulator/BUILD.bazel +++ b/src/Emulator/BUILD.bazel @@ -4,23 +4,22 @@ cc_library( name = 'emulator_core', srcs = glob(['**/*.cpp'], exclude = ['Main.cpp']), hdrs = glob(['**/*.hpp']), - visibility = [ - '//tests:__subpackages__' - ], deps = [ '@fmt//:fmt', - '@argparse//:argparse', '@eternal//:eternal', '//src/Assembler:assembler_core', '//src/PCH:pch_cstd', '//src/Pog:pog' - ] + ], + visibility = ['//visibility:public'] ) cc_binary( name = 'hcemul', srcs = ['Main.cpp'], deps = [ + '@argparse//:argparse', ':emulator_core' - ] + ], + visibility = ['//visibility:private'] ) diff --git a/src/Emulator/CMakeLists.txt b/src/Emulator/CMakeLists.txt deleted file mode 100644 index 88d7e7ab..00000000 --- a/src/Emulator/CMakeLists.txt +++ /dev/null @@ -1,98 +0,0 @@ -cmake_minimum_required(VERSION 3.22) - - -add_library( - hcpu::emulator-core - STATIC - Core/CPU/Instructions/AllowedFlags.cpp - Core/CPU/Interrupts/InterruptHandler.cpp - Core/CPU/CPU.cpp - Core/CPU/InstructionsImpl/DIV.cpp - Core/CPU/InstructionsImpl/CALLL.cpp - Core/CPU/InstructionsImpl/MUL.cpp - Core/CPU/InstructionsImpl/READ.cpp - Core/CPU/InstructionsImpl/ADC.cpp - Core/CPU/InstructionsImpl/ADD.cpp - Core/CPU/InstructionsImpl/DEC.cpp - Core/CPU/InstructionsImpl/SHFL.cpp - Core/CPU/InstructionsImpl/CUDF.cpp - Core/CPU/InstructionsImpl/PUSH.cpp - Core/CPU/InstructionsImpl/OR.cpp - Core/CPU/InstructionsImpl/POP.cpp - Core/CPU/InstructionsImpl/CALLGR.cpp - Core/CPU/InstructionsImpl/CCRF.cpp - Core/CPU/InstructionsImpl/JMP.cpp - Core/CPU/InstructionsImpl/AND.cpp - Core/CPU/InstructionsImpl/HID.cpp - Core/CPU/InstructionsImpl/CALL.cpp - Core/CPU/InstructionsImpl/INC.cpp - Core/CPU/InstructionsImpl/INTR.cpp - Core/CPU/InstructionsImpl/SHFR.cpp - Core/CPU/InstructionsImpl/CALLE.cpp - Core/CPU/InstructionsImpl/JML.cpp - Core/CPU/InstructionsImpl/SUB.cpp - Core/CPU/InstructionsImpl/ANDN.cpp - Core/CPU/InstructionsImpl/LOIVT.cpp - Core/CPU/InstructionsImpl/HALT.cpp - Core/CPU/InstructionsImpl/MOV.cpp - Core/CPU/InstructionsImpl/CMP.cpp - Core/CPU/InstructionsImpl/WRITE.cpp - Core/CPU/InstructionsImpl/BSWAP.cpp - Core/CPU/InstructionsImpl/JME.cpp - Core/CPU/InstructionsImpl/COVF.cpp - Core/CPU/InstructionsImpl/JMGR.cpp - Core/CPU/Decoders/StdDecoder.cpp - Core/CPU/Stack.cpp - Core/CPU/OperandsEvaluation.cpp - Core/CPU/IO/Simple.cpp - Core/MemoryController/MemoryControllerST.hpp - Core/MemoryController/IMemoryController.hpp - Core/CPU/Instructions/AllowedFlags.hpp - Core/CPU/Instructions/Opcodes.hpp - Core/CPU/Instructions/Flags.hpp - Core/CPU/Instructions/Registers.hpp - Core/CPU/Interrupts/ReservedInterrupts.hpp - Core/CPU/CPU.hpp - Core/CPU/ALU.hpp - Core/CPU/Decoders/StdDecoder.hpp - Core/CPU/Decoders/IDecoder.hpp - Core/CPU/Assert.hpp - Core/CPU/Version.hpp - Core/CPU/Util.hpp - Core/CPU/IO/Simple.hpp - Misc/byteswap.hpp - Misc/overflow.hpp - Misc/deref.hpp - Misc/bit_cast.hpp - Misc/unreachable.hpp - Misc/underflow.hpp - Misc/print.hpp -) - -target_include_directories( - hcpu::emulator-core - PUBLIC - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_CURRENT_SOURCE_DIR} -) - -target_link_libraries( - hcpu::emulator-core - PUBLIC - hcpu::pog - hcpu::pch - dist::hpool - fmt::fmt - argparse::argparse - eternal::eternal -) - -add_executable( - hcpu::hcemul - Main/Main.hpp - Main/Main.cpp - Main/ExceptionHandling.cpp - Main/ExceptionHandling.hpp -) - -target_link_libraries(hcpu::hcemul PRIVATE hcpu::emulator-core) diff --git a/src/PCH/BUILD.bazel b/src/PCH/BUILD.bazel index bfd82cc8..e5dd8076 100644 --- a/src/PCH/BUILD.bazel +++ b/src/PCH/BUILD.bazel @@ -1,12 +1,7 @@ load('//tools/bazel:pch.bzl', 'precompiled_headers') -package( - default_visibility = [ - '//:__subpackages__', - ], -) - precompiled_headers( name = 'pch_cstd', - main = 'CStd.hpp' + main = 'CStd.hpp', + visibility = ['//visibility:public'] ) diff --git a/src/PCH/CMakeLists.txt b/src/PCH/CMakeLists.txt deleted file mode 100644 index d4e981a6..00000000 --- a/src/PCH/CMakeLists.txt +++ /dev/null @@ -1,4 +0,0 @@ -cmake_minimum_required(VERSION 3.22) - -add_library(hcpu::pch INTERFACE CStd.hpp) -target_precompile_headers(hcpu::pch INTERFACE CStd.hpp) diff --git a/src/Pog/BUILD.bazel b/src/Pog/BUILD.bazel index d0ee2d9d..fc5384d4 100644 --- a/src/Pog/BUILD.bazel +++ b/src/Pog/BUILD.bazel @@ -1,19 +1,14 @@ load('@rules_cc//cc:defs.bzl', 'cc_library') load('//tools/bazel:pch.bzl', 'precompiled_headers') -package( - default_visibility = [ - '//:__subpackages__', - ], -) - cc_library( name = 'pog_core', hdrs = glob(['**/*.hpp'], exclude = ['Pog.hpp']), deps = [ '@re2//:re2', '@fmt//:fmt' - ] + ], + visibility = ['//visibility:private'] ) precompiled_headers( @@ -21,5 +16,6 @@ precompiled_headers( main = 'Pog.hpp', deps = [ ':pog_core' - ] + ], + visibility = ['//visibility:public'] ) diff --git a/src/Pog/CMakeLists.txt b/src/Pog/CMakeLists.txt deleted file mode 100644 index 7882ec59..00000000 --- a/src/Pog/CMakeLists.txt +++ /dev/null @@ -1,41 +0,0 @@ -cmake_minimum_required(VERSION 3.22) - -add_library( - hcpu::pog - INTERFACE - Pog.hpp - Action.hpp - Automaton.hpp - DigraphAlgo.hpp - Errors.hpp - FilterView.hpp - Grammar.hpp - HTMLReport.hpp - Item.hpp - LineSpecialization.hpp - Operations/Follow.hpp - Operations/Lookahead.hpp - Operations/Operation.hpp - Operations/Read.hpp - Parser.hpp - ParserReport.hpp - ParsingTable.hpp - Pog.hpp - Precedence.hpp - Relations/Includes.hpp - Relations/Lookback.hpp - Relations/Relation.hpp - RuleBuilder.hpp - Rule.hpp - State.hpp - Symbol.hpp - TokenBuilder.hpp - Token.hpp - Tokenizer.hpp - Types/StateAndRule.hpp - Types/StateAndSymbol.hpp - Utils.hpp -) - -target_precompile_headers(hcpu::pog INTERFACE Pog.hpp) -target_include_directories(hcpu::pog INTERFACE ${CMAKE_SOURCE_DIR}/src) diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt deleted file mode 100644 index bb1fd19a..00000000 --- a/tests/CMakeLists.txt +++ /dev/null @@ -1,10 +0,0 @@ -# FIXME: Add separate precompiled headers here, too -cmake_minimum_required(VERSION 3.25) - - -include(GoogleTest) - -add_subdirectory(Integration) -add_subdirectory(Modular) -add_subdirectory(Pog) -add_subdirectory(Python/Buildsystem) diff --git a/tests/Integration/CMakeLists.txt b/tests/Integration/CMakeLists.txt deleted file mode 100644 index f45fabc2..00000000 --- a/tests/Integration/CMakeLists.txt +++ /dev/null @@ -1,67 +0,0 @@ -cmake_minimum_required(VERSION 3.25) - - -add_executable( - integration_testing - ${CMAKE_SOURCE_DIR}/tests/main.cpp - EmulatorCore/CPU/CPU_CALLE.cpp - EmulatorCore/CPU/CPU_HID.cpp - EmulatorCore/CPU/CPU_READ.cpp - EmulatorCore/CPU/CPU_AND.cpp - EmulatorCore/CPU/CPU_INC.cpp - EmulatorCore/CPU/CPU_COVF.cpp - EmulatorCore/CPU/CPU_CALLL.cpp - EmulatorCore/CPU/CPU_ADC.cpp - EmulatorCore/CPU/CPU_ADD.cpp - EmulatorCore/CPU/CPU_MOV.cpp - EmulatorCore/CPU/CPU_CMP.cpp - EmulatorCore/CPU/CPU_OR.cpp - EmulatorCore/CPU/CPU_SHFL.cpp - EmulatorCore/CPU/CPU_POP.cpp - EmulatorCore/CPU/CPU_DEC.cpp - EmulatorCore/CPU/CPU_JML.cpp - EmulatorCore/CPU/CPU_SHFR.cpp - EmulatorCore/CPU/CPU_CALL.cpp - EmulatorCore/CPU/CPU_JMP.cpp - EmulatorCore/CPU/CPU_INTR.cpp - EmulatorCore/CPU/CPU_WRITE.cpp - EmulatorCore/CPU/CPU_IRET.cpp - EmulatorCore/CPU/CPU_MUL.cpp - EmulatorCore/CPU/CPU_JME.cpp - EmulatorCore/CPU/CPU_CALLGR.cpp - EmulatorCore/CPU/CPU_ANDN.cpp - EmulatorCore/CPU/CPU_CCRF.cpp - EmulatorCore/CPU/CPU_LOIVT.cpp - EmulatorCore/CPU/CPU_SUB.cpp - EmulatorCore/CPU/CPU_PUSH.cpp - EmulatorCore/CPU/CPU_DIV.cpp - EmulatorCore/CPU/OperandsEvaluation.cpp - EmulatorCore/CPU/CPU_JMGR.cpp - EmulatorCore/CPU/CPU_CUDF.cpp - EmulatorCore/CPU/CPU_BSWAP.cpp - EmulatorCore/Exceptions/Exceptions.cpp - AssemblerCore/TwoOperandsSuccess.cpp - AssemblerCore/AssemblerSuccess.cpp - AssemblerCore/FullAssembler.cpp - AssemblerCore/AssemblerFail.cpp -) -target_link_libraries( - integration_testing - PRIVATE - emulator-core - assembler-core - GTest::gtest - pthread -) -target_include_directories( - integration_testing - PRIVATE - ${CMAKE_SOURCE_DIR}/tests -) - -gtest_add_tests( - TARGET - integration_testing - ARGS - --gtest_brief=1 -) \ No newline at end of file diff --git a/tests/Modular/CMakeLists.txt b/tests/Modular/CMakeLists.txt deleted file mode 100644 index 8ef88049..00000000 --- a/tests/Modular/CMakeLists.txt +++ /dev/null @@ -1,141 +0,0 @@ -cmake_minimum_required(VERSION 3.25) - - -add_executable( - modular_testing - ${CMAKE_SOURCE_DIR}/tests/main.cpp - EmulatorCore/Decoding/CMPInstr/R_R.cpp - EmulatorCore/Decoding/CMPInstr/RM_IMM.cpp - EmulatorCore/Decoding/CMPInstr/RM_M.cpp - EmulatorCore/Decoding/CMPInstr/M_R.cpp - EmulatorCore/Decoding/CMPInstr/RM_R.cpp - EmulatorCore/Decoding/CMPInstr/Unsupported.cpp - EmulatorCore/Decoding/CMPInstr/R_RM.cpp - EmulatorCore/Decoding/CMPInstr/R_IMM.cpp - EmulatorCore/Decoding/CMPInstr/R_M.cpp - EmulatorCore/Decoding/SHFLInstr/R_R.cpp - EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp - EmulatorCore/Decoding/SHFLInstr/R_IMM.cpp - EmulatorCore/Decoding/SHFRInstr/R_R.cpp - EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp - EmulatorCore/Decoding/SHFRInstr/R_IMM.cpp - EmulatorCore/Decoding/JMLInstr/test_decoder_r.cpp - EmulatorCore/Decoding/JMLInstr/test_decoder_imm.cpp - EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp - EmulatorCore/Decoding/BSWAPInstr/R.cpp - EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp - EmulatorCore/Decoding/CALLGRInstr/test_decoder_r.cpp - EmulatorCore/Decoding/CALLGRInstr/test_decoder_imm.cpp - EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp - EmulatorCore/Decoding/MULInstr/R_R.cpp - EmulatorCore/Decoding/MULInstr/Unsupported.cpp - EmulatorCore/Decoding/MULInstr/R_RM.cpp - EmulatorCore/Decoding/MULInstr/R_IMM.cpp - EmulatorCore/Decoding/MULInstr/R_M.cpp - EmulatorCore/Decoding/WRITEInstr/R_R.cpp - EmulatorCore/Decoding/WRITEInstr/Unsupported.cpp - EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp - EmulatorCore/Decoding/DECInstr/R.cpp - EmulatorCore/Decoding/DECInstr/Unsupported.cpp - EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp - EmulatorCore/Decoding/CUDFInstr/None.cpp - EmulatorCore/Decoding/CALLEInstr/test_decoder_r.cpp - EmulatorCore/Decoding/CALLEInstr/test_decoder_imm.cpp - EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp - EmulatorCore/Decoding/INCInstr/R.cpp - EmulatorCore/Decoding/INCInstr/Unsupported.cpp - EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp - EmulatorCore/Decoding/COVFInstr/test_decoder_none.cpp - EmulatorCore/Decoding/JMGRInstr/test_decoder_r.cpp - EmulatorCore/Decoding/JMGRInstr/test_decoder_imm.cpp - EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp - EmulatorCore/Decoding/JMPInstr/test_decoder_r.cpp - EmulatorCore/Decoding/JMPInstr/test_decoder_imm.cpp - EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp - EmulatorCore/Decoding/SUBInstr/R_R.cpp - EmulatorCore/Decoding/SUBInstr/Unsupported.cpp - EmulatorCore/Decoding/SUBInstr/R_RM.cpp - EmulatorCore/Decoding/SUBInstr/R_IMM.cpp - EmulatorCore/Decoding/SUBInstr/R_M.cpp - EmulatorCore/Decoding/ANDInstr/R_R.cpp - EmulatorCore/Decoding/ANDInstr/Unsupported.cpp - EmulatorCore/Decoding/ANDInstr/R_RM.cpp - EmulatorCore/Decoding/ANDInstr/R_IMM.cpp - EmulatorCore/Decoding/ANDInstr/R_M.cpp - EmulatorCore/Decoding/MOVInstr/R_R.cpp - EmulatorCore/Decoding/MOVInstr/RM_IMM.cpp - EmulatorCore/Decoding/MOVInstr/RM_M.cpp - EmulatorCore/Decoding/MOVInstr/M_R.cpp - EmulatorCore/Decoding/MOVInstr/RM_R.cpp - EmulatorCore/Decoding/MOVInstr/Unsupported.cpp - EmulatorCore/Decoding/MOVInstr/R_RM.cpp - EmulatorCore/Decoding/MOVInstr/R_IMM.cpp - EmulatorCore/Decoding/MOVInstr/R_M.cpp - EmulatorCore/Decoding/ADDInstr/R_R.cpp - EmulatorCore/Decoding/ADDInstr/Unsupported.cpp - EmulatorCore/Decoding/ADDInstr/R_RM.cpp - EmulatorCore/Decoding/ADDInstr/R_IMM.cpp - EmulatorCore/Decoding/ADDInstr/R_M.cpp - EmulatorCore/Decoding/HIDInstr/Unsupported.cpp - EmulatorCore/Decoding/HIDInstr/None.cpp - EmulatorCore/Decoding/JMEInstr/test_decoder_r.cpp - EmulatorCore/Decoding/JMEInstr/test_decoder_imm.cpp - EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp - EmulatorCore/Decoding/ANDNInstr/R_R.cpp - EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp - EmulatorCore/Decoding/ANDNInstr/R_RM.cpp - EmulatorCore/Decoding/ANDNInstr/R_IMM.cpp - EmulatorCore/Decoding/ANDNInstr/R_M.cpp - EmulatorCore/Decoding/DIVInstr/R.cpp - EmulatorCore/Decoding/DIVInstr/Unsupported.cpp - EmulatorCore/Decoding/CALLLInstr/test_decoder_r.cpp - EmulatorCore/Decoding/CALLLInstr/test_decoder_imm.cpp - EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp - EmulatorCore/Decoding/CALLInstr/test_decoder_r.cpp - EmulatorCore/Decoding/CALLInstr/test_decoder_imm.cpp - EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp - EmulatorCore/Decoding/ADCInstr/R_R.cpp - EmulatorCore/Decoding/ADCInstr/Unsupported.cpp - EmulatorCore/Decoding/ADCInstr/R_RM.cpp - EmulatorCore/Decoding/ADCInstr/R_IMM.cpp - EmulatorCore/Decoding/ADCInstr/R_M.cpp - EmulatorCore/Decoding/Features/AddressAddition.cpp - EmulatorCore/Decoding/HALTInstr/Unsupported.cpp - EmulatorCore/Decoding/HALTInstr/None.cpp - EmulatorCore/Decoding/ORInstr/R_R.cpp - EmulatorCore/Decoding/ORInstr/Unsupported.cpp - EmulatorCore/Decoding/ORInstr/R_RM.cpp - EmulatorCore/Decoding/ORInstr/R_IMM.cpp - EmulatorCore/Decoding/ORInstr/R_M.cpp - EmulatorCore/Decoding/READInstr/IMM.cpp - EmulatorCore/Decoding/READInstr/Unsupported.cpp - EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp - EmulatorCore/Decoding/CCRFInstr/test_decoder_none.cpp - EmulatorCore/MemoryControllers/ST.cpp - EmulatorCore/CPUInit/CPUInit.cpp - EmulatorCore/Stack/Stack.cpp - AssemblerCore/Parser/Statements.cpp - AssemblerCore/Parser/Operands.cpp - AssemblerCore/Parser/Tokens.cpp -) -target_link_libraries( - modular_testing - PRIVATE - emulator-core - assembler-core - GTest::gtest - pthread - pch -) -target_include_directories( - modular_testing - PRIVATE - ${CMAKE_SOURCE_DIR}/tests -) - -gtest_add_tests( - TARGET - modular_testing - EXTRA_ARGS - --gtest_brief=1 -) diff --git a/tests/Pog/CMakeLists.txt b/tests/Pog/CMakeLists.txt deleted file mode 100644 index c0cc31fe..00000000 --- a/tests/Pog/CMakeLists.txt +++ /dev/null @@ -1,44 +0,0 @@ -cmake_minimum_required(VERSION 3.25) - -add_executable( - pog_testing - Automaton.cpp - FilterView.cpp - Grammar.cpp - Item.cpp - Parser.cpp - ParsingTable.cpp - PogTests.cpp - Precedence.cpp - Rule.cpp - RuleBuilder.cpp - State.cpp - Symbol.cpp - Token.cpp - TokenBuilder.cpp - Tokenizer.cpp - Utils.cpp -) - -target_link_libraries( - pog_testing - PRIVATE - emulator-core - assembler-core - GTest::gtest - pthread - pch - pog -) -target_include_directories( - pog_testing - PRIVATE - ${CMAKE_SOURCE_DIR}/tests -) - -gtest_add_tests( - TARGET - pog_testing - EXTRA_ARGS - --gtest_brief=1 -) diff --git a/tests/Python/Buildsystem/CMakeLists.txt b/tests/Python/Buildsystem/CMakeLists.txt deleted file mode 100644 index 5a097f07..00000000 --- a/tests/Python/Buildsystem/CMakeLists.txt +++ /dev/null @@ -1,21 +0,0 @@ -cmake_minimum_required(VERSION 3.25) - - -add_custom_target(python_build_copy_tests ALL - COMMAND ${CMAKE_COMMAND} -E copy_directory - "${CMAKE_CURRENT_SOURCE_DIR}/DummyProject" - "${CMAKE_CURRENT_BINARY_DIR}/DummyProject" - COMMAND ${CMAKE_COMMAND} -E copy - "${CMAKE_CURRENT_SOURCE_DIR}/test_build.py" - "${CMAKE_CURRENT_BINARY_DIR}/test_build.py" - COMMENT "Copy python tests and their artifacts to build directory" -) - -add_test( - NAME TestBuildsystem - WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} - COMMAND ${CMAKE_COMMAND} -E env - PYTHONPATH=${CMAKE_SOURCE_DIR} - python3 - "${CMAKE_CURRENT_BINARY_DIR}/test_build.py" -) \ No newline at end of file diff --git a/tests/Python/Buildsystem/DummyProject/CMakeLists.txt b/tests/Python/Buildsystem/DummyProject/CMakeLists.txt deleted file mode 100644 index 930b3cbc..00000000 --- a/tests/Python/Buildsystem/DummyProject/CMakeLists.txt +++ /dev/null @@ -1,21 +0,0 @@ -cmake_minimum_required(VERSION 3.25) -project(dummy) - -find_package(plog 1.0.0 REQUIRED) - -if(NOT DEFINED DUMMY_MESSAGE OR DUMMY_MESSAGE STREQUAL "") - message(FATAL_ERROR "Dummy: expected DUMMY_MESSAGE to be defined") -endif() - -add_executable(dummy main.cpp) - -target_compile_definitions(dummy - PRIVATE - # The backslashes escape the quote into the generated -D flag - DUMMY_MESSAGE=\"${DUMMY_MESSAGE}\" -) - -target_link_libraries(dummy - PRIVATE - plog::plog -) \ No newline at end of file diff --git a/tests/Python/Buildsystem/DummyProject/conanfile.py b/tests/Python/Buildsystem/DummyProject/conanfile.py deleted file mode 100644 index b6f90766..00000000 --- a/tests/Python/Buildsystem/DummyProject/conanfile.py +++ /dev/null @@ -1,20 +0,0 @@ -from typing import Self, List - -from conan import ConanFile -from conan.tools.cmake import cmake_layout - - -class Dummy(ConanFile): - generators: List[str] = ['CMakeToolchain', 'CMakeDeps'] - settings: List[str] = ['os', 'compiler', 'build_type', 'arch'] - - def __init__(self: Self, display_name: str = '') -> None: - self.name = 'Dummy' - self.version = '1.0.0' - super().__init__(display_name) - - def requirements(self: Self) -> None: - self.requires('plog/1.1.10') - - def layout(self): - cmake_layout(self) \ No newline at end of file diff --git a/tests/Python/Buildsystem/DummyProject/main.cpp b/tests/Python/Buildsystem/DummyProject/main.cpp deleted file mode 100644 index 6d30eee3..00000000 --- a/tests/Python/Buildsystem/DummyProject/main.cpp +++ /dev/null @@ -1,13 +0,0 @@ -#include - -// compilation will fail if plog is not available -#include - -#ifndef DUMMY_MESSAGE -#error "Expected macro DUMMY_MESSAGE in this compilation unit" -#endif - -int main() { - std::cout << DUMMY_MESSAGE; - return 0; -} \ No newline at end of file diff --git a/tests/Python/Buildsystem/test_build.py b/tests/Python/Buildsystem/test_build.py deleted file mode 100644 index e07439e2..00000000 --- a/tests/Python/Buildsystem/test_build.py +++ /dev/null @@ -1,99 +0,0 @@ -import os -import logging -import unittest - -from pathlib import Path -from scripts.build import Routines, Config - -# TODO: make a single test runner -# TODO: add more tests + run resulting executable -class BuildsystemTestCase(unittest.TestCase): - @classmethod - def setUpClass(cls): - cls.dummy_message = 'Hello, HyperCPU!' - cls.orig_cwd = Path.cwd() - cls.dummy_dir = cls.orig_cwd / 'DummyProject' - - os.chdir(cls.dummy_dir) - - @classmethod - def tearDownClass(cls): - os.chdir(cls.orig_cwd) - - def setUp(self): - self.config = Config() - self.routines = Routines(self.config) - - def test_01_remove_no_dirs(self): - self.config.build_configs = ['Debug', 'Release'] - self.routines.remove() - - def test_01_remove_a_single_dir(self): - path = self.config.build_directory / 'Debug' - path.mkdir(parents=True, exist_ok=True) - - self.config.build_configs = ['Debug'] - self.routines.remove() - - self.assertFalse(path.exists()) - - def test_01_remove_selected_dir(self): - build_path = self.config.build_directory - paths = [build_path / 'Debug', build_path / 'Release'] - for path in paths: - path.mkdir(parents=True) - - self.config.build_configs = ['Debug'] - self.routines.remove() - - debug, release = paths - self.assertTrue(build_path.exists()) - self.assertFalse(debug.exists()) - self.assertTrue(release.exists()) - - def test_01_remove_all_dirs(self): - build_path = self.config.build_directory - paths = [build_path / 'Debug', build_path / 'Release'] - for path in paths: - path.mkdir(parents=True, exist_ok=True) - - self.config.build_configs = ['Debug', 'Release'] - self.routines.remove() - - debug, release = paths - # it is important to preserve top-level "build" dir - self.assertTrue(build_path.exists()) - self.assertFalse(debug.exists()) - self.assertFalse(release.exists()) - - def test_02_conan_install(self): - # it just has to work - self.config.allow_profile_detection = True - self.config.build_configs = ['Debug', 'Release'] - self.routines.conan_install() - - build_path = self.config.build_directory - debug, release = build_path / 'Debug', build_path / 'Release' - self.assertTrue(build_path.exists()) - self.assertTrue(debug.exists()) - self.assertTrue(release.exists()) - - def test_03_configure(self): - self.config.defines.append( - ('DUMMY_MESSAGE', 'STRING', self.dummy_message) - ) - self.config.build_configs = ['Debug', 'Release'] - self.routines.configure() - - def test_04_build(self): - self.config.build_configs = ['Debug', 'Release'] - self.routines.build() - pass - - def test_05_symlink_debug_compile_commands(self): - pass - pass - -if __name__ == '__main__': - logging.basicConfig(level=logging.DEBUG) - unittest.main() \ No newline at end of file From 80f9f103a62eb35e22963f9f4e7d4a3a0cce1270 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sun, 11 May 2025 01:55:47 +0300 Subject: [PATCH 27/40] added modular tests --- .bazelrc | 13 +++++------- BUILD.bazel | 19 ++++++++++++++++-- tests/BUILD.bazel | 4 ++-- tests/Integration/BUILD.bazel | 11 +++++----- .../Modular/AssemblerCore/Parser/Operands.cpp | 20 +++++++++---------- .../AssemblerCore/Parser/Statements.cpp | 10 +++++----- tests/Modular/AssemblerCore/Parser/Tokens.cpp | 3 +-- tests/Modular/BUILD.bazel | 17 ++++++++++++++++ .../Modular/EmulatorCore/CPUInit/CPUInit.cpp | 7 +++---- .../Decoding/WRITEInstr/R_IMM.cpp | 10 +++++----- .../EmulatorCore/MemoryControllers/ST.cpp | 8 ++++---- tests/Modular/EmulatorCore/Stack/Stack.cpp | 4 ++-- 12 files changed, 76 insertions(+), 50 deletions(-) create mode 100644 tests/Modular/BUILD.bazel diff --git a/.bazelrc b/.bazelrc index a0c9d848..e55a8920 100644 --- a/.bazelrc +++ b/.bazelrc @@ -1,6 +1,11 @@ # Make Bazel print out all options from rc files common --announce_rc +# Verbose test output +common --test_summary=detailed +# Stream test results to stdout +common --test_output=streamed + # We use 23 standard build:linux --cxxopt=-std=c++23 # Include: source directory @@ -42,11 +47,3 @@ build:linux-opt --cxxopt=-O3 # Distro-specific configurations # ... - -# --- Testing --- -# Linux -# Verbose output -test:linux --test_summary=detailed -# Stream test results to stdout -test:linux --test_output=streamed -# --------------- diff --git a/BUILD.bazel b/BUILD.bazel index ff2f40be..524ad821 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -9,12 +9,27 @@ package( ], ) +config_setting( + name = 'linux', + constraint_values = ['@platforms//os:linux'] +) + refresh_compile_commands( name = 'refresh_compile_commands', targets = { - '//src/...': '', - '//tests/...': '' + '//src/...': '--config=linux-dbg', + '//tests/...': '--config=linux-dbg' } + # I hope they will support this at some point + # targets = select( + # { + # ':linux': { + # '//src/...': '--config=linux-dbg', + # '//tests/...': '--config=linux-dbg' + # } + # }, + # no_match_error = 'Could not determine host OS toolchain flags, running this target is pointless' + # ) ) format_multirun( diff --git a/tests/BUILD.bazel b/tests/BUILD.bazel index 8752a762..f73075d2 100644 --- a/tests/BUILD.bazel +++ b/tests/BUILD.bazel @@ -3,7 +3,7 @@ load('//tools/bazel:pch.bzl', 'precompiled_headers') package( default_visibility = [ - '//:__subpackages__', + '//tests:__subpackages__', ], ) @@ -11,7 +11,7 @@ precompiled_headers( name = 'pch_gtest', main = 'gtest.hpp', deps = [ - '@gtest//:gtest-gmock_main' + '@gtest//:gtest-libgtest' ] ) diff --git a/tests/Integration/BUILD.bazel b/tests/Integration/BUILD.bazel index 10679124..c2a4ff57 100644 --- a/tests/Integration/BUILD.bazel +++ b/tests/Integration/BUILD.bazel @@ -1,17 +1,16 @@ load('@rules_cc//cc:defs.bzl', 'cc_test') - cc_test( name = 'integration-test', linkstatic = True, srcs = glob(['**/*.cpp']), deps = [ - '//src/PCH:pch_cstd', + '@gtest//:gtest-gmock_main', + '@fmt//:fmt', '//tests:pch_gtest', - '//src/Assembler:assembler_core', - '//src/Emulator:emulator_core', '//tests:test_fixtures', - '@gtest//:gtest-gmock_main', - '@fmt//:fmt' + '//src/PCH:pch_cstd', + '//src/Assembler:assembler_core', + '//src/Emulator:emulator_core' ] ) diff --git a/tests/Modular/AssemblerCore/Parser/Operands.cpp b/tests/Modular/AssemblerCore/Parser/Operands.cpp index c11463e4..53ae4eca 100644 --- a/tests/Modular/AssemblerCore/Parser/Operands.cpp +++ b/tests/Modular/AssemblerCore/Parser/Operands.cpp @@ -1,4 +1,4 @@ -#include +#include "tests/fixtures.hpp" TEST_F(ASM_PARSER_TEST, OPERAND1) { std::string data = "[0x15FA]"; @@ -21,7 +21,7 @@ TEST_F(ASM_PARSER_TEST, OPERAND2) { auto operand = std::get(parser.parse(data)->val); EXPECT_EQ(operand.type, HCAsm::OperandType::memaddr_reg); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.reg, HyperCPU::Reg::X0); } TEST_F(ASM_PARSER_TEST, OPERAND3_1) { @@ -33,7 +33,7 @@ TEST_F(ASM_PARSER_TEST, OPERAND3_1) { auto operand = std::get(parser.parse(data)->val); EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.reg, HyperCPU::Reg::X0); EXPECT_EQ(std::get(operand.variant), static_cast(15)); } @@ -46,7 +46,7 @@ TEST_F(ASM_PARSER_TEST, OPERAND3_2) { auto operand = std::get(parser.parse(data)->val); EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.reg, HyperCPU::Reg::X0); EXPECT_EQ(std::get(operand.variant), static_cast(0x15)); } @@ -59,7 +59,7 @@ TEST_F(ASM_PARSER_TEST, OPERAND3_3) { auto operand = std::get(parser.parse(data)->val); EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.reg, HyperCPU::Reg::X0); EXPECT_EQ(std::get(operand.variant), static_cast(0b00110101)); } @@ -86,7 +86,7 @@ TEST_F(ASM_PARSER_TEST, OPERAND5) { EXPECT_EQ(operand.type, HCAsm::OperandType::memaddr_reg); EXPECT_EQ(operand.mode, HCAsm::Mode::b16); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.reg, HyperCPU::Reg::X0); } TEST_F(ASM_PARSER_TEST, OPERAND6_1) { @@ -98,7 +98,7 @@ TEST_F(ASM_PARSER_TEST, OPERAND6_1) { auto operand = std::get(parser.parse(data)->val); EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.reg, HyperCPU::Reg::X0); EXPECT_EQ(operand.mode, HCAsm::Mode::b32); EXPECT_EQ(std::get(operand.variant), static_cast(15)); } @@ -112,7 +112,7 @@ TEST_F(ASM_PARSER_TEST, OPERAND6_2) { auto operand = std::get(parser.parse(data)->val); EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.reg, HyperCPU::Reg::X0); EXPECT_EQ(operand.mode, HCAsm::Mode::b8); EXPECT_EQ(std::get(operand.variant), static_cast(0x15)); } @@ -126,7 +126,7 @@ TEST_F(ASM_PARSER_TEST, OPERAND6_3) { auto operand = std::get(parser.parse(data)->val); EXPECT_EQ(operand.type, HCAsm::OperandType::mem_reg_add_int); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.reg, HyperCPU::Reg::X0); EXPECT_EQ(operand.mode, HCAsm::Mode::b32); EXPECT_EQ(std::get(operand.variant), static_cast(0b00110101)); } @@ -206,7 +206,7 @@ TEST_F(ASM_PARSER_TEST, OPERAND9) { EXPECT_EQ(operand.type, HCAsm::OperandType::reg); EXPECT_EQ(operand.mode, HCAsm::Mode::b64); - EXPECT_EQ(operand.reg, HyperCPU::Registers::X0); + EXPECT_EQ(operand.reg, HyperCPU::Reg::X0); } TEST_F(ASM_PARSER_TEST, OPERAND10) { diff --git a/tests/Modular/AssemblerCore/Parser/Statements.cpp b/tests/Modular/AssemblerCore/Parser/Statements.cpp index dd50ba19..93c58fbb 100644 --- a/tests/Modular/AssemblerCore/Parser/Statements.cpp +++ b/tests/Modular/AssemblerCore/Parser/Statements.cpp @@ -1,6 +1,6 @@ -#include +#include "tests/fixtures.hpp" +#include "Assembler/Core/Compiler.hpp" -#include TEST_F(ASM_PARSER_STMT_TEST, STMT1) { std::string data = "adc x0, x1;"; @@ -13,10 +13,10 @@ TEST_F(ASM_PARSER_STMT_TEST, STMT1) { EXPECT_EQ(instr.opcode, HyperCPU::Opcode::ADC); EXPECT_EQ(instr.op1.type, HCAsm::OperandType::reg); - EXPECT_EQ(instr.op1.reg, HyperCPU::Registers::X0); + EXPECT_EQ(instr.op1.reg, HyperCPU::Reg::X0); EXPECT_EQ(instr.op2.type, HCAsm::OperandType::reg); - EXPECT_EQ(instr.op2.reg, HyperCPU::Registers::X1); + EXPECT_EQ(instr.op2.reg, HyperCPU::Reg::X1); } TEST_F(ASM_PARSER_STMT_TEST, STMT2) { @@ -30,7 +30,7 @@ TEST_F(ASM_PARSER_STMT_TEST, STMT2) { EXPECT_EQ(instr.opcode, HyperCPU::Opcode::ADC); EXPECT_EQ(instr.op1.type, HCAsm::OperandType::reg); - EXPECT_EQ(instr.op1.reg, HyperCPU::Registers::X0); + EXPECT_EQ(instr.op1.reg, HyperCPU::Reg::X0); EXPECT_EQ(instr.op2.type, HCAsm::OperandType::none); } diff --git a/tests/Modular/AssemblerCore/Parser/Tokens.cpp b/tests/Modular/AssemblerCore/Parser/Tokens.cpp index e947670c..8d689db9 100644 --- a/tests/Modular/AssemblerCore/Parser/Tokens.cpp +++ b/tests/Modular/AssemblerCore/Parser/Tokens.cpp @@ -1,5 +1,4 @@ -#include -#include +#include "tests/fixtures.hpp" TEST_F(ASM_PARSER_TEST, TOKEN_STRING) { std::string str = "this is a string to test parser\\n\\r\\\"\\\'\\a\\\\"; diff --git a/tests/Modular/BUILD.bazel b/tests/Modular/BUILD.bazel new file mode 100644 index 00000000..ead31c14 --- /dev/null +++ b/tests/Modular/BUILD.bazel @@ -0,0 +1,17 @@ +load('@rules_cc//cc:defs.bzl', 'cc_test') + +cc_test( + name = 'modular-test', + linkstatic = True, + # TODO: remove when tests are fixed + srcs = glob(['**/*.cpp'], exclude = ['EmulatorCore/Decoding/**/*.cpp']), + deps = [ + '@gtest//:gtest-gmock_main', + '@fmt//:fmt', + '//tests:pch_gtest', + '//tests:test_fixtures', + '//src/PCH:pch_cstd', + '//src/Assembler:assembler_core', + '//src/Emulator:emulator_core', + ] +) diff --git a/tests/Modular/EmulatorCore/CPUInit/CPUInit.cpp b/tests/Modular/EmulatorCore/CPUInit/CPUInit.cpp index 57ee3cc3..b34000a7 100644 --- a/tests/Modular/EmulatorCore/CPUInit/CPUInit.cpp +++ b/tests/Modular/EmulatorCore/CPUInit/CPUInit.cpp @@ -1,8 +1,8 @@ -#include "Logger/Logger.hpp" -#include +#include "tests/gtest.hpp" #define private public -#include +#include "Emulator/Core/CPU/CPU.hpp" +#undef private static constexpr std::uint64_t FULL_CONST = 0x0001020304050607; static constexpr std::uint32_t CONSTH = 0x00010203; @@ -12,7 +12,6 @@ static constexpr std::uint8_t CONSTLLH = 0x06; static constexpr std::uint8_t CONSTLLL = 0x07; TEST(cpu_init, REGS_ARE_INITIALIZED) { - HyperCPU::Logger logger{HyperCPU::LogLevel::ERROR}; HyperCPU::CPU cpu{1, 4096}; for (std::size_t i = 0; i < 13; ++i) cpu.data[i] = FULL_CONST; diff --git a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp index d3b7f304..391de023 100644 --- a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp @@ -1,16 +1,16 @@ -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -18,8 +18,8 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } diff --git a/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp b/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp index 497a1dbb..456e3ff4 100644 --- a/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp +++ b/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp @@ -1,9 +1,9 @@ -#include "pch.hpp" - -#include +#include "PCH/CStd.hpp" +#include "tests/fixtures.hpp" #define private public -#include +#include "Emulator/Core/MemoryController/MemoryControllerST.hpp" +#undef private static constexpr std::uint8_t BYTE = 0x55; static constexpr std::uint16_t WORD = 0x5555; diff --git a/tests/Modular/EmulatorCore/Stack/Stack.cpp b/tests/Modular/EmulatorCore/Stack/Stack.cpp index 59e4309e..0f55c190 100644 --- a/tests/Modular/EmulatorCore/Stack/Stack.cpp +++ b/tests/Modular/EmulatorCore/Stack/Stack.cpp @@ -1,4 +1,4 @@ -#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA = 0x55; static constexpr std::uint16_t WORD_DATA = 0x5555; @@ -63,4 +63,4 @@ TEST_F(STACK_TEST, STACK_POP64) { ASSERT_EQ(*cpu.xsp, 1024); ASSERT_EQ(val, QWORD_DATA); -} \ No newline at end of file +} From ee0ec1fd4c6634d8ad5b2bede639999ed2504dcb Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sun, 11 May 2025 02:12:48 +0300 Subject: [PATCH 28/40] run formatter & patched ci --- .github/workflows/distro-ci.yml | 9 +- .../workflows/run-tests-feature-branch.yml | 28 +- .github/workflows/testing.yml | 48 +-- BUILD.bazel | 30 +- MODULE.bazel | 65 ++-- conandata.yml | 5 - conanfile.py | 42 +- dist/BUILD.bazel | 10 +- docs/conf.py | 21 +- src/Assembler/BUILD.bazel | 39 +- src/Assembler/Core/BinaryTransformer.hpp | 113 +++--- src/Assembler/Core/Compiler.cpp | 43 +- src/Assembler/Core/Compiler.hpp | 5 +- src/Assembler/Core/OpcodeNameAssoc.hpp | 75 ++-- src/Assembler/Core/RegNameAssoc.hpp | 85 ++-- src/Assembler/Main.cpp | 9 +- src/BacktraceProvider/BUILD.bazel | 18 +- src/Common/BUILD.bazel | 19 +- src/Common/LanguageSpec/AllowedFlags.hpp | 58 +-- src/Common/NotImplemented.hpp | 2 +- src/Emulator/BUILD.bazel | 33 +- src/Emulator/Core/CPU/CPU.cpp | 2 +- src/Emulator/Core/CPU/CPU.hpp | 2 +- src/Emulator/Core/CPU/Decoders/StdDecoder.cpp | 6 +- src/Emulator/Core/CPU/Decoders/StdDecoder.hpp | 4 +- .../Core/CPU/InstructionsImpl/ADC.cpp | 308 ++++++++------- .../Core/CPU/InstructionsImpl/ADD.cpp | 261 +++++++------ .../Core/CPU/InstructionsImpl/AND.cpp | 224 +++++------ .../Core/CPU/InstructionsImpl/ANDN.cpp | 268 ++++++------- .../Core/CPU/InstructionsImpl/BSWAP.cpp | 35 +- .../Core/CPU/InstructionsImpl/CALL.cpp | 23 +- .../Core/CPU/InstructionsImpl/CALLE.cpp | 23 +- .../Core/CPU/InstructionsImpl/CALLGR.cpp | 23 +- .../Core/CPU/InstructionsImpl/CALLL.cpp | 23 +- .../Core/CPU/InstructionsImpl/CMP.cpp | 289 +++++++------- .../Core/CPU/InstructionsImpl/COVF.cpp | 1 - .../Core/CPU/InstructionsImpl/CUDF.cpp | 1 - .../Core/CPU/InstructionsImpl/DEC.cpp | 49 ++- .../Core/CPU/InstructionsImpl/DIV.cpp | 51 ++- .../Core/CPU/InstructionsImpl/HALT.cpp | 1 - .../Core/CPU/InstructionsImpl/HID.cpp | 23 +- .../Core/CPU/InstructionsImpl/INC.cpp | 49 ++- .../Core/CPU/InstructionsImpl/INTR.cpp | 17 +- .../Core/CPU/InstructionsImpl/JME.cpp | 19 +- .../Core/CPU/InstructionsImpl/JMGR.cpp | 19 +- .../Core/CPU/InstructionsImpl/JML.cpp | 19 +- .../Core/CPU/InstructionsImpl/JMP.cpp | 19 +- .../Core/CPU/InstructionsImpl/LOIVT.cpp | 16 +- .../Core/CPU/InstructionsImpl/MOV.cpp | 279 +++++++------ .../Core/CPU/InstructionsImpl/MUL.cpp | 261 +++++++------ src/Emulator/Core/CPU/InstructionsImpl/OR.cpp | 225 ++++++----- .../Core/CPU/InstructionsImpl/POP.cpp | 28 +- .../Core/CPU/InstructionsImpl/PUSH.cpp | 53 ++- .../Core/CPU/InstructionsImpl/READ.cpp | 17 +- .../Core/CPU/InstructionsImpl/SHFL.cpp | 85 ++-- .../Core/CPU/InstructionsImpl/SHFR.cpp | 85 ++-- .../Core/CPU/InstructionsImpl/SUB.cpp | 237 ++++++----- .../Core/CPU/InstructionsImpl/WRITE.cpp | 15 +- .../Core/CPU/Interrupts/InterruptHandler.cpp | 4 +- src/Emulator/Core/CPU/OperandsEvaluation.cpp | 2 +- .../MemoryController/IMemoryController.hpp | 44 +-- src/Emulator/Main.cpp | 2 +- src/Emulator/Misc/byteswap.hpp | 2 +- src/PCH/BUILD.bazel | 8 +- src/PCH/CStd.hpp | 1 - src/Pog/BUILD.bazel | 25 +- tests/BUILD.bazel | 22 +- .../AssemblerCore/AssemblerSuccess.cpp | 1 - .../AssemblerCore/FullAssembler.cpp | 1 - .../AssemblerCore/TwoOperandsSuccess.cpp | 1 - tests/Integration/BUILD.bazel | 22 +- .../Integration/EmulatorCore/CPU/CPU_ADC.cpp | 1 - .../Integration/EmulatorCore/CPU/CPU_ADD.cpp | 1 - .../EmulatorCore/Exceptions/Exceptions.cpp | 1 - .../AssemblerCore/Parser/Statements.cpp | 3 +- tests/Modular/BUILD.bazel | 27 +- tests/Pog/Automaton.cpp | 1 - tests/Pog/BUILD.bazel | 20 +- tests/Pog/Grammar.cpp | 1 - tests/Pog/Item.cpp | 1 - tests/Pog/Parser.cpp | 1 - tests/fixtures.hpp | 6 +- tests/gtest.hpp | 2 +- tools/bazel/BUILD.bazel | 2 +- tools/bazel/pch.bzl | 57 ++- tools/build.py | 368 ------------------ tools/increment_version.py | 70 ++-- 87 files changed, 2059 insertions(+), 2455 deletions(-) delete mode 100755 tools/build.py diff --git a/.github/workflows/distro-ci.yml b/.github/workflows/distro-ci.yml index 968195ed..3f605ab7 100644 --- a/.github/workflows/distro-ci.yml +++ b/.github/workflows/distro-ci.yml @@ -44,10 +44,5 @@ jobs: git checkout ${{ github.event.pull_request.head.sha }} git submodule update --init --recursive - python3 tools/build.py -icb \ - --config Release \ - --config Debug \ - --build-dir build \ - -D CMAKE_CXX_COMPILER:STRING=g++ \ - -D CMAKE_CXX_COMPILER:STRING=gcc \ - --profiles-detection + conan profile detect && conan install . --build=missing + bazelisk build //src/... //tests/... --config=linux-opt diff --git a/.github/workflows/run-tests-feature-branch.yml b/.github/workflows/run-tests-feature-branch.yml index f11b9616..7ec06ff7 100644 --- a/.github/workflows/run-tests-feature-branch.yml +++ b/.github/workflows/run-tests-feature-branch.yml @@ -15,28 +15,16 @@ jobs: with: submodules: "true" - - name: Build and test with GCC on Release profile + - name: Install conan dependecies run: | - python3 tools/build.py -icb \ - --config Release \ - --build-dir build \ - -D CMAKE_CXX_COMPILER:STRING=g++ \ - -D CMAKE_C_COMPILER:STRING=gcc \ - --profiles-detection - cd build/Release && ctest -V && cd ../.. - python3 tools/build.py -r --config Release --build-dir build + conan profile detect && conan install . --build=missing - - name: Build and test with LLVM on Release profile + - name: Build and test with GCC on Release profile run: | - python3 tools/build.py -icb \ - --config Release \ - --build-dir build \ - -D CMAKE_CXX_COMPILER:STRING=clang++-19 \ - -D CMAKE_C_COMPILER:STRING=clang-19 \ - --profiles-detection - cd build/Release && ctest -V && cd ../.. - python3 tools/build.py -r --config Release --build-dir build + bazelisk test //src/... //tests/... --config=linux-dbg --compiler=gcc + bazelisk clean --expunge - - name: Cleanup (Conan cache + leftovers in build) + - name: Build and test with LLVM on Release profile run: | - rm -r build/ + bazelisk test //src/... //tests/... --config=linux-dbg --compiler=clang + bazelisk clean --expunge diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index 555ebc55..b36b323e 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -17,50 +17,26 @@ jobs: with: submodules: "true" + - name: Install conan dependecies + run: | + conan profile detect && conan install . --build=missing + - name: Build and test with GCC on Debug profile run: | - python3 tools/build.py -icb \ - --config Debug \ - --build-dir build \ - -D CMAKE_CXX_COMPILER:STRING=g++ \ - -D CMAKE_C_COMPILER:STRING=gcc \ - --profiles-detection - cd build/Debug && ctest -V && cd ../.. - python3 tools/build.py -r --config Debug --build-dir build + bazelisk test //src/... //tests/... --config=linux-dbg --compiler=gcc + bazelisk clean --expunge - name: Build and test with GCC on Release profile run: | - python3 tools/build.py -icb \ - --config Release \ - --build-dir build \ - -D CMAKE_CXX_COMPILER:STRING=g++ \ - -D CMAKE_C_COMPILER:STRING=gcc \ - --profiles-detection - cd build/Release && ctest -V && cd ../.. - python3 tools/build.py -r --config Release --build-dir build + bazelisk test //src/... //tests/... --config=linux-opt --compiler=gcc + bazelisk clean --expunge - name: Build and test with LLVM on Debug profile run: | - python3 tools/build.py -icb \ - --config Debug \ - --build-dir build \ - -D CMAKE_CXX_COMPILER:STRING=clang++-19 \ - -D CMAKE_C_COMPILER:STRING=clang-19 \ - --profiles-detection - cd build/Debug && ctest -V && cd ../.. - python3 tools/build.py -r --config Debug --build-dir build + bazelisk test //src/... //tests/... --config=linux-dbg --compiler=clang + bazelisk clean --expunge - name: Build and test with LLVM on Release profile run: | - python3 tools/build.py -icb \ - --config Release \ - --build-dir build \ - -D CMAKE_CXX_COMPILER:STRING=clang++-19 \ - -D CMAKE_C_COMPILER:STRING=clang-19 \ - --profiles-detection - cd build/Release && ctest -V && cd ../.. - python3 tools/build.py -r --config Release --build-dir build - - - name: Cleanup (Conan cache + leftovers in build) - run: | - rm -r build/ + bazelisk test //src/... //tests/... --config=linux-opt --compiler=clang + bazelisk clean --expunge diff --git a/BUILD.bazel b/BUILD.bazel index 524ad821..76e2bfa1 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -1,25 +1,25 @@ -'Top level build configuration, use for tooling only' +"Top level build configuration, use for tooling only" -load('@aspect_rules_lint//format:defs.bzl', 'format_multirun') -load('@hedron_compile_commands//:refresh_compile_commands.bzl', 'refresh_compile_commands') +load("@aspect_rules_lint//format:defs.bzl", "format_multirun") +load("@hedron_compile_commands//:refresh_compile_commands.bzl", "refresh_compile_commands") package( default_visibility = [ - '//visibility:private', + "//visibility:private", ], ) config_setting( - name = 'linux', - constraint_values = ['@platforms//os:linux'] + name = "linux", + constraint_values = ["@platforms//os:linux"], ) refresh_compile_commands( - name = 'refresh_compile_commands', + name = "refresh_compile_commands", targets = { - '//src/...': '--config=linux-dbg', - '//tests/...': '--config=linux-dbg' - } + "//src/...": "--config=linux-dbg", + "//tests/...": "--config=linux-dbg", + }, # I hope they will support this at some point # targets = select( # { @@ -33,9 +33,9 @@ refresh_compile_commands( ) format_multirun( - name = 'format', - cc = '@llvm_toolchain//:bin/clang-format', - python = '@aspect_rules_lint//format:ruff', - starlark = '@buildifier_prebuilt//:buildifier', - print_command = True + name = "format", + cc = "@llvm_toolchain//:bin/clang-format", + print_command = True, + python = "@aspect_rules_lint//format:ruff", + starlark = "@buildifier_prebuilt//:buildifier", ) diff --git a/MODULE.bazel b/MODULE.bazel index 5174fa20..43688e9c 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -1,50 +1,49 @@ -'HyperCPU' +"HyperCPU" module( - name = 'hyper-cpu', - version = '0.4.13', - compatibility_level = 1 + name = "hyper-cpu", + version = "0.4.13", + compatibility_level = 1, ) # We use conan for deps management -conan = use_extension('//conan:conan_deps_module_extension.bzl', 'conan_extension') - +conan = use_extension("//conan:conan_deps_module_extension.bzl", "conan_extension") use_repo( conan, - 'abseil', - 'argparse', - 'benchmark', - 'boost', - 'eternal', - 'gtest', - 'libbacktrace', - 'libunwind', - 'bzip2', - 'fmt', - 're2', - 'xz_utils', - 'zlib', - 'spdlog' + "abseil", + "argparse", + "benchmark", + "boost", + "bzip2", + "eternal", + "fmt", + "gtest", + "libbacktrace", + "libunwind", + "re2", + "spdlog", + "xz_utils", + "zlib", ) -bazel_dep(name = 'rules_cc', version = '0.0.17') -bazel_dep(name = 'aspect_rules_lint', version = '1.3.5') -bazel_dep(name = 'bazel_skylib', version = '1.7.1') -bazel_dep(name = 'hedron_compile_commands', dev_dependency = True) -bazel_dep(name = 'buildifier_prebuilt', version = '8.0.3', dev_dependency = True) +bazel_dep(name = "rules_cc", version = "0.0.17") +bazel_dep(name = "aspect_rules_lint", version = "1.3.5") +bazel_dep(name = "bazel_skylib", version = "1.7.1") + +bazel_dep(name = "hedron_compile_commands", dev_dependency = True) +bazel_dep(name = "buildifier_prebuilt", version = "8.0.3", dev_dependency = True) git_override( - module_name = 'hedron_compile_commands', - remote = 'https://github.com/hedronvision/bazel-compile-commands-extractor.git', - commit = '4f28899228fb3ad0126897876f147ca15026151e' + module_name = "hedron_compile_commands", + commit = "4f28899228fb3ad0126897876f147ca15026151e", + remote = "https://github.com/hedronvision/bazel-compile-commands-extractor.git", ) # We use this for static analysis -bazel_dep(name = 'toolchains_llvm', version = '1.4.0', dev_dependency = True) +bazel_dep(name = "toolchains_llvm", version = "1.4.0", dev_dependency = True) -llvm = use_extension('@toolchains_llvm//toolchain/extensions:llvm.bzl', 'llvm') +llvm = use_extension("@toolchains_llvm//toolchain/extensions:llvm.bzl", "llvm") llvm.toolchain( - llvm_version = '19.1.7', + llvm_version = "19.1.7", ) - -use_repo(llvm, 'llvm_toolchain') +use_repo(llvm, "llvm_toolchain") diff --git a/conandata.yml b/conandata.yml index 265d7f8a..aa465698 100644 --- a/conandata.yml +++ b/conandata.yml @@ -1,8 +1,3 @@ -# HyperCPU works with multiple buildsystems, this -# switch affects which one will be used to defined project layout, -# toolchains etc. -buildsystem: "bazel" - requirements: gtest: "1.14.0" benchmark: "1.9.1" diff --git a/conanfile.py b/conanfile.py index cad19131..0707284c 100644 --- a/conanfile.py +++ b/conanfile.py @@ -1,23 +1,13 @@ -import enum - -from pathlib import Path +from typing import Dict, Any, Collection from functools import cached_property, lru_cache -from typing import Dict, Any, Collection, Mapping, Callable, Optional, cast from conan import ConanFile -from conan.tools.cmake import cmake_layout from conan.tools.google import bazel_layout -from conan.errors import ConanInvalidConfiguration - - -class Buildsystem(enum.StrEnum): - CMAKE = 'cmake' - BAZEL = 'bazel' class HyperCPU(ConanFile): - name: 'HyperCPU' - settings = ['os', 'compiler', 'build_type', 'arch'] + name: "HyperCPU" + settings = ["os", "compiler", "build_type", "arch"] # conan data is fetched dynamically from # conandata.yml @@ -25,30 +15,12 @@ class HyperCPU(ConanFile): @cached_property def generators(self) -> Collection[str]: - return cast(Collection[str], self.__resolve_buildsystem({ - Buildsystem.CMAKE: lambda _: ['CMakeToolchain', 'CMakeDeps'], - Buildsystem.BAZEL: lambda _: ['BazelToolchain', 'BazelDeps'] - })) + return ["BazelToolchain", "BazelDeps"] @lru_cache def requirements(self) -> None: - for req, version in self.conan_data['requirements'].items(): - self.requires(f'{req}/{version}') + for req, version in self.conan_data["requirements"].items(): + self.requires(f"{req}/{version}") def layout(self): - self.__resolve_buildsystem({ - Buildsystem.CMAKE: lambda self: cmake_layout(self), - Buildsystem.BAZEL: lambda self: bazel_layout(self) - }) - - def __resolve_buildsystem( - self, - visitors: Mapping[Buildsystem, Callable[['HyperCPU'], Optional[Any]]] - ) -> Optional[Any]: - buildsystem = Buildsystem(self.conan_data['buildsystem']) - if buildsystem not in visitors: - raise ConanInvalidConfiguration( - f'buildsystem: {buildsystem} is not supported by visitors: ' + ', '.join(visitors) - ) - - return visitors[buildsystem](self) + bazel_layout(self) diff --git a/dist/BUILD.bazel b/dist/BUILD.bazel index 2d92302d..39a3d6eb 100644 --- a/dist/BUILD.bazel +++ b/dist/BUILD.bazel @@ -1,13 +1,13 @@ -load('@rules_cc//cc:defs.bzl', 'cc_library') +load("@rules_cc//cc:defs.bzl", "cc_library") package( default_visibility = [ - '//:__subpackages__', + "//:__subpackages__", ], ) cc_library( - name = 'hpool', - hdrs = ['HPool/hpool.hpp'], - includes = ['HPool'], + name = "hpool", + hdrs = ["HPool/hpool.hpp"], + includes = ["HPool"], ) diff --git a/docs/conf.py b/docs/conf.py index 2a96157b..162ad653 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -6,25 +6,22 @@ # -- Project information ----------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information -project = 'HyperCPU' -copyright = '2024, HyperWinX' -author = 'HyperWinX' -release = '0.0' +project = "HyperCPU" +copyright = "2024, HyperWinX" +author = "HyperWinX" +release = "0.0" # -- General configuration --------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#general-configuration -extensions = [ - 'sphinx_rtd_theme' -] - -templates_path = ['_templates'] -exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] +extensions = ["sphinx_rtd_theme"] +templates_path = ["_templates"] +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] # -- Options for HTML output ------------------------------------------------- # https://www.sphinx-doc.org/en/master/usage/configuration.html#options-for-html-output -html_theme = 'sphinx_rtd_theme' -html_static_path = ['_static'] +html_theme = "sphinx_rtd_theme" +html_static_path = ["_static"] diff --git a/src/Assembler/BUILD.bazel b/src/Assembler/BUILD.bazel index 0a9cead2..8d09b706 100644 --- a/src/Assembler/BUILD.bazel +++ b/src/Assembler/BUILD.bazel @@ -1,28 +1,31 @@ -load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') +load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library") cc_library( - name = 'assembler_core', - srcs = glob(['**/*.cpp'], exclude = ['Main.cpp']), - hdrs = glob(['**/*.hpp']), + name = "assembler_core", + srcs = glob( + ["**/*.cpp"], + exclude = ["Main.cpp"], + ), + hdrs = glob(["**/*.hpp"]), + visibility = ["//visibility:public"], deps = [ - '@fmt//:fmt', - '@re2//:re2', - '@eternal//:eternal', - '@spdlog//:spdlog', - '//dist:hpool', - '//src/PCH:pch_cstd', - '//src/Pog:pog', - '//src/Common:hcpu_common' + "//dist:hpool", + "//src/Common:hcpu_common", + "//src/PCH:pch_cstd", + "//src/Pog:pog", + "@eternal", + "@fmt", + "@re2", + "@spdlog", ], - visibility = ['//visibility:public'] ) cc_binary( - name = 'hcasm', - srcs = ['Main.cpp'], + name = "hcasm", + srcs = ["Main.cpp"], + visibility = ["//visibility:private"], deps = [ - '@argparse//:argparse', - ':assembler_core' + ":assembler_core", + "@argparse", ], - visibility = ['//visibility:private'] ) diff --git a/src/Assembler/Core/BinaryTransformer.hpp b/src/Assembler/Core/BinaryTransformer.hpp index f34e3b6c..871b9813 100644 --- a/src/Assembler/Core/BinaryTransformer.hpp +++ b/src/Assembler/Core/BinaryTransformer.hpp @@ -2,10 +2,9 @@ #include -#include "PCH/CStd.hpp" -#include "Common/LanguageSpec/Flags.hpp" #include "Assembler/Core/Compiler.hpp" - +#include "Common/LanguageSpec/Flags.hpp" +#include "PCH/CStd.hpp" namespace HCAsm { struct BinaryResult; @@ -13,19 +12,19 @@ namespace HCAsm { struct Operand; enum class Op1T : std::uint8_t { - R = 0x10, - M = 0x20, - IMM = 0x30, - RM = 0x40, - NONE = 0x50 + R = 0x10, + M = 0x20, + IMM = 0x30, + RM = 0x40, + NONE = 0x50 }; enum class Op2T : std::uint8_t { - R = 0x01, - M = 0x02, - IMM = 0x03, - RM = 0x04, - NONE = 0x05 + R = 0x01, + M = 0x02, + IMM = 0x03, + RM = 0x04, + NONE = 0x05 }; constexpr inline std::uint8_t QuickOR(Op1T a, Op2T b) { @@ -37,59 +36,79 @@ namespace HCAsm { } enum class OperandTypes : std::uint8_t { - R_R = QuickOR(Op1T::R, Op2T::R), - R_RM = QuickOR(Op1T::R, Op2T::RM), - R_M = QuickOR(Op1T::R, Op2T::M), - R_IMM = QuickOR(Op1T::R, Op2T::IMM), - RM_R = QuickOR(Op1T::RM, Op2T::R), - RM_M = QuickOR(Op1T::RM, Op2T::M), - RM_IMM = QuickOR(Op1T::RM, Op2T::IMM), - M_R = QuickOR(Op1T::M, Op2T::R), - R = QuickOR(Op1T::R, Op2T::NONE), - M = QuickOR(Op1T::M, Op2T::NONE), - IMM = QuickOR(Op1T::IMM, Op2T::NONE), - NONE = QuickOR(Op1T::NONE, Op2T::NONE), + R_R = QuickOR(Op1T::R, Op2T::R), + R_RM = QuickOR(Op1T::R, Op2T::RM), + R_M = QuickOR(Op1T::R, Op2T::M), + R_IMM = QuickOR(Op1T::R, Op2T::IMM), + RM_R = QuickOR(Op1T::RM, Op2T::R), + RM_M = QuickOR(Op1T::RM, Op2T::M), + RM_IMM = QuickOR(Op1T::RM, Op2T::IMM), + M_R = QuickOR(Op1T::M, Op2T::R), + R = QuickOR(Op1T::R, Op2T::NONE), + M = QuickOR(Op1T::M, Op2T::NONE), + IMM = QuickOR(Op1T::IMM, Op2T::NONE), + NONE = QuickOR(Op1T::NONE, Op2T::NONE), }; constexpr HyperCPU::OperandTypes QuickCast(std::uint8_t x) { switch (static_cast(x)) { - case OperandTypes::R_R: return HyperCPU::OperandTypes::R_R; - case OperandTypes::R_RM: return HyperCPU::OperandTypes::R_RM; - case OperandTypes::R_M: return HyperCPU::OperandTypes::R_M; - case OperandTypes::R_IMM: return HyperCPU::OperandTypes::R_IMM; - case OperandTypes::RM_R: return HyperCPU::OperandTypes::RM_R; - case OperandTypes::RM_M: return HyperCPU::OperandTypes::RM_M; - case OperandTypes::RM_IMM: return HyperCPU::OperandTypes::RM_IMM; - case OperandTypes::M_R: return HyperCPU::OperandTypes::M_R; - case OperandTypes::R: return HyperCPU::OperandTypes::R; - case OperandTypes::M: return HyperCPU::OperandTypes::M; - case OperandTypes::IMM: return HyperCPU::OperandTypes::IMM; - case OperandTypes::NONE: return HyperCPU::OperandTypes::NONE; - default: - spdlog::error("Invalid operand types!"); - std::abort(); + case OperandTypes::R_R: + return HyperCPU::OperandTypes::R_R; + case OperandTypes::R_RM: + return HyperCPU::OperandTypes::R_RM; + case OperandTypes::R_M: + return HyperCPU::OperandTypes::R_M; + case OperandTypes::R_IMM: + return HyperCPU::OperandTypes::R_IMM; + case OperandTypes::RM_R: + return HyperCPU::OperandTypes::RM_R; + case OperandTypes::RM_M: + return HyperCPU::OperandTypes::RM_M; + case OperandTypes::RM_IMM: + return HyperCPU::OperandTypes::RM_IMM; + case OperandTypes::M_R: + return HyperCPU::OperandTypes::M_R; + case OperandTypes::R: + return HyperCPU::OperandTypes::R; + case OperandTypes::M: + return HyperCPU::OperandTypes::M; + case OperandTypes::IMM: + return HyperCPU::OperandTypes::IMM; + case OperandTypes::NONE: + return HyperCPU::OperandTypes::NONE; + default: + spdlog::error("Invalid operand types!"); + std::abort(); } } constexpr HyperCPU::Mode cast_mode(HCAsm::Mode md) { switch (md) { - case HCAsm::Mode::b8: return HyperCPU::Mode::b8; - case HCAsm::Mode::b16: return HyperCPU::Mode::b16; - case HCAsm::Mode::b32: return HyperCPU::Mode::b32; - case HCAsm::Mode::b64: return HyperCPU::Mode::b64; - default: std::abort(); + case HCAsm::Mode::b8: + return HyperCPU::Mode::b8; + case HCAsm::Mode::b16: + return HyperCPU::Mode::b16; + case HCAsm::Mode::b32: + return HyperCPU::Mode::b32; + case HCAsm::Mode::b64: + return HyperCPU::Mode::b64; + default: + std::abort(); } } class BinaryTransformer { public: // TODO: move to src - BinaryTransformer(BinaryResult& result, CompilerState* state = nullptr) : res(result), state(state) { } + BinaryTransformer(BinaryResult& result, CompilerState* state = nullptr) + : res(result), state(state) { + } void EncodeInstruction(Instruction& instr); HyperCPU::OperandTypes DetermineOperandTypes(Operand& op1, Operand& op2); + private: BinaryResult& res; CompilerState* state; }; -} +} // namespace HCAsm diff --git a/src/Assembler/Core/Compiler.cpp b/src/Assembler/Core/Compiler.cpp index dd1b12e7..f038a654 100644 --- a/src/Assembler/Core/Compiler.cpp +++ b/src/Assembler/Core/Compiler.cpp @@ -172,7 +172,8 @@ constexpr inline std::uint8_t HCAsm::HCAsmCompiler::OperandSize(HCAsm::OperandTy case HCAsm::OperandType::uint: case HCAsm::OperandType::label: return 8; - default: std::abort(); + default: + std::abort(); } } @@ -189,7 +190,8 @@ std::uint8_t HCAsm::HCAsmCompiler::ModeToSize(const Operand& op) { case Mode::b64_label: case Mode::b64: return 8; - default: std::abort(); + default: + std::abort(); } } @@ -204,7 +206,8 @@ std::uint8_t HCAsm::HCAsmCompiler::ModeToSize(Mode md) { case Mode::b64_label: case Mode::b64: return 8; - default: std::abort(); + default: + std::abort(); } } @@ -291,7 +294,8 @@ std::uint8_t HCAsm::HCAsmCompiler::InstructionSize(HCAsm::Instruction& instr) { break; case OperandType::none: break; - default: std::abort(); + default: + std::abort(); } return result; @@ -307,21 +311,22 @@ HCAsm::BinaryResult HCAsm::HCAsmCompiler::TransformToBinary(HCAsm::CompilerState if (label.is_entry_point) { ir.entry_point = ir.code_size; } }, [&ir](RawValue& raw) mutable -> void { ir.code_size += [&raw]() -> std::uint8_t { - switch (raw.mode) { - case Mode::b8_str: - return std::get>(raw.value.variant)->size(); - case Mode::b8: - return 1; - case Mode::b16: - return 2; - case Mode::b32: - return 4; - case Mode::b64_label: - case Mode::b64: - return 8; - default: std::abort(); - } - }(); }); + switch (raw.mode) { + case Mode::b8_str: + return std::get>(raw.value.variant)->size(); + case Mode::b8: + return 1; + case Mode::b16: + return 2; + case Mode::b32: + return 4; + case Mode::b64_label: + case Mode::b64: + return 8; + default: + std::abort(); + } + }(); }); } // Resolve references - pass 2 diff --git a/src/Assembler/Core/Compiler.hpp b/src/Assembler/Core/Compiler.hpp index 083f3fce..744465aa 100644 --- a/src/Assembler/Core/Compiler.hpp +++ b/src/Assembler/Core/Compiler.hpp @@ -7,8 +7,8 @@ #include "Common/Helpers/Classes.hpp" #include "Common/LanguageSpec/Opcodes.hpp" #include "Common/LanguageSpec/Registers.hpp" -#include "Pog/Pog.hpp" #include "PCH/CStd.hpp" +#include "Pog/Pog.hpp" namespace HCAsm { enum class ValueType { @@ -185,7 +185,8 @@ namespace HCAsm { case Reg::XLLL2: case Reg::XLLL3: return Mode::b8; - default: std::abort(); + default: + std::abort(); } // TODO: handle missing return } diff --git a/src/Assembler/Core/OpcodeNameAssoc.hpp b/src/Assembler/Core/OpcodeNameAssoc.hpp index a30a1609..68aad063 100644 --- a/src/Assembler/Core/OpcodeNameAssoc.hpp +++ b/src/Assembler/Core/OpcodeNameAssoc.hpp @@ -7,42 +7,39 @@ #include "PCH/CStd.hpp" constexpr inline const auto opcode_assoc = mapbox::eternal::hash_map( - { - {"adc", HyperCPU::Opcode::ADC}, - {"add", HyperCPU::Opcode::ADD}, - {"and", HyperCPU::Opcode::AND}, - {"andn", HyperCPU::Opcode::ANDN}, - {"bswap", HyperCPU::Opcode::BSWAP}, - {"call", HyperCPU::Opcode::CALL}, - {"ccrf", HyperCPU::Opcode::CCRF}, - {"covf", HyperCPU::Opcode::COVF}, - {"cudf", HyperCPU::Opcode::CUDF}, - {"hid", HyperCPU::Opcode::HID}, - {"inc", HyperCPU::Opcode::INC}, - {"dec", HyperCPU::Opcode::DEC}, - {"div", HyperCPU::Opcode::DIV}, - {"mul", HyperCPU::Opcode::MUL}, - {"sub", HyperCPU::Opcode::SUB}, - {"shfr", HyperCPU::Opcode::SHFR}, - {"shfl", HyperCPU::Opcode::SHFL}, - {"or", HyperCPU::Opcode::OR}, - {"halt", HyperCPU::Opcode::HALT}, - {"loivt", HyperCPU::Opcode::LOIVT}, - {"intr", HyperCPU::Opcode::INTR}, - {"ret", HyperCPU::Opcode::RET}, - {"iret", HyperCPU::Opcode::IRET}, - {"mov", HyperCPU::Opcode::MOV}, - {"read", HyperCPU::Opcode::READ}, - {"write", HyperCPU::Opcode::WRITE}, - {"jmp", HyperCPU::Opcode::JMP}, - {"push", HyperCPU::Opcode::PUSH}, - {"pop", HyperCPU::Opcode::POP}, - {"calle", HyperCPU::Opcode::CALLE}, - {"callgr", HyperCPU::Opcode::CALLGR}, - {"calll", HyperCPU::Opcode::CALLL}, - {"jme", HyperCPU::Opcode::JME}, - {"jmgr", HyperCPU::Opcode::JMGR}, - {"jml", HyperCPU::Opcode::JML}, - {"cmp", HyperCPU::Opcode::CMP} - } -); + {{"adc", HyperCPU::Opcode::ADC}, + {"add", HyperCPU::Opcode::ADD}, + {"and", HyperCPU::Opcode::AND}, + {"andn", HyperCPU::Opcode::ANDN}, + {"bswap", HyperCPU::Opcode::BSWAP}, + {"call", HyperCPU::Opcode::CALL}, + {"ccrf", HyperCPU::Opcode::CCRF}, + {"covf", HyperCPU::Opcode::COVF}, + {"cudf", HyperCPU::Opcode::CUDF}, + {"hid", HyperCPU::Opcode::HID}, + {"inc", HyperCPU::Opcode::INC}, + {"dec", HyperCPU::Opcode::DEC}, + {"div", HyperCPU::Opcode::DIV}, + {"mul", HyperCPU::Opcode::MUL}, + {"sub", HyperCPU::Opcode::SUB}, + {"shfr", HyperCPU::Opcode::SHFR}, + {"shfl", HyperCPU::Opcode::SHFL}, + {"or", HyperCPU::Opcode::OR}, + {"halt", HyperCPU::Opcode::HALT}, + {"loivt", HyperCPU::Opcode::LOIVT}, + {"intr", HyperCPU::Opcode::INTR}, + {"ret", HyperCPU::Opcode::RET}, + {"iret", HyperCPU::Opcode::IRET}, + {"mov", HyperCPU::Opcode::MOV}, + {"read", HyperCPU::Opcode::READ}, + {"write", HyperCPU::Opcode::WRITE}, + {"jmp", HyperCPU::Opcode::JMP}, + {"push", HyperCPU::Opcode::PUSH}, + {"pop", HyperCPU::Opcode::POP}, + {"calle", HyperCPU::Opcode::CALLE}, + {"callgr", HyperCPU::Opcode::CALLGR}, + {"calll", HyperCPU::Opcode::CALLL}, + {"jme", HyperCPU::Opcode::JME}, + {"jmgr", HyperCPU::Opcode::JMGR}, + {"jml", HyperCPU::Opcode::JML}, + {"cmp", HyperCPU::Opcode::CMP}}); diff --git a/src/Assembler/Core/RegNameAssoc.hpp b/src/Assembler/Core/RegNameAssoc.hpp index 03e98910..9930ab18 100644 --- a/src/Assembler/Core/RegNameAssoc.hpp +++ b/src/Assembler/Core/RegNameAssoc.hpp @@ -7,47 +7,44 @@ #include "PCH/CStd.hpp" constexpr inline const auto registers_assoc = mapbox::eternal::hash_map( - { - {"x0", HyperCPU::Reg::X0}, - {"x1", HyperCPU::Reg::X1}, - {"x2", HyperCPU::Reg::X2}, - {"x3", HyperCPU::Reg::X3}, - {"x4", HyperCPU::Reg::X4}, - {"x5", HyperCPU::Reg::X5}, - {"x6", HyperCPU::Reg::X6}, - {"x7", HyperCPU::Reg::X7}, - {"xh0", HyperCPU::Reg::XH0}, - {"xh1", HyperCPU::Reg::XH1}, - {"xh2", HyperCPU::Reg::XH2}, - {"xh3", HyperCPU::Reg::XH3}, - {"xh4", HyperCPU::Reg::XH4}, - {"xh5", HyperCPU::Reg::XH5}, - {"xh6", HyperCPU::Reg::XH6}, - {"xh7", HyperCPU::Reg::XH7}, - {"xl0", HyperCPU::Reg::XL0}, - {"xl1", HyperCPU::Reg::XL1}, - {"xl2", HyperCPU::Reg::XL2}, - {"xl3", HyperCPU::Reg::XL3}, - {"xl4", HyperCPU::Reg::XL4}, - {"xl5", HyperCPU::Reg::XL5}, - {"xl6", HyperCPU::Reg::XL6}, - {"xl7", HyperCPU::Reg::XL7}, - {"xll0", HyperCPU::Reg::XLL0}, - {"xll1", HyperCPU::Reg::XLL1}, - {"xll2", HyperCPU::Reg::XLL2}, - {"xll3", HyperCPU::Reg::XLL3}, - {"xllh0", HyperCPU::Reg::XLLH0}, - {"xllh1", HyperCPU::Reg::XLLH1}, - {"xllh2", HyperCPU::Reg::XLLH2}, - {"xllh3", HyperCPU::Reg::XLLH3}, - {"xlll0", HyperCPU::Reg::XLLL0}, - {"xlll1", HyperCPU::Reg::XLLL1}, - {"xlll2", HyperCPU::Reg::XLLL2}, - {"xlll3", HyperCPU::Reg::XLLL3}, - {"xbp", HyperCPU::Reg::XBP}, - {"xsp", HyperCPU::Reg::XSP}, - {"xip", HyperCPU::Reg::XIP}, - {"xgdp", HyperCPU::Reg::XGDP}, - {"xivt", HyperCPU::Reg::XIVT} - } -); + {{"x0", HyperCPU::Reg::X0}, + {"x1", HyperCPU::Reg::X1}, + {"x2", HyperCPU::Reg::X2}, + {"x3", HyperCPU::Reg::X3}, + {"x4", HyperCPU::Reg::X4}, + {"x5", HyperCPU::Reg::X5}, + {"x6", HyperCPU::Reg::X6}, + {"x7", HyperCPU::Reg::X7}, + {"xh0", HyperCPU::Reg::XH0}, + {"xh1", HyperCPU::Reg::XH1}, + {"xh2", HyperCPU::Reg::XH2}, + {"xh3", HyperCPU::Reg::XH3}, + {"xh4", HyperCPU::Reg::XH4}, + {"xh5", HyperCPU::Reg::XH5}, + {"xh6", HyperCPU::Reg::XH6}, + {"xh7", HyperCPU::Reg::XH7}, + {"xl0", HyperCPU::Reg::XL0}, + {"xl1", HyperCPU::Reg::XL1}, + {"xl2", HyperCPU::Reg::XL2}, + {"xl3", HyperCPU::Reg::XL3}, + {"xl4", HyperCPU::Reg::XL4}, + {"xl5", HyperCPU::Reg::XL5}, + {"xl6", HyperCPU::Reg::XL6}, + {"xl7", HyperCPU::Reg::XL7}, + {"xll0", HyperCPU::Reg::XLL0}, + {"xll1", HyperCPU::Reg::XLL1}, + {"xll2", HyperCPU::Reg::XLL2}, + {"xll3", HyperCPU::Reg::XLL3}, + {"xllh0", HyperCPU::Reg::XLLH0}, + {"xllh1", HyperCPU::Reg::XLLH1}, + {"xllh2", HyperCPU::Reg::XLLH2}, + {"xllh3", HyperCPU::Reg::XLLH3}, + {"xlll0", HyperCPU::Reg::XLLL0}, + {"xlll1", HyperCPU::Reg::XLLL1}, + {"xlll2", HyperCPU::Reg::XLLL2}, + {"xlll3", HyperCPU::Reg::XLLL3}, + {"xbp", HyperCPU::Reg::XBP}, + {"xsp", HyperCPU::Reg::XSP}, + {"xip", HyperCPU::Reg::XIP}, + {"xgdp", HyperCPU::Reg::XGDP}, + {"xivt", HyperCPU::Reg::XIVT}}); diff --git a/src/Assembler/Main.cpp b/src/Assembler/Main.cpp index ecc84e4f..26452e4b 100644 --- a/src/Assembler/Main.cpp +++ b/src/Assembler/Main.cpp @@ -1,6 +1,6 @@ -#include #include #include +#include #include "Assembler/Core/Compiler.hpp" #include "Common/NotImplemented.hpp" @@ -66,8 +66,8 @@ int main(int argc, char** argv) { // Verify that files are available if (!std::filesystem::is_regular_file(source)) { - spdlog::error("Source file \"{}\" is not a regular file!", source); - return 1; + spdlog::error("Source file \"{}\" is not a regular file!", source); + return 1; } std::ifstream src(source); @@ -88,8 +88,7 @@ int main(int argc, char** argv) { std::string contents( (std::istreambuf_iterator(src)), - std::istreambuf_iterator() - ); + std::istreambuf_iterator()); std::uint32_t code_size; diff --git a/src/BacktraceProvider/BUILD.bazel b/src/BacktraceProvider/BUILD.bazel index 3e36da4b..b4222290 100644 --- a/src/BacktraceProvider/BUILD.bazel +++ b/src/BacktraceProvider/BUILD.bazel @@ -1,14 +1,14 @@ -load('@rules_cc//cc:defs.bzl', 'cc_library') +load("@rules_cc//cc:defs.bzl", "cc_library") cc_library( - name = 'backtrace_provider', - srcs = ['BacktraceProvider.cpp'], - hdrs = ['BacktraceProvider.hpp'], + name = "backtrace_provider", + srcs = ["BacktraceProvider.cpp"], + hdrs = ["BacktraceProvider.hpp"], + visibility = ["//visibility:public"], deps = [ - '@fmt//:fmt', - '@libbacktrace//:libbacktrace', - '@libunwind//:libunwind', - '//src/PCH:pch_cstd' + "//src/PCH:pch_cstd", + "@fmt", + "@libbacktrace", + "@libunwind", ], - visibility = ['//visibility:public'] ) diff --git a/src/Common/BUILD.bazel b/src/Common/BUILD.bazel index 3a338f08..bcbca553 100644 --- a/src/Common/BUILD.bazel +++ b/src/Common/BUILD.bazel @@ -1,13 +1,16 @@ -load('@rules_cc//cc:defs.bzl', 'cc_library') +load("@rules_cc//cc:defs.bzl", "cc_library") cc_library( - name = 'hcpu_common', - srcs = glob(['**/*.cpp'], allow_empty = True), - hdrs = glob(['**/*.hpp']), - strip_include_prefix = '/src', + name = "hcpu_common", + srcs = glob( + ["**/*.cpp"], + allow_empty = True, + ), + hdrs = glob(["**/*.hpp"]), + strip_include_prefix = "/src", + visibility = ["//visibility:public"], deps = [ - '@spdlog//:spdlog', - '//src/PCH:pch_cstd' + "//src/PCH:pch_cstd", + "@spdlog", ], - visibility = ['//visibility:public'] ) diff --git a/src/Common/LanguageSpec/AllowedFlags.hpp b/src/Common/LanguageSpec/AllowedFlags.hpp index 23f37444..8653cc6a 100644 --- a/src/Common/LanguageSpec/AllowedFlags.hpp +++ b/src/Common/LanguageSpec/AllowedFlags.hpp @@ -5,35 +5,35 @@ namespace HyperCPU { inline static constexpr std::uint8_t SUPPORT_ALL = 0b00011011; inline static const std::uint8_t AllowedOpModes[128][12] = { - {}, // NULL - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ADC - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ADD - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // AND - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ANDN - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // BSWAP - {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALL - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // CCRF - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // COVF - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // CUDF - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // HID - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // INC - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // DEC - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // DIV - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // MUL - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // SUB - {SUPPORT_ALL, 0, 0, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // SHFR - {SUPPORT_ALL, 0, 0, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // SHFL - {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // OR - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // HALT - {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // LOIVT - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // INTR - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // IRET - {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // RET - {0, 0, 0, 0, 0, 0, 0, 0, 0b11000000, 0, 0b11000000, 0}, // READ - {0b11000000, 0, 0, 0b11000000, 0, 0, 0, 0, 0, 0, 0}, // WRITE - {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // JMP - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, SUPPORT_ALL, 0}, // PUSH - {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // POP + {}, // NULL + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ADC + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ADD + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // AND + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // ANDN + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // BSWAP + {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALL + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // CCRF + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // COVF + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // CUDF + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // HID + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // INC + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // DEC + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // DIV + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // MUL + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // SUB + {SUPPORT_ALL, 0, 0, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // SHFR + {SUPPORT_ALL, 0, 0, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // SHFL + {SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, SUPPORT_ALL, 0, 0, 0, 0, 0, 0, 0, 0}, // OR + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // HALT + {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // LOIVT + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // INTR + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // IRET + {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL}, // RET + {0, 0, 0, 0, 0, 0, 0, 0, 0b11000000, 0, 0b11000000, 0}, // READ + {0b11000000, 0, 0, 0b11000000, 0, 0, 0, 0, 0, 0, 0}, // WRITE + {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // JMP + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, SUPPORT_ALL, 0}, // PUSH + {0, 0, 0, 0, 0, 0, 0, 0, SUPPORT_ALL, 0, 0, 0}, // POP {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALLE {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALLGR {0, 0, 0, 0, 0, 0, 0, 0, 0b00000011, 0, 0b00000011, 0}, // CALLL diff --git a/src/Common/NotImplemented.hpp b/src/Common/NotImplemented.hpp index 3f509ee5..6d81d6fb 100644 --- a/src/Common/NotImplemented.hpp +++ b/src/Common/NotImplemented.hpp @@ -5,6 +5,6 @@ namespace HyperCPU { HCPU_ALWAYS_INLINE static void PrintUnsupported(std::string_view /* msg */) { - std::abort(); + std::abort(); } } // namespace HyperCPU diff --git a/src/Emulator/BUILD.bazel b/src/Emulator/BUILD.bazel index 52138c00..93cf1423 100644 --- a/src/Emulator/BUILD.bazel +++ b/src/Emulator/BUILD.bazel @@ -1,25 +1,28 @@ -load('@rules_cc//cc:defs.bzl', 'cc_library', 'cc_binary') +load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library") cc_library( - name = 'emulator_core', - srcs = glob(['**/*.cpp'], exclude = ['Main.cpp']), - hdrs = glob(['**/*.hpp']), + name = "emulator_core", + srcs = glob( + ["**/*.cpp"], + exclude = ["Main.cpp"], + ), + hdrs = glob(["**/*.hpp"]), + visibility = ["//visibility:public"], deps = [ - '@fmt//:fmt', - '@eternal//:eternal', - '//src/Assembler:assembler_core', - '//src/PCH:pch_cstd', - '//src/Pog:pog' + "//src/Assembler:assembler_core", + "//src/PCH:pch_cstd", + "//src/Pog:pog", + "@eternal", + "@fmt", ], - visibility = ['//visibility:public'] ) cc_binary( - name = 'hcemul', - srcs = ['Main.cpp'], + name = "hcemul", + srcs = ["Main.cpp"], + visibility = ["//visibility:private"], deps = [ - '@argparse//:argparse', - ':emulator_core' + ":emulator_core", + "@argparse", ], - visibility = ['//visibility:private'] ) diff --git a/src/Emulator/Core/CPU/CPU.cpp b/src/Emulator/Core/CPU/CPU.cpp index 49d20f03..31d0f01e 100644 --- a/src/Emulator/Core/CPU/CPU.cpp +++ b/src/Emulator/Core/CPU/CPU.cpp @@ -1,9 +1,9 @@ #include "Common/LanguageSpec/Opcodes.hpp" #include "PCH/CStd.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" #include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" -#include "Common/LanguageSpec/Opcodes.hpp" #include "Emulator/Core/MemoryController/MemoryControllerST.hpp" HyperCPU::CPU::CPU(std::uint16_t core_count, std::uint64_t mem_size, char* binary, std::uint64_t binary_size) diff --git a/src/Emulator/Core/CPU/CPU.hpp b/src/Emulator/Core/CPU/CPU.hpp index 686cd5db..8899dfd8 100644 --- a/src/Emulator/Core/CPU/CPU.hpp +++ b/src/Emulator/Core/CPU/CPU.hpp @@ -2,9 +2,9 @@ #include "PCH/CStd.hpp" +#include "Common/LanguageSpec/Flags.hpp" #include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" #include "Emulator/Core/CPU/IO/Simple.hpp" -#include "Common/LanguageSpec/Flags.hpp" #include "Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp" #include "Emulator/Core/MemoryController/IMemoryController.hpp" diff --git a/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp b/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp index 9d0610c3..73a28e23 100644 --- a/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp +++ b/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp @@ -1,11 +1,11 @@ #include "PCH/CStd.hpp" -#include "Emulator/Core/CPU/CPU.hpp" -#include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" #include "Common/LanguageSpec/AllowedFlags.hpp" #include "Common/LanguageSpec/Flags.hpp" -#include "Common/LanguageSpec/Registers.hpp" #include "Common/LanguageSpec/Opcodes.hpp" +#include "Common/LanguageSpec/Registers.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" // TODO: лишать кошка жена за такое #define dcdr_assert(expr) \ diff --git a/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp b/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp index b29471e4..a225d6bf 100644 --- a/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp +++ b/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp @@ -2,9 +2,9 @@ #include "PCH/CStd.hpp" -#include "Emulator/Core/CPU/Decoders/IDecoder.hpp" #include "Common/LanguageSpec/Flags.hpp" #include "Common/LanguageSpec/Opcodes.hpp" +#include "Emulator/Core/CPU/Decoders/IDecoder.hpp" #include "Emulator/Core/MemoryController/IMemoryController.hpp" #include "Emulator/Misc/bit_cast.hpp" @@ -102,4 +102,4 @@ namespace HyperCPU { ~Decoder() = default; }; -}; +}; // namespace HyperCPU diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp index 02c2a506..243a290d 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp @@ -1,5 +1,5 @@ -#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/ALU.hpp" +#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Misc/bit_cast.hpp" #include "Emulator/Misc/overflow.hpp" @@ -8,151 +8,167 @@ using namespace HyperALU; void HyperCPU::CPU::ExecADC(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case OperandTypes::R_R: { - switch (instr.m_opcode_mode) { - case Mode::b8: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - if (crf) ++op1.deref(); - break; - - case Mode::b16: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - if (crf) ++op1.deref(); - break; - - case Mode::b32: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - if (crf) ++op1.deref(); - break; - - case Mode::b64: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - if (crf) ++op1.deref(); - break; - } - break; - } - - case OperandTypes::R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - } - break; - } - - case OperandTypes::R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - } - break; - } - - case OperandTypes::R_IMM: { - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case Mode::b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case Mode::b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - - case Mode::b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - if (crf) ++op1.deref(); - break; - } - } - break; - } - - default: + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + if (crf) + ++op1.deref(); + break; + + case Mode::b16: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + if (crf) + ++op1.deref(); + break; + + case Mode::b32: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + if (crf) + ++op1.deref(); + break; + + case Mode::b64: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + if (crf) + ++op1.deref(); + break; + } + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + } + break; + } + + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + if (crf) + ++op1.deref(); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp index 3129df45..1c3769c9 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp @@ -1,141 +1,140 @@ -#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/ALU.hpp" +#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Misc/bit_cast.hpp" #include "Emulator/Misc/overflow.hpp" - void HyperCPU::CPU::ExecADD(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case OperandTypes::R_R: { - switch (instr.m_opcode_mode) { - case Mode::b8: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b16: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b32: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b64: - ovf = AdditionWillOverflow(op1.deref(), op2.deref()); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - break; - } - - case OperandTypes::R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - } - break; - } - - case OperandTypes::R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - } - break; - } - - case OperandTypes::R_IMM: { - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - ovf = AdditionWillOverflow(op1.deref(), val); - op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); - break; - } - } - break; - } - - default: + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b16: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b32: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b64: + ovf = AdditionWillOverflow(op1.deref(), op2.deref()); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + ovf = AdditionWillOverflow(op1.deref(), val); + op1.deref() = HyperALU::__hcpu_add(op1.deref(), val); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp b/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp index 3db8b343..71301391 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp @@ -1,5 +1,5 @@ -#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/ALU.hpp" +#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Misc/bit_cast.hpp" @@ -7,119 +7,119 @@ using namespace HyperALU; void HyperCPU::CPU::ExecAND(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case OperandTypes::R_R: { - switch (instr.m_opcode_mode) { - case Mode::b8: - op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b16: - op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b32: - op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b64: - op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - break; - } - - case OperandTypes::R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - } - break; - } - - case OperandTypes::R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - } - break; - } - - case OperandTypes::R_IMM: { - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_and(op1.deref(), val); - break; - } - } + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b16: + op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b32: + op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b64: + op1.deref() = __hcpu_and(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); break; - } + } + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } - default: + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_and(op1.deref(), val); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp index 69f63199..bf1b3568 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp @@ -1,5 +1,5 @@ -#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/ALU.hpp" +#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Misc/bit_cast.hpp" @@ -7,139 +7,139 @@ using namespace HyperALU; void HyperCPU::CPU::ExecANDN(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case OperandTypes::R_R: { - switch (instr.m_opcode_mode) { - case Mode::b8: { - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - - case Mode::b16: { - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - - case Mode::b32: { - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - - case Mode::b64: { - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - } - break; - } - - case OperandTypes::R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - } - break; - } - - case OperandTypes::R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - } - break; - } - - case OperandTypes::R_IMM: { - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case Mode::b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case Mode::b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - - case Mode::b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - auto& dst = op1.deref(); - dst = __hcpu_and(__hcpu_not(dst), val); - break; - } - } - break; - } - - default: + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + + case Mode::b16: { + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + + case Mode::b32: { + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + + case Mode::b64: { + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + } + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + } + break; + } + + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + auto& dst = op1.deref(); + dst = __hcpu_and(__hcpu_not(dst), val); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp index 1154f332..54156caf 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp @@ -2,28 +2,27 @@ #include "Emulator/Misc/byteswap.hpp" - void HyperCPU::CPU::ExecBSWAP(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_opcode_mode) { - case Mode::b8: - break; + case Mode::b8: + break; - case Mode::b16: { - auto& dst = op1.deref(); - dst = HyperCPU::byteswap(dst); - break; - } + case Mode::b16: { + auto& dst = op1.deref(); + dst = HyperCPU::byteswap(dst); + break; + } - case Mode::b32: { - auto& dst = op1.deref(); - dst = HyperCPU::byteswap(dst); - break; - } + case Mode::b32: { + auto& dst = op1.deref(); + dst = HyperCPU::byteswap(dst); + break; + } - case Mode::b64: { - auto& dst = op1.deref(); - dst = HyperCPU::byteswap(dst); - break; - } + case Mode::b64: { + auto& dst = op1.deref(); + dst = HyperCPU::byteswap(dst); + break; + } } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp index 6ed64033..03ad91a6 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp @@ -2,19 +2,18 @@ #include "Emulator/Misc/bit_cast.hpp" - void HyperCPU::CPU::ExecCALL(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_op_types) { // Placeholders - case OperandTypes::R: - StackPush64(*xip); - *xip = op1.deref(); - break; - case OperandTypes::IMM: - StackPush64(*xip); - *xip = HyperCPU::bit_cast(op1); - break; - default: - std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; - exit(1); + case OperandTypes::R: + StackPush64(*xip); + *xip = op1.deref(); + break; + case OperandTypes::IMM: + StackPush64(*xip); + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp index ff94c2d9..3fc88c96 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp @@ -1,23 +1,22 @@ #include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Misc/bit_cast.hpp" - void HyperCPU::CPU::ExecCALLE(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(zrf && !crf)) { return; } switch (instr.m_op_types) { // Placeholders - case OperandTypes::R: - StackPush64(*xip); - *xip = op1.deref(); - break; - case OperandTypes::IMM: - StackPush64(*xip); - *xip = HyperCPU::bit_cast(op1); - break; - default: - std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; - exit(1); + case OperandTypes::R: + StackPush64(*xip); + *xip = op1.deref(); + break; + case OperandTypes::IMM: + StackPush64(*xip); + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp index 6d22d67b..a021052c 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp @@ -2,23 +2,22 @@ #include "Emulator/Misc/bit_cast.hpp" - void HyperCPU::CPU::ExecCALLGR(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(!zrf && !crf)) { return; } switch (instr.m_op_types) { // Placeholders - case OperandTypes::R: - StackPush64(*xip); - *xip = op1.deref(); - break; - case OperandTypes::IMM: - StackPush64(*xip); - *xip = HyperCPU::bit_cast(op1); - break; - default: - std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; - exit(1); + case OperandTypes::R: + StackPush64(*xip); + *xip = op1.deref(); + break; + case OperandTypes::IMM: + StackPush64(*xip); + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp index 40832135..8f7db594 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp @@ -2,23 +2,22 @@ #include "Emulator/Misc/bit_cast.hpp" - void HyperCPU::CPU::ExecCALLL(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(!zrf && crf)) { return; } switch (instr.m_op_types) { // Placeholders - case OperandTypes::R: - StackPush64(*xip); - *xip = op1.deref(); - break; - case OperandTypes::IMM: - StackPush64(*xip); - *xip = HyperCPU::bit_cast(op1); - break; - default: - std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; - exit(1); + case OperandTypes::R: + StackPush64(*xip); + *xip = op1.deref(); + break; + case OperandTypes::IMM: + StackPush64(*xip); + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp index 910f2b77..957ab3fb 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp @@ -1,211 +1,210 @@ -#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/ALU.hpp" +#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Misc/bit_cast.hpp" - void HyperCPU::CPU::ExecCMP(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { std::int8_t res = 0; switch (instr.m_op_types) { - case OperandTypes::R_R: { - switch (instr.m_opcode_mode) { - case Mode::b8: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); - break; + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); + break; - case Mode::b16: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); + break; - case Mode::b32: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); + break; - case Mode::b64: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); - break; - } + case Mode::b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast_from(op2.ptr())); break; } + break; + } - case OperandTypes::R_RM: { - std::uint64_t ptr; - std::memcpy(&ptr, op2.ptr(), 8); + case OperandTypes::R_RM: { + std::uint64_t ptr; + std::memcpy(&ptr, op2.ptr(), 8); - switch (instr.m_opcode_mode) { - case Mode::b8: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read8(ptr)); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read8(ptr)); + break; - case Mode::b16: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); + break; - case Mode::b32: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); + break; - case Mode::b64: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); - break; - } + case Mode::b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); break; } + break; + } - case OperandTypes::R_M: { - std::uint64_t ptr = op2; + case OperandTypes::R_M: { + std::uint64_t ptr = op2; - switch (instr.m_opcode_mode) { - case Mode::b8: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read8(ptr)); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read8(ptr)); + break; - case Mode::b16: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read16(ptr)); + break; - case Mode::b32: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read32(ptr)); + break; - case Mode::b64: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); - break; - } + case Mode::b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); break; } + break; + } - case OperandTypes::R_IMM: { - switch (instr.m_opcode_mode) { - case Mode::b8: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); - break; + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); + break; - case Mode::b16: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); + break; - case Mode::b32: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); + break; - case Mode::b64: - res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); - break; - } + case Mode::b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), HyperCPU::bit_cast(op2)); break; } + break; + } - case OperandTypes::RM_M: { - std::uint64_t ptr1, ptr2 = 0; - std::memcpy(&ptr1, op1.ptr(), 8); - ptr2 = HyperCPU::bit_cast(op2); + case OperandTypes::RM_M: { + std::uint64_t ptr1, ptr2 = 0; + std::memcpy(&ptr1, op1.ptr(), 8); + ptr2 = HyperCPU::bit_cast(op2); - switch (instr.m_opcode_mode) { - case Mode::b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr1), mem_controller->Read8(ptr2)); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr1), mem_controller->Read8(ptr2)); + break; - case Mode::b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr1), mem_controller->Read16(ptr2)); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr1), mem_controller->Read16(ptr2)); + break; - case Mode::b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr1), mem_controller->Read32(ptr2)); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr1), mem_controller->Read32(ptr2)); + break; - case Mode::b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr1), mem_controller->Read64(ptr2)); - break; - } + case Mode::b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr1), mem_controller->Read64(ptr2)); break; } + break; + } - case OperandTypes::RM_R: { - std::uint64_t ptr = op1.deref(); + case OperandTypes::RM_R: { + std::uint64_t ptr = op1.deref(); - switch (instr.m_opcode_mode) { - case Mode::b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case Mode::b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case Mode::b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case Mode::b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; - } + case Mode::b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; } + break; + } - case OperandTypes::RM_IMM: { - std::uint64_t ptr = op1.deref(); + case OperandTypes::RM_IMM: { + std::uint64_t ptr = op1.deref(); - switch (instr.m_opcode_mode) { - case Mode::b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast(op2)); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast(op2)); + break; - case Mode::b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast(op2)); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast(op2)); + break; - case Mode::b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast(op2)); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast(op2)); + break; - case Mode::b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast(op2)); - break; - } + case Mode::b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast(op2)); break; } + break; + } - case OperandTypes::M_R: { - std::size_t ptr = HyperCPU::bit_cast(op1); + case OperandTypes::M_R: { + std::size_t ptr = HyperCPU::bit_cast(op1); - switch (instr.m_opcode_mode) { - case Mode::b8: - res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case Mode::b16: - res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + case Mode::b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case Mode::b32: - res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; + case Mode::b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); + break; - case Mode::b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); - break; - } + case Mode::b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; } + break; + } - default: - break; + default: + break; } switch (res) { - case -1: - zrf = 0; - crf = 1; - break; - case 0: - zrf = 1; - crf = 0; - break; - case 1: - zrf = 0; - crf = 0; - break; + case -1: + zrf = 0; + crf = 1; + break; + case 0: + zrf = 1; + crf = 0; + break; + case 1: + zrf = 0; + crf = 0; + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp b/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp index 37823004..462771ab 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp @@ -1,6 +1,5 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecCOVF(const IInstruction& /* instr */, OperandContainer /* op1 */, OperandContainer /* op2 */) { ovf = false; } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp b/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp index 6e5fb458..6a22d7db 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp @@ -1,6 +1,5 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecCUDF(const IInstruction& /* instr */, OperandContainer /* op1 */, OperandContainer /* op2 */) { udf = false; } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp b/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp index a2073511..7c58789a 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp @@ -1,34 +1,33 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecDEC(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_opcode_mode) { - case Mode::b8: { - auto& dst = op1.deref(); - udf = (dst == 0); - --dst; - break; - } + case Mode::b8: { + auto& dst = op1.deref(); + udf = (dst == 0); + --dst; + break; + } - case Mode::b16: { - auto& dst = op1.deref(); - udf = (dst == 0); - --dst; - break; - } + case Mode::b16: { + auto& dst = op1.deref(); + udf = (dst == 0); + --dst; + break; + } - case Mode::b32: { - auto& dst = op1.deref(); - udf = (dst == 0); - --dst; - break; - } + case Mode::b32: { + auto& dst = op1.deref(); + udf = (dst == 0); + --dst; + break; + } - case Mode::b64: { - auto& dst = op1.deref(); - udf = (dst == 0); - --dst; - break; - } + case Mode::b64: { + auto& dst = op1.deref(); + udf = (dst == 0); + --dst; + break; + } } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp b/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp index d3be8225..8cdb1540 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp @@ -1,8 +1,7 @@ -#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/ALU.hpp" +#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp" - using namespace HyperALU; void HyperCPU::CPU::ExecDIV(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { @@ -12,32 +11,32 @@ void HyperCPU::CPU::ExecDIV(const IInstruction& instr, OperandContainer op1, Ope } switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t& dst = op1.deref(); - *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); - dst = __hcpu_div(dst, static_cast(*x2)); - break; - } + case Mode::b8: { + std::uint8_t& dst = op1.deref(); + *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); + dst = __hcpu_div(dst, static_cast(*x2)); + break; + } - case Mode::b16: { - auto& dst = op1.deref(); - *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); - dst = __hcpu_div(dst, static_cast(*x2)); - break; - } + case Mode::b16: { + auto& dst = op1.deref(); + *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); + dst = __hcpu_div(dst, static_cast(*x2)); + break; + } - case Mode::b32: { - auto& dst = op1.deref(); - *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); - dst = __hcpu_div(dst, static_cast(*x2)); - break; - } + case Mode::b32: { + auto& dst = op1.deref(); + *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); + dst = __hcpu_div(dst, static_cast(*x2)); + break; + } - case Mode::b64: { - auto& dst = op1.deref(); - *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); - dst = __hcpu_div(dst, static_cast(*x2)); - break; - } + case Mode::b64: { + auto& dst = op1.deref(); + *x1 = __hcpu_div_remainder(dst, static_cast(*x2)); + dst = __hcpu_div(dst, static_cast(*x2)); + break; + } } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp b/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp index df8469d9..ec310cfb 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp @@ -1,6 +1,5 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecHALT(const IInstruction& /* instr */, OperandContainer /* op1 */, OperandContainer /* op2 */) { halted = true; } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp b/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp index f5a01e88..5d6ace53 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp @@ -1,19 +1,18 @@ #include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/Version.hpp" - void HyperCPU::CPU::ExecHID(const IInstruction& /* instr */, OperandContainer /* op1 */, OperandContainer /* op2 */) { switch (*x0) { - case 0: - *x0 = 2; - break; - case 1: - std::strcpy(std::bit_cast(&data), HID_CPU_NAME); - break; - case 2: - *x0 = 0; - break; - default: - break; + case 0: + *x0 = 2; + break; + case 1: + std::strcpy(std::bit_cast(&data), HID_CPU_NAME); + break; + case 2: + *x0 = 0; + break; + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp b/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp index 387c8995..0007a67b 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp @@ -1,34 +1,33 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecINC(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_opcode_mode) { - case Mode::b8: { - auto& dst = op1.deref(); - ++dst; - ovf = (dst == 0); - break; - } + case Mode::b8: { + auto& dst = op1.deref(); + ++dst; + ovf = (dst == 0); + break; + } - case Mode::b16: { - auto& dst = op1.deref(); - ++dst; - ovf = (dst == 0); - break; - } + case Mode::b16: { + auto& dst = op1.deref(); + ++dst; + ovf = (dst == 0); + break; + } - case Mode::b32: { - auto& dst = op1.deref(); - ++dst; - ovf = (dst == 0); - break; - } + case Mode::b32: { + auto& dst = op1.deref(); + ++dst; + ovf = (dst == 0); + break; + } - case Mode::b64: { - auto& dst = op1.deref(); - ++dst; - ovf = (dst == 0); - break; - } + case Mode::b64: { + auto& dst = op1.deref(); + ++dst; + ovf = (dst == 0); + break; + } } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp index c56c12c7..3a9f5d93 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp @@ -1,7 +1,6 @@ #include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp" - #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wunused-parameter" @@ -9,10 +8,18 @@ void HyperCPU::CPU::ExecINTR(const IInstruction& instr, OperandContainer op1, Op std::uint64_t num = 0; switch (instr.m_opcode_mode) { - case Mode::b8: num = HyperCPU::bit_cast_from(op1.ptr()); break; - case Mode::b16: num = HyperCPU::bit_cast_from(op1.ptr()); break; - case Mode::b32: num = HyperCPU::bit_cast_from(op1.ptr()); break; - case Mode::b64: num = HyperCPU::bit_cast_from(op1.ptr()); break; + case Mode::b8: + num = HyperCPU::bit_cast_from(op1.ptr()); + break; + case Mode::b16: + num = HyperCPU::bit_cast_from(op1.ptr()); + break; + case Mode::b32: + num = HyperCPU::bit_cast_from(op1.ptr()); + break; + case Mode::b64: + num = HyperCPU::bit_cast_from(op1.ptr()); + break; } if (num > 255) { diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp index 2c0ecdc2..c1bf4b95 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp @@ -1,20 +1,19 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecJME(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(zrf && !crf)) { return; } switch (instr.m_op_types) { // Placeholders - case OperandTypes::R: - *xip = op1.deref(); - break; - case OperandTypes::IMM: - *xip = HyperCPU::bit_cast(op1); - break; - default: - std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; - exit(1); + case OperandTypes::R: + *xip = op1.deref(); + break; + case OperandTypes::IMM: + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp index 827a5d50..b47271db 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp @@ -1,20 +1,19 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecJMGR(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(!zrf && !crf)) { return; } switch (instr.m_op_types) { // Placeholders - case OperandTypes::R: - *xip = op1.deref(); - break; - case OperandTypes::IMM: - *xip = HyperCPU::bit_cast(op1); - break; - default: - std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; - exit(1); + case OperandTypes::R: + *xip = op1.deref(); + break; + case OperandTypes::IMM: + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp index 1ba36db9..a935db40 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp @@ -1,20 +1,19 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecJML(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(!zrf && crf)) { return; } switch (instr.m_op_types) { // Placeholders - case OperandTypes::R: - *xip = op1.deref(); - break; - case OperandTypes::IMM: - *xip = HyperCPU::bit_cast(op1); - break; - default: - std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; - exit(1); + case OperandTypes::R: + *xip = op1.deref(); + break; + case OperandTypes::IMM: + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp index 36f87bd5..022088d6 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp @@ -1,16 +1,15 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecJMP(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_op_types) { // Placeholders - case OperandTypes::R: - *xip = op1.deref(); - break; - case OperandTypes::IMM: - *xip = HyperCPU::bit_cast(op1); - break; - default: - std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; - exit(1); + case OperandTypes::R: + *xip = op1.deref(); + break; + case OperandTypes::IMM: + *xip = HyperCPU::bit_cast(op1); + break; + default: + std::cerr << "HyperCPU::CPU::ExecCALLE placeholder reached: please report bug\n"; + exit(1); } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp b/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp index e4083ac6..ef898fa5 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp @@ -1,15 +1,15 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecLOIVT(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_op_types) { - case OperandTypes::IMM: - *xivt = HyperCPU::bit_cast(op1); - break; - case OperandTypes::R: - *xivt = HyperCPU::bit_cast_from(op1.ptr()); - break; - default: std::abort(); + case OperandTypes::IMM: + *xivt = HyperCPU::bit_cast(op1); + break; + case OperandTypes::R: + *xivt = HyperCPU::bit_cast_from(op1.ptr()); + break; + default: + std::abort(); } ivt_initialized = true; } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp b/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp index bdaeb82c..d873c6c5 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp @@ -1,200 +1,199 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecMOV(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case OperandTypes::R_R: { - switch (instr.m_opcode_mode) { - case Mode::b8: - std::memcpy(op1, op2.ptr(), 1); - break; + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + std::memcpy(op1, op2.ptr(), 1); + break; - case Mode::b16: - std::memcpy(op1, op2.ptr(), 2); - break; + case Mode::b16: + std::memcpy(op1, op2.ptr(), 2); + break; - case Mode::b32: - std::memcpy(op1, op2.ptr(), 4); - break; + case Mode::b32: + std::memcpy(op1, op2.ptr(), 4); + break; - case Mode::b64: - std::memcpy(op1, op2.ptr(), 8); - break; - } + case Mode::b64: + std::memcpy(op1, op2.ptr(), 8); break; } + break; + } - case OperandTypes::R_RM: { - std::uint64_t ptr; - std::memcpy(&ptr, op2.ptr(), 8); + case OperandTypes::R_RM: { + std::uint64_t ptr; + std::memcpy(&ptr, op2.ptr(), 8); - switch (instr.m_opcode_mode) { - case Mode::b8: - *static_cast(op1) = mem_controller->Read8(ptr); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + *static_cast(op1) = mem_controller->Read8(ptr); + break; - case Mode::b16: - *static_cast(op1) = mem_controller->Read16(ptr); - break; + case Mode::b16: + *static_cast(op1) = mem_controller->Read16(ptr); + break; - case Mode::b32: - *static_cast(op1) = mem_controller->Read32(ptr); - break; + case Mode::b32: + *static_cast(op1) = mem_controller->Read32(ptr); + break; - case Mode::b64: - *static_cast(op1) = mem_controller->Read64(ptr); - break; - } + case Mode::b64: + *static_cast(op1) = mem_controller->Read64(ptr); break; } + break; + } - case OperandTypes::R_M: { - std::uint64_t ptr = op2; + case OperandTypes::R_M: { + std::uint64_t ptr = op2; - switch (instr.m_opcode_mode) { - case Mode::b8: - *static_cast(op1) = mem_controller->Read8(ptr); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + *static_cast(op1) = mem_controller->Read8(ptr); + break; - case Mode::b16: - *static_cast(op1) = mem_controller->Read16(ptr); - break; + case Mode::b16: + *static_cast(op1) = mem_controller->Read16(ptr); + break; - case Mode::b32: - *static_cast(op1) = mem_controller->Read32(ptr); - break; + case Mode::b32: + *static_cast(op1) = mem_controller->Read32(ptr); + break; - case Mode::b64: - *static_cast(op1) = mem_controller->Read64(ptr); - break; - } + case Mode::b64: + *static_cast(op1) = mem_controller->Read64(ptr); break; } + break; + } - case OperandTypes::R_IMM: { - switch (instr.m_opcode_mode) { - case Mode::b8: - std::memcpy(op1, &op2.ref(), 1); - break; + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: + std::memcpy(op1, &op2.ref(), 1); + break; - case Mode::b16: - std::memcpy(op1, &op2.ref(), 2); - break; + case Mode::b16: + std::memcpy(op1, &op2.ref(), 2); + break; - case Mode::b32: - std::memcpy(op1, &op2.ref(), 4); - break; + case Mode::b32: + std::memcpy(op1, &op2.ref(), 4); + break; - case Mode::b64: - std::memcpy(op1, &op2.ref(), 8); - break; - } + case Mode::b64: + std::memcpy(op1, &op2.ref(), 8); break; } + break; + } - case OperandTypes::RM_M: { - std::uint64_t ptr1, ptr2 = 0; - std::memcpy(&ptr1, op1.ptr(), 8); - ptr2 = op2; + case OperandTypes::RM_M: { + std::uint64_t ptr1, ptr2 = 0; + std::memcpy(&ptr1, op1.ptr(), 8); + ptr2 = op2; - switch (instr.m_opcode_mode) { - case Mode::b8: - mem_controller->Load8(ptr1, mem_controller->Read8(ptr2)); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + mem_controller->Load8(ptr1, mem_controller->Read8(ptr2)); + break; - case Mode::b16: - mem_controller->Load16(ptr1, mem_controller->Read16(ptr2)); - break; + case Mode::b16: + mem_controller->Load16(ptr1, mem_controller->Read16(ptr2)); + break; - case Mode::b32: - mem_controller->Load32(ptr1, mem_controller->Read32(ptr2)); - break; + case Mode::b32: + mem_controller->Load32(ptr1, mem_controller->Read32(ptr2)); + break; - case Mode::b64: - mem_controller->Load64(ptr1, mem_controller->Read64(ptr2)); - break; - } + case Mode::b64: + mem_controller->Load64(ptr1, mem_controller->Read64(ptr2)); break; } + break; + } - case OperandTypes::RM_R: { - std::uint64_t ptr = op1.deref(); + case OperandTypes::RM_R: { + std::uint64_t ptr = op1.deref(); - switch (instr.m_opcode_mode) { - case Mode::b8: { - mem_controller->Load8(ptr, *static_cast(op2)); - break; - } + switch (instr.m_opcode_mode) { + case Mode::b8: { + mem_controller->Load8(ptr, *static_cast(op2)); + break; + } - case Mode::b16: { - mem_controller->Load16(ptr, *static_cast(op2)); - break; - } + case Mode::b16: { + mem_controller->Load16(ptr, *static_cast(op2)); + break; + } - case Mode::b32: { - mem_controller->Load32(ptr, *static_cast(op2)); - break; - } + case Mode::b32: { + mem_controller->Load32(ptr, *static_cast(op2)); + break; + } - case Mode::b64: { - mem_controller->Load64(ptr, *static_cast(op2)); - break; - } - } + case Mode::b64: { + mem_controller->Load64(ptr, *static_cast(op2)); break; } + } + break; + } - case OperandTypes::RM_IMM: { - std::uint64_t ptr1 = op1.deref(); + case OperandTypes::RM_IMM: { + std::uint64_t ptr1 = op1.deref(); - switch (instr.m_opcode_mode) { - case Mode::b8: - mem_controller->Load8(ptr1, HyperCPU::bit_cast(op2)); - break; + switch (instr.m_opcode_mode) { + case Mode::b8: + mem_controller->Load8(ptr1, HyperCPU::bit_cast(op2)); + break; - case Mode::b16: - mem_controller->Load16(ptr1, HyperCPU::bit_cast(op2)); - break; + case Mode::b16: + mem_controller->Load16(ptr1, HyperCPU::bit_cast(op2)); + break; - case Mode::b32: - mem_controller->Load32(ptr1, HyperCPU::bit_cast(op2)); - break; + case Mode::b32: + mem_controller->Load32(ptr1, HyperCPU::bit_cast(op2)); + break; - case Mode::b64: - mem_controller->Load64(ptr1, HyperCPU::bit_cast(op2)); - break; - } + case Mode::b64: + mem_controller->Load64(ptr1, HyperCPU::bit_cast(op2)); break; } + break; + } - case OperandTypes::M_R: { - std::size_t ptr1 = HyperCPU::bit_cast(op1); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - mem_controller->Load8(ptr1, HyperCPU::bit_cast_from(op2.ptr())); - break; - } + case OperandTypes::M_R: { + std::size_t ptr1 = HyperCPU::bit_cast(op1); - case Mode::b16: { - mem_controller->Load16(ptr1, HyperCPU::bit_cast_from(op2.ptr())); - break; - } + switch (instr.m_opcode_mode) { + case Mode::b8: { + mem_controller->Load8(ptr1, HyperCPU::bit_cast_from(op2.ptr())); + break; + } - case Mode::b32: { - mem_controller->Load32(ptr1, HyperCPU::bit_cast_from(op2.ptr())); - break; - } + case Mode::b16: { + mem_controller->Load16(ptr1, HyperCPU::bit_cast_from(op2.ptr())); + break; + } - case Mode::b64: { - mem_controller->Load64(ptr1, HyperCPU::bit_cast_from(op2.ptr())); - break; - } - } + case Mode::b32: { + mem_controller->Load32(ptr1, HyperCPU::bit_cast_from(op2.ptr())); break; } - default: + case Mode::b64: { + mem_controller->Load64(ptr1, HyperCPU::bit_cast_from(op2.ptr())); break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp index df8997d7..177be42f 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp @@ -1,142 +1,141 @@ -#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/ALU.hpp" +#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Misc/overflow.hpp" - using namespace HyperALU; void HyperCPU::CPU::ExecMUL(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case OperandTypes::R_R: { - switch (instr.m_opcode_mode) { - case Mode::b8: - ovf = multiplication_will_overflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b16: - ovf = multiplication_will_overflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b32: - ovf = multiplication_will_overflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b64: - ovf = multiplication_will_overflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - break; - } - - case OperandTypes::R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - } - break; - } - - case OperandTypes::R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - } - break; - } - - case OperandTypes::R_IMM: { - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - ovf = multiplication_will_overflow(op1.deref(), val); - op1.deref() = __hcpu_mul(op1.deref(), val); - break; - } - } - break; - } - - default: + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + ovf = multiplication_will_overflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b16: + ovf = multiplication_will_overflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b32: + ovf = multiplication_will_overflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b64: + ovf = multiplication_will_overflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_mul(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + ovf = multiplication_will_overflow(op1.deref(), val); + op1.deref() = __hcpu_mul(op1.deref(), val); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp index 1cdc21bd..b8265ef9 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp @@ -1,124 +1,123 @@ -#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/ALU.hpp" - +#include "Emulator/Core/CPU/CPU.hpp" using namespace HyperALU; void HyperCPU::CPU::ExecOR(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case OperandTypes::R_R: { - switch (instr.m_opcode_mode) { - case Mode::b8: - op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b16: - op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b32: - op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b64: - op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } - break; - } - - case OperandTypes::R_RM: { - std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - } - break; - } - - case OperandTypes::R_M: { - std::uint64_t ptr = HyperCPU::bit_cast(op2); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - } - break; - } - - case OperandTypes::R_IMM: { - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - op1.deref() = __hcpu_or(op1.deref(), val); - break; - } - } + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b16: + op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b32: + op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b64: + op1.deref() = __hcpu_or(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = HyperCPU::bit_cast_from(op2.ptr()); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = HyperCPU::bit_cast(op2); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + op1.deref() = __hcpu_or(op1.deref(), val); break; - } + } + } + break; + } - default: + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_or(op1.deref(), val); break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + op1.deref() = __hcpu_or(op1.deref(), val); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp index 6bab6b40..7d56215a 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp @@ -1,18 +1,26 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecPOP(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_op_types) { - case OperandTypes::R: - switch (instr.m_opcode_mode) { - case Mode::b8: op1.deref() = StackPop8(); break; - case Mode::b16: op1.deref() = StackPop16(); break; - case Mode::b32: op1.deref() = StackPop32(); break; - case Mode::b64: op1.deref() = StackPop64(); break; - default: std::abort(); - } + case OperandTypes::R: + switch (instr.m_opcode_mode) { + case Mode::b8: + op1.deref() = StackPop8(); + break; + case Mode::b16: + op1.deref() = StackPop16(); + break; + case Mode::b32: + op1.deref() = StackPop32(); + break; + case Mode::b64: + op1.deref() = StackPop64(); break; default: - std::abort(); + std::abort(); + } + break; + default: + std::abort(); } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp b/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp index b07eb704..822614da 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp @@ -1,27 +1,44 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecPUSH(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { switch (instr.m_op_types) { - case OperandTypes::R: - switch (instr.m_opcode_mode) { - case HyperCPU::Mode::b8: StackPush8(HyperCPU::bit_cast_from(op1.ptr())); break; - case HyperCPU::Mode::b16: StackPush16(HyperCPU::bit_cast_from(op1.ptr())); break; - case HyperCPU::Mode::b32: StackPush32(HyperCPU::bit_cast_from(op1.ptr())); break; - case HyperCPU::Mode::b64: StackPush64(HyperCPU::bit_cast_from(op1.ptr())); break; - default: std::abort(); - } - break; - case OperandTypes::IMM: - switch (instr.m_opcode_mode) { - case HyperCPU::Mode::b8: StackPush8(HyperCPU::bit_cast(op1)); break; - case HyperCPU::Mode::b16: StackPush16(HyperCPU::bit_cast(op1)); break; - case HyperCPU::Mode::b32: StackPush32(HyperCPU::bit_cast(op1)); break; - case HyperCPU::Mode::b64: StackPush64(HyperCPU::bit_cast(op1)); break; - default: std::abort(); - } + case OperandTypes::R: + switch (instr.m_opcode_mode) { + case HyperCPU::Mode::b8: + StackPush8(HyperCPU::bit_cast_from(op1.ptr())); + break; + case HyperCPU::Mode::b16: + StackPush16(HyperCPU::bit_cast_from(op1.ptr())); + break; + case HyperCPU::Mode::b32: + StackPush32(HyperCPU::bit_cast_from(op1.ptr())); + break; + case HyperCPU::Mode::b64: + StackPush64(HyperCPU::bit_cast_from(op1.ptr())); + break; + default: + std::abort(); + } + break; + case OperandTypes::IMM: + switch (instr.m_opcode_mode) { + case HyperCPU::Mode::b8: + StackPush8(HyperCPU::bit_cast(op1)); + break; + case HyperCPU::Mode::b16: + StackPush16(HyperCPU::bit_cast(op1)); + break; + case HyperCPU::Mode::b32: + StackPush32(HyperCPU::bit_cast(op1)); + break; + case HyperCPU::Mode::b64: + StackPush64(HyperCPU::bit_cast(op1)); break; default: std::abort(); + } + break; + default: + std::abort(); } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp b/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp index e530ebfa..32acb6d0 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp @@ -1,17 +1,16 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecREAD(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { read_operation_handler* handler = nullptr; switch (instr.m_op_types) { - case OperandTypes::IMM: - handler = &read_io_handlers[HyperCPU::bit_cast(op1)]; - break; - case OperandTypes::R: - handler = &read_io_handlers[HyperCPU::bit_cast_from(op1.ptr())]; - break; - default: - std::abort(); + case OperandTypes::IMM: + handler = &read_io_handlers[HyperCPU::bit_cast(op1)]; + break; + case OperandTypes::R: + handler = &read_io_handlers[HyperCPU::bit_cast_from(op1.ptr())]; + break; + default: + std::abort(); } if (handler) { diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp index 92783668..73771961 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp @@ -1,59 +1,58 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecSHFL(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case OperandTypes::R_R: { - switch (instr.m_opcode_mode) { - case Mode::b8: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; + + case Mode::b16: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; - case Mode::b16: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; + case Mode::b32: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; - case Mode::b32: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; + case Mode::b64: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; + } + break; + } - case Mode::b64: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; - } + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; break; } - case OperandTypes::R_IMM: { - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - op1.deref() <<= val; - break; - } - - case Mode::b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - op1.deref() <<= val; - break; - } - - case Mode::b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - op1.deref() <<= val; - break; - } - - case Mode::b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - op1.deref() <<= val; - break; - } - } + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; break; } - default: + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp index 800ac2bc..27ffbb7a 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp @@ -1,59 +1,58 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecSHFR(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case OperandTypes::R_R: { - switch (instr.m_opcode_mode) { - case Mode::b8: - op1.deref() >>= op2.deref(); - break; + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + op1.deref() >>= op2.deref(); + break; + + case Mode::b16: + op1.deref() >>= op2.deref(); + break; - case Mode::b16: - op1.deref() >>= op2.deref(); - break; + case Mode::b32: + op1.deref() >>= op2.deref(); + break; - case Mode::b32: - op1.deref() >>= op2.deref(); - break; + case Mode::b64: + op1.deref() >>= op2.deref(); + break; + } + break; + } - case Mode::b64: - op1.deref() >>= op2.deref(); - break; - } + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; break; } - case OperandTypes::R_IMM: { - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - op1.deref() >>= val; - break; - } - - case Mode::b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - op1.deref() >>= val; - break; - } - - case Mode::b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - op1.deref() >>= val; - break; - } - - case Mode::b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - op1.deref() >>= val; - break; - } - } + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; break; } - default: + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp index d92c885c..18eaae71 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp @@ -1,142 +1,141 @@ -#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/ALU.hpp" +#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Misc/underflow.hpp" - using namespace HyperALU; void HyperCPU::CPU::ExecSUB(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { switch (instr.m_op_types) { - case OperandTypes::R_R: { - switch (instr.m_opcode_mode) { - case Mode::b8: - udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b16: - udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b32: - udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - - case Mode::b64: - udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); - op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); - break; - } // TODO: mark defaults as std::unreachable() + case OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b16: + udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b32: + udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + + case Mode::b64: + udf = SubtractionWillUnderflow(op1.deref(), op2.deref()); + op1.deref() = __hcpu_sub(op1.deref(), HyperCPU::bit_cast_from(op2.ptr())); + break; + } // TODO: mark defaults as std::unreachable() + break; + } + + case OperandTypes::R_RM: { + std::uint64_t ptr = op2.deref(); + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); break; } - case OperandTypes::R_RM: { - std::uint64_t ptr = op2.deref(); - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - } + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); break; } - case OperandTypes::R_M: { - std::uint64_t ptr = op2; - - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = mem_controller->Read8(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = mem_controller->Read16(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = mem_controller->Read32(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = mem_controller->Read64(ptr); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - } + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_M: { + std::uint64_t ptr = op2; + + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = mem_controller->Read8(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); break; } - case OperandTypes::R_IMM: { - switch (instr.m_opcode_mode) { - case Mode::b8: { - std::uint8_t val = HyperCPU::bit_cast(op2); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case Mode::b16: { - std::uint16_t val = HyperCPU::bit_cast(op2); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case Mode::b32: { - std::uint32_t val = HyperCPU::bit_cast(op2); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - - case Mode::b64: { - std::uint64_t val = HyperCPU::bit_cast(op2); - udf = SubtractionWillUnderflow(op1.deref(), val); - op1.deref() = __hcpu_sub(op1.deref(), val); - break; - } - } + case Mode::b16: { + std::uint16_t val = mem_controller->Read16(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); break; } - default: + case Mode::b32: { + std::uint32_t val = mem_controller->Read32(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); break; + } + + case Mode::b64: { + std::uint64_t val = mem_controller->Read64(ptr); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + } + break; + } + + case OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b16: { + std::uint16_t val = HyperCPU::bit_cast(op2); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b32: { + std::uint32_t val = HyperCPU::bit_cast(op2); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + + case Mode::b64: { + std::uint64_t val = HyperCPU::bit_cast(op2); + udf = SubtractionWillUnderflow(op1.deref(), val); + op1.deref() = __hcpu_sub(op1.deref(), val); + break; + } + } + break; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp b/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp index 67f418fd..26356d45 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp @@ -1,18 +1,17 @@ #include "Emulator/Core/CPU/CPU.hpp" - void HyperCPU::CPU::ExecWRITE(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { write_operation_handler& handler = write_io_handlers[*static_cast(op1)]; if (handler) { switch (instr.m_op_types) { - case OperandTypes::R_R: - handler(*static_cast(op2)); - break; - case OperandTypes::R_IMM: - handler(HyperCPU::bit_cast(op2)); - break; - default: + case OperandTypes::R_R: + handler(*static_cast(op2)); + break; + case OperandTypes::R_IMM: + handler(HyperCPU::bit_cast(op2)); + break; + default: std::abort(); } } diff --git a/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp b/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp index 4bc5e05a..3c3ed6f5 100644 --- a/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp +++ b/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp @@ -1,9 +1,9 @@ #include -#include "PCH/CStd.hpp" -#include "Emulator/Core/CPU/CPU.hpp" #include "Common/LanguageSpec/Opcodes.hpp" +#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp" +#include "PCH/CStd.hpp" void HyperCPU::CPU::TriggerInterrupt(HyperCPU::cpu_exceptions exception) { if (!ivt_initialized || pending_interrupt.has_value()) { diff --git a/src/Emulator/Core/CPU/OperandsEvaluation.cpp b/src/Emulator/Core/CPU/OperandsEvaluation.cpp index 2da7c9cd..efbba705 100644 --- a/src/Emulator/Core/CPU/OperandsEvaluation.cpp +++ b/src/Emulator/Core/CPU/OperandsEvaluation.cpp @@ -1,7 +1,7 @@ #include "PCH/CStd.hpp" -#include "Emulator/Core/CPU/CPU.hpp" #include "Common/LanguageSpec/Registers.hpp" +#include "Emulator/Core/CPU/CPU.hpp" #include "Emulator/Misc/bit_cast.hpp" HyperCPU::OperandContainer HyperCPU::CPU::GetRegister(OperandContainer& op1) { diff --git a/src/Emulator/Core/MemoryController/IMemoryController.hpp b/src/Emulator/Core/MemoryController/IMemoryController.hpp index 1638ff91..99a559fd 100644 --- a/src/Emulator/Core/MemoryController/IMemoryController.hpp +++ b/src/Emulator/Core/MemoryController/IMemoryController.hpp @@ -34,21 +34,21 @@ namespace HyperCPU { template struct loadTypeChooser { - using type = T; + using type = T; }; template struct loadTypeChooser { - using type = std::underlying_type_t; + using type = std::underlying_type_t; }; - template + template void Load8(std::uint64_t, T); - template + template void Load16(std::uint64_t, T); - template + template void Load32(std::uint64_t, T); - template + template void Load64(std::uint64_t, T); virtual std::uint8_t* get_ptr() const noexcept = 0; @@ -63,34 +63,34 @@ namespace HyperCPU { } // namespace HyperCPU -template +template void HyperCPU::IMemoryController::Load8(std::uint64_t address, T value) { - using ActualFrom = typename loadTypeChooser, T>::type; - static_assert(std::is_convertible_v, "Value must be convertable to integer type"); + using ActualFrom = typename loadTypeChooser, T>::type; + static_assert(std::is_convertible_v, "Value must be convertable to integer type"); - load8(address, static_cast(value)); + load8(address, static_cast(value)); } -template +template void HyperCPU::IMemoryController::Load16(std::uint64_t address, T value) { - using ActualFrom = typename loadTypeChooser, T>::type; - static_assert(std::is_convertible_v, "Value must be convertable to integer type"); + using ActualFrom = typename loadTypeChooser, T>::type; + static_assert(std::is_convertible_v, "Value must be convertable to integer type"); - load16(address, static_cast(value)); + load16(address, static_cast(value)); } -template +template void HyperCPU::IMemoryController::Load32(std::uint64_t address, T value) { - using ActualFrom = typename loadTypeChooser, T>::type; - static_assert(std::is_convertible_v, "Value must be convertable to integer type"); + using ActualFrom = typename loadTypeChooser, T>::type; + static_assert(std::is_convertible_v, "Value must be convertable to integer type"); - load32(address, static_cast(value)); + load32(address, static_cast(value)); } -template +template void HyperCPU::IMemoryController::Load64(std::uint64_t address, T value) { - using ActualFrom = typename loadTypeChooser, T>::type; - static_assert(std::is_convertible_v, "Value must be convertable to integer type"); + using ActualFrom = typename loadTypeChooser, T>::type; + static_assert(std::is_convertible_v, "Value must be convertable to integer type"); - load64(address, static_cast(value)); + load64(address, static_cast(value)); } diff --git a/src/Emulator/Main.cpp b/src/Emulator/Main.cpp index 4e9b7c5e..a70fc7ac 100644 --- a/src/Emulator/Main.cpp +++ b/src/Emulator/Main.cpp @@ -1,8 +1,8 @@ #include -#include "PCH/CStd.hpp" #include "Assembler/Core/Compiler.hpp" #include "Emulator/Core/CPU/CPU.hpp" +#include "PCH/CStd.hpp" // TODO: move this header (it needs some prefix, otherwise quotes look in this dir) #include "Common/Version.hpp" diff --git a/src/Emulator/Misc/byteswap.hpp b/src/Emulator/Misc/byteswap.hpp index 3b787e52..2667bc05 100644 --- a/src/Emulator/Misc/byteswap.hpp +++ b/src/Emulator/Misc/byteswap.hpp @@ -1,7 +1,7 @@ #pragma once -#include "PCH/CStd.hpp" #include "Emulator/Misc/bit_cast.hpp" +#include "PCH/CStd.hpp" namespace HyperCPU { template diff --git a/src/PCH/BUILD.bazel b/src/PCH/BUILD.bazel index e5dd8076..123b0274 100644 --- a/src/PCH/BUILD.bazel +++ b/src/PCH/BUILD.bazel @@ -1,7 +1,7 @@ -load('//tools/bazel:pch.bzl', 'precompiled_headers') +load("//tools/bazel:pch.bzl", "precompiled_headers") precompiled_headers( - name = 'pch_cstd', - main = 'CStd.hpp', - visibility = ['//visibility:public'] + name = "pch_cstd", + main = "CStd.hpp", + visibility = ["//visibility:public"], ) diff --git a/src/PCH/CStd.hpp b/src/PCH/CStd.hpp index 229019ba..479e713e 100644 --- a/src/PCH/CStd.hpp +++ b/src/PCH/CStd.hpp @@ -32,4 +32,3 @@ #include #include #include -#include diff --git a/src/Pog/BUILD.bazel b/src/Pog/BUILD.bazel index fc5384d4..5cd65d04 100644 --- a/src/Pog/BUILD.bazel +++ b/src/Pog/BUILD.bazel @@ -1,21 +1,24 @@ -load('@rules_cc//cc:defs.bzl', 'cc_library') -load('//tools/bazel:pch.bzl', 'precompiled_headers') +load("@rules_cc//cc:defs.bzl", "cc_library") +load("//tools/bazel:pch.bzl", "precompiled_headers") cc_library( - name = 'pog_core', - hdrs = glob(['**/*.hpp'], exclude = ['Pog.hpp']), + name = "pog_core", + hdrs = glob( + ["**/*.hpp"], + exclude = ["Pog.hpp"], + ), + visibility = ["//visibility:private"], deps = [ - '@re2//:re2', - '@fmt//:fmt' + "@fmt", + "@re2", ], - visibility = ['//visibility:private'] ) precompiled_headers( - name = 'pog', - main = 'Pog.hpp', + name = "pog", + main = "Pog.hpp", + visibility = ["//visibility:public"], deps = [ - ':pog_core' + ":pog_core", ], - visibility = ['//visibility:public'] ) diff --git a/tests/BUILD.bazel b/tests/BUILD.bazel index f73075d2..4a50d10c 100644 --- a/tests/BUILD.bazel +++ b/tests/BUILD.bazel @@ -1,24 +1,24 @@ -load('@rules_cc//cc:defs.bzl', 'cc_library') -load('//tools/bazel:pch.bzl', 'precompiled_headers') +load("@rules_cc//cc:defs.bzl", "cc_library") +load("//tools/bazel:pch.bzl", "precompiled_headers") package( default_visibility = [ - '//tests:__subpackages__', + "//tests:__subpackages__", ], ) precompiled_headers( - name = 'pch_gtest', - main = 'gtest.hpp', + name = "pch_gtest", + main = "gtest.hpp", deps = [ - '@gtest//:gtest-libgtest' - ] + "@gtest//:gtest-libgtest", + ], ) cc_library( - name = 'test_fixtures', - hdrs = ['fixtures.hpp'], + name = "test_fixtures", + hdrs = ["fixtures.hpp"], deps = [ - '//src/PCH:pch_cstd' - ] + "//src/PCH:pch_cstd", + ], ) diff --git a/tests/Integration/AssemblerCore/AssemblerSuccess.cpp b/tests/Integration/AssemblerCore/AssemblerSuccess.cpp index 97e89291..151d4160 100644 --- a/tests/Integration/AssemblerCore/AssemblerSuccess.cpp +++ b/tests/Integration/AssemblerCore/AssemblerSuccess.cpp @@ -1,6 +1,5 @@ #include "tests/fixtures.hpp" - TEST_F(ASSEMBLER, ASM_R_R_b8) { std::string data = "mov xlll0, xlll1;"; auto state(compiler.TransformToIR(data)); diff --git a/tests/Integration/AssemblerCore/FullAssembler.cpp b/tests/Integration/AssemblerCore/FullAssembler.cpp index 33376b33..58b5828b 100644 --- a/tests/Integration/AssemblerCore/FullAssembler.cpp +++ b/tests/Integration/AssemblerCore/FullAssembler.cpp @@ -1,6 +1,5 @@ #include "tests/fixtures.hpp" - TEST_F(FULL_ASSEMBLER, MULTUPLE_INSTRUCTIONS) { std::string data = "_start:\n\tmov x0, 0u1;\n\tmov x1, 0u2;\n\tadd x0, x1;"; std::uint32_t code_size; diff --git a/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp b/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp index a14e7dc8..d820de84 100644 --- a/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp +++ b/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp @@ -1,6 +1,5 @@ #include "tests/fixtures.hpp" - TEST_F(TWO_OPERANDS_SUCCESS, OPERANDS_R_R_b8) { std::string data = "mov xlll0, xlll1;"; std::uint32_t code_size; diff --git a/tests/Integration/BUILD.bazel b/tests/Integration/BUILD.bazel index c2a4ff57..f5269665 100644 --- a/tests/Integration/BUILD.bazel +++ b/tests/Integration/BUILD.bazel @@ -1,16 +1,16 @@ -load('@rules_cc//cc:defs.bzl', 'cc_test') +load("@rules_cc//cc:defs.bzl", "cc_test") cc_test( - name = 'integration-test', + name = "integration-test", + srcs = glob(["**/*.cpp"]), linkstatic = True, - srcs = glob(['**/*.cpp']), deps = [ - '@gtest//:gtest-gmock_main', - '@fmt//:fmt', - '//tests:pch_gtest', - '//tests:test_fixtures', - '//src/PCH:pch_cstd', - '//src/Assembler:assembler_core', - '//src/Emulator:emulator_core' - ] + "//src/Assembler:assembler_core", + "//src/Emulator:emulator_core", + "//src/PCH:pch_cstd", + "//tests:pch_gtest", + "//tests:test_fixtures", + "@fmt", + "@gtest//:gtest-gmock_main", + ], ) diff --git a/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp b/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp index 5098223a..693b63c0 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp @@ -1,6 +1,5 @@ #include "tests/fixtures.hpp" - static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; static constexpr std::uint8_t BYTE_SUM = BYTE_DATA1 + BYTE_DATA2 + 1; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp b/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp index 0121dffa..42461a62 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp @@ -1,6 +1,5 @@ #include "tests/fixtures.hpp" - static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; static constexpr std::uint8_t BYTE_SUM = BYTE_DATA1 + BYTE_DATA2; diff --git a/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp b/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp index 49d6641e..c3fa62ef 100644 --- a/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp +++ b/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp @@ -1,6 +1,5 @@ #include "tests/fixtures.hpp" - TEST_F(EXCEPTION_TEST, CPU_EXCEPTION_IO) { cpu.mem_controller->Load16(*cpu.xip, 8273); diff --git a/tests/Modular/AssemblerCore/Parser/Statements.cpp b/tests/Modular/AssemblerCore/Parser/Statements.cpp index 93c58fbb..34669811 100644 --- a/tests/Modular/AssemblerCore/Parser/Statements.cpp +++ b/tests/Modular/AssemblerCore/Parser/Statements.cpp @@ -1,6 +1,5 @@ -#include "tests/fixtures.hpp" #include "Assembler/Core/Compiler.hpp" - +#include "tests/fixtures.hpp" TEST_F(ASM_PARSER_STMT_TEST, STMT1) { std::string data = "adc x0, x1;"; diff --git a/tests/Modular/BUILD.bazel b/tests/Modular/BUILD.bazel index ead31c14..79eff704 100644 --- a/tests/Modular/BUILD.bazel +++ b/tests/Modular/BUILD.bazel @@ -1,17 +1,20 @@ -load('@rules_cc//cc:defs.bzl', 'cc_test') +load("@rules_cc//cc:defs.bzl", "cc_test") cc_test( - name = 'modular-test', - linkstatic = True, + name = "modular-test", # TODO: remove when tests are fixed - srcs = glob(['**/*.cpp'], exclude = ['EmulatorCore/Decoding/**/*.cpp']), + srcs = glob( + ["**/*.cpp"], + exclude = ["EmulatorCore/Decoding/**/*.cpp"], + ), + linkstatic = True, deps = [ - '@gtest//:gtest-gmock_main', - '@fmt//:fmt', - '//tests:pch_gtest', - '//tests:test_fixtures', - '//src/PCH:pch_cstd', - '//src/Assembler:assembler_core', - '//src/Emulator:emulator_core', - ] + "//src/Assembler:assembler_core", + "//src/Emulator:emulator_core", + "//src/PCH:pch_cstd", + "//tests:pch_gtest", + "//tests:test_fixtures", + "@fmt", + "@gtest//:gtest-gmock_main", + ], ) diff --git a/tests/Pog/Automaton.cpp b/tests/Pog/Automaton.cpp index c1db89c6..09545241 100644 --- a/tests/Pog/Automaton.cpp +++ b/tests/Pog/Automaton.cpp @@ -3,7 +3,6 @@ #include "PCH/CStd.hpp" #include "tests/gtest.hpp" - using namespace pog; class TestAutomaton : public ::testing::Test { diff --git a/tests/Pog/BUILD.bazel b/tests/Pog/BUILD.bazel index 77ff00fa..05d3a74e 100644 --- a/tests/Pog/BUILD.bazel +++ b/tests/Pog/BUILD.bazel @@ -1,14 +1,14 @@ -load('@rules_cc//cc:defs.bzl', 'cc_test') +load("@rules_cc//cc:defs.bzl", "cc_test") cc_test( - name = 'test-pog', - srcs = glob(['**/*.cpp']), + name = "test-pog", + srcs = glob(["**/*.cpp"]), deps = [ - '//tests:pch_gtest', - '//src/PCH:pch_cstd', - '//src/Pog:pog', - '@gtest//:gtest-gmock_main', - '@re2//:re2', - '@fmt//:fmt' - ] + "//src/PCH:pch_cstd", + "//src/Pog:pog", + "//tests:pch_gtest", + "@fmt", + "@gtest//:gtest-gmock_main", + "@re2", + ], ) diff --git a/tests/Pog/Grammar.cpp b/tests/Pog/Grammar.cpp index b63f26c0..7ae97f4a 100644 --- a/tests/Pog/Grammar.cpp +++ b/tests/Pog/Grammar.cpp @@ -3,7 +3,6 @@ #include "PCH/CStd.hpp" #include "tests/gtest.hpp" - using namespace pog; class TestGrammar : public ::testing::Test {}; diff --git a/tests/Pog/Item.cpp b/tests/Pog/Item.cpp index 7c0e85ef..7445eba3 100644 --- a/tests/Pog/Item.cpp +++ b/tests/Pog/Item.cpp @@ -3,7 +3,6 @@ #include "PCH/CStd.hpp" #include "tests/gtest.hpp" - using namespace pog; class TestItem : public ::testing::Test {}; diff --git a/tests/Pog/Parser.cpp b/tests/Pog/Parser.cpp index cb70586f..28439dd6 100644 --- a/tests/Pog/Parser.cpp +++ b/tests/Pog/Parser.cpp @@ -3,7 +3,6 @@ #include "PCH/CStd.hpp" #include "tests/gtest.hpp" - using namespace pog; using namespace ::testing; diff --git a/tests/fixtures.hpp b/tests/fixtures.hpp index 2f234c5f..12c80ce3 100644 --- a/tests/fixtures.hpp +++ b/tests/fixtures.hpp @@ -5,10 +5,10 @@ #define private public #include "Assembler/Core/Compiler.hpp" -#include "Emulator/Core/CPU/CPU.hpp" -#include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" #include "Common/LanguageSpec/Flags.hpp" #include "Common/LanguageSpec/Opcodes.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" #include "Emulator/Core/MemoryController/MemoryControllerST.hpp" #undef private @@ -226,5 +226,5 @@ class TWO_OPERANDS_FAILURE : public ::testing::Test { }; constexpr inline std::uint8_t EncodeTestFlags(HyperCPU::Mode md, HyperCPU::OperandTypes types) { - return (static_cast(md) << 4) | static_cast(types); + return (static_cast(md) << 4) | static_cast(types); } diff --git a/tests/gtest.hpp b/tests/gtest.hpp index 4829be8f..53a3bfd0 100644 --- a/tests/gtest.hpp +++ b/tests/gtest.hpp @@ -1,3 +1,3 @@ /* precompiled gtest header, used by our unit & integration tests */ -#include #include +#include diff --git a/tools/bazel/BUILD.bazel b/tools/bazel/BUILD.bazel index b97ffb1d..69b83cbe 100644 --- a/tools/bazel/BUILD.bazel +++ b/tools/bazel/BUILD.bazel @@ -1 +1 @@ -'Common macros, rules etc. used by HyperCPU' +"Common macros, rules etc. used by HyperCPU" diff --git a/tools/bazel/pch.bzl b/tools/bazel/pch.bzl index 316bcad7..6f7eb9ae 100644 --- a/tools/bazel/pch.bzl +++ b/tools/bazel/pch.bzl @@ -1,9 +1,8 @@ -'Custom target to support precompiled headers. Notice, this is relevant to end-consumer project, like ours' +"Custom target to support precompiled headers. Notice, this is relevant to end-consumer project, like ours" # Inspired by: https://github.com/erenon/rules_pch -load('@rules_cc//cc:action_names.bzl', 'CPP_COMPILE_ACTION_NAME') -load('@bazel_tools//tools/cpp:toolchain_utils.bzl', 'find_cpp_toolchain') - +load("@bazel_tools//tools/cpp:toolchain_utils.bzl", "find_cpp_toolchain") +load("@rules_cc//cc:action_names.bzl", "CPP_COMPILE_ACTION_NAME") def _global_flags(ctx, cc_toolchain): feature_configuration = cc_common.configure_features( @@ -21,16 +20,15 @@ def _global_flags(ctx, cc_toolchain): variables = compile_variables, ) - if cc_toolchain.needs_pic_for_dynamic_libraries(feature_configuration=feature_configuration): - return tc_flags + ['-fPIC'] + if cc_toolchain.needs_pic_for_dynamic_libraries(feature_configuration = feature_configuration): + return tc_flags + ["-fPIC"] return tc_flags - def _precompiled_headers_impl(ctx): files = ctx.attr.main.files.to_list() if len(files) != 1: - fail('expected a single aggregated header to compile, got: {}'.format(files)) + fail("expected a single aggregated header to compile, got: {}".format(files)) main_file = files[0] args = ctx.actions.args() @@ -43,7 +41,7 @@ def _precompiled_headers_impl(ctx): headers = [] for dep in ctx.attr.deps: if not CcInfo in dep: - fail('dep arguments must provide CcInfo (e.g: cc_library)') + fail("dep arguments must provide CcInfo (e.g: cc_library)") # collect exported header files compilation_context = dep[CcInfo].compilation_context @@ -51,48 +49,48 @@ def _precompiled_headers_impl(ctx): # add defines for define in compilation_context.defines.to_list(): - args.add('-D' + define) + args.add("-D" + define) # add include dirs for i in compilation_context.includes.to_list(): - args.add('-I' + i) + args.add("-I" + i) - args.add_all(compilation_context.quote_includes.to_list(), before_each = '-iquote') - args.add_all(compilation_context.system_includes.to_list(), before_each = '-isystem') + args.add_all(compilation_context.quote_includes.to_list(), before_each = "-iquote") + args.add_all(compilation_context.system_includes.to_list(), before_each = "-isystem") - inputs = depset(direct=[main_file], transitive=headers+[cc_toolchain.all_files]) + inputs = depset(direct = [main_file], transitive = headers + [cc_toolchain.all_files]) # add args specified for this rule args.add_all(ctx.attr.copts) # force compilation of header - args.add('-xc++-header') + args.add("-xc++-header") args.add(main_file.path) # specify output - output = ctx.actions.declare_file('{}.pch'.format(main_file.basename)) - args.add('-o', output.path) + output = ctx.actions.declare_file("{}.pch".format(main_file.basename)) + args.add("-o", output.path) # Unless -MD is specified while creating the precompiled file, # the .d file of the user of the precompiled file will not # show the precompiled file: therefore bazel will not rebuild # the user if the pch file changes. - args.add('-MD') - args.add('-MF', "/dev/null") + args.add("-MD") + args.add("-MF", "/dev/null") ctx.actions.run( inputs = inputs, outputs = [output], executable = cc_toolchain.compiler_executable, arguments = [args], - mnemonic = 'PrecompileHdrs', - progress_message = 'Pre-compiling header: {}'.format(main_file.basename), + mnemonic = "PrecompileHdrs", + progress_message = "Pre-compiling header: {}".format(main_file.basename), ) # create a CcInfo output that cc_binary rules can depend on compilation_context = cc_common.create_compilation_context( - headers = depset(direct=[output, main_file]), - includes = depset(direct=[output.dirname]), + headers = depset(direct = [output, main_file]), + includes = depset(direct = [output.dirname]), ) main_cc_info = CcInfo(compilation_context = compilation_context, linking_context = None) cc_info = cc_common.merge_cc_infos( @@ -102,15 +100,14 @@ def _precompiled_headers_impl(ctx): return [cc_info] - precompiled_headers = rule( implementation = _precompiled_headers_impl, attrs = { - 'main': attr.label(allow_files=True, mandatory=True), - 'deps': attr.label_list(), - 'copts': attr.string_list(), - '_cc_toolchain': attr.label(default = Label('@bazel_tools//tools/cpp:current_cc_toolchain')), + "main": attr.label(allow_files = True, mandatory = True), + "deps": attr.label_list(), + "copts": attr.string_list(), + "_cc_toolchain": attr.label(default = Label("@bazel_tools//tools/cpp:current_cc_toolchain")), }, - toolchains = ['@bazel_tools//tools/cpp:toolchain_type'], - fragments = ['cpp'], + toolchains = ["@bazel_tools//tools/cpp:toolchain_type"], + fragments = ["cpp"], ) diff --git a/tools/build.py b/tools/build.py deleted file mode 100755 index 24cf7d52..00000000 --- a/tools/build.py +++ /dev/null @@ -1,368 +0,0 @@ -#!/usr/bin/env python3 - -import os -import sys -import json -import errno -import shutil -import typing -import inspect -import logging -import argparse -import subprocess -import multiprocessing - -from pathlib import Path -from collections import OrderedDict -from dataclasses import dataclass, field -from typing import Callable, Iterable, Union, Tuple, Collection, Optional - -from conan.api.conan_api import ConanAPI, ConanException -# this is not part of external API, but those formatters are really cool -from conan.api.output import ConanOutput -from conan.cli.printers import print_profiles -from conan.cli.printers.graph import print_graph_basic, print_graph_packages - - -logger = logging.getLogger(__file__ if '__file__' in vars() else 'build.helper') - - -DESCRIPTION = ''' - CLI build helper. -''' - - -@dataclass -class Config: - build_directory: Path = field(default_factory=lambda: Path.cwd().joinpath('build')) - cores: int = multiprocessing.cpu_count() - # CMake-specific - build_configs: Iterable[str] = field(default_factory=lambda: ['Debug']) - generator: Optional[str] = None - defines: Collection[Tuple[str, str, str]] = field(default_factory=lambda: []) - # Conan-specific - # allow conan to detect profile (might be inaccurate) - allow_profile_detection: bool = False - # build profile specifies target environment - build_profile: str = 'default' - # host profile describes host environment (where build happens) - host_profile: str = 'default' - - -def routine(priority: int) -> Callable: - def factory(f: Callable) -> Callable: - f.priority = priority - f.is_routine = True - return f - - return factory - - -class Routines: - def __init__(self, params: Config): - self.__params = params - - def routines(self) -> Iterable[Tuple[str, Callable]]: - def key(pair): - _, member = pair - return member.priority if hasattr(member, 'priority') else 0 - - members = inspect.getmembers(self, predicate=inspect.ismethod) - for name, method in sorted(members, key=key, reverse=True): - if hasattr(method, 'is_routine'): - yield name, method - - @routine(5) - def remove(self): - for config in self.__params.build_configs: - directory = self.__params.build_directory.joinpath(config) - if directory.is_dir(): - logger.info(f'removing directory for CMake build config "{config}"') - shutil.rmtree(directory) - else: - logger.error(f'build directory for config "{config}" was not found or was not a directory') - - @routine(4) - def conan_install(self): - api = ConanAPI(str(self.__params.build_directory / 'conan2')) - - detect_profiles = False - profiles = api.profiles.list() - if len(profiles) > 0: - logger.debug(f'detected profiles: ' + ', '.join(profiles)) - else: - if not self.__params.allow_profile_detection: - raise FileNotFoundError( - 'no profiles exist and autodetection is turned off' - ) - detect_profiles = True - - logger.info( - 'please notice, this script modifies "build_type" in incoming profile, to match running params' - ) - remotes = api.remotes.list() - - for config in self.__params.build_configs: - if not self._conan_install_for_config(config, api, remotes, detect_profiles=detect_profiles): - raise RuntimeError( - f'failed to install dependencies for config: {config}, see error from conan above' - ) - - @routine(3) - def configure(self): - if not self.__params.build_directory.is_dir(): - self.__params.build_directory.mkdir() - - use_presets = Path.cwd().joinpath('CMakeUserPresets.json').is_file() - if use_presets: - logger.info('found CMake presets') - - logger.info('configuring for CMake build configs: ' + ', '.join(self.__params.build_configs)) - for config in self.__params.build_configs: - source = Path.cwd() - binary = self.__params.build_directory.joinpath(config) - - # TODO: allow multiconfigs - command = [ - 'cmake', - '--preset', f'conan-{config.lower()}', - '-B', str(binary), - '-S', str(source), - self._decorate_cmake_variable('CMAKE_EXPORT_COMPILE_COMMANDS', 'ON', 'BOOL'), - self._decorate_cmake_variable('CMAKE_BUILD_TYPE', config) - ] if use_presets else [ - 'cmake', - '-B', str(binary), - '-S', str(source), - self._decorate_cmake_variable('CMAKE_EXPORT_COMPILE_COMMANDS', 'ON', 'BOOL'), - self._decorate_cmake_variable('CMAKE_BUILD_TYPE', config) - ] - - if self.__params.generator is not None: - command.extend(['-G', self.__params.generator]) - - if len(self.__params.defines) > 0: - for key, var_type, value in self.__params.defines: - command.append(self._decorate_cmake_variable(key, value, var_type)) - - logger.info(f'running configure command for CMake config {config}') - self._run(command) - - @routine(2) - def build(self): - if not self.__params.build_directory.is_dir(): - raise FileNotFoundError(f'build directory \'{self.__params.build_directory}\' was not found') - - logger.info(f'using {self.__params.cores} threads') - for config in self.__params.build_configs: - directory = self.__params.build_directory.joinpath(config) - logger.info(f'building for CMake configuration \'{config}\'') - self._run([ - 'cmake', - '--build', str(directory), - '--parallel', str(self.__params.cores) - ]) - - @routine(1) - def symlink_compile_commands(self: 'Routines') -> None: - path = None - if 'Debug' in self.__params.build_configs: - path = self.__params.build_directory.joinpath('Debug').joinpath('compile_commands.json') - logger.info(f'creating symlink for path \'{path}\'') - - if 'Release' in self.__params.build_configs: - path = self.__params.build_directory.joinpath('Release').joinpath('compile_commands.json') - logger.info(f'creating symlink for path \'{path}\'') - - if path is None: - raise ValueError('no supported CMake configs detected') - - symlink = Path.cwd().joinpath('compile_commands.json') - if symlink.is_symlink(): - symlink.unlink() - - Path.cwd().joinpath('compile_commands.json').symlink_to(path) - - def _conan_install_for_config( - self, - config: str, - api: ConanAPI, - remotes: list, - detect_profiles: bool = False - ) -> bool: - out = ConanOutput() - try: - if detect_profiles: - build_profile = host_profile = api.profiles.detect() - else: - build_profile = api.profiles.get_profile([self.__params.build_profile]) - host_profile = api.profiles.get_profile([self.__params.host_profile]) - - mixin = OrderedDict({'build_type': config}) - for profile in (build_profile, host_profile): - profile.update_settings(mixin) - if profile.processed_settings is None: - profile.process_settings(api.config.settings_yml) - - if detect_profiles: - out.title('Autodetected profiles (be careful using them!)') - print_profiles(host_profile, build_profile) - - except ConanException as conan_error: - raise RuntimeError( - f'getting requested profiles failed: {(self.__params.build_profile, self.__params.host_profile)}' - ) from conan_error - - logger.info(f'computing dependency graph for config: {config}') - try: - graph = api.graph.load_graph_consumer( - path=api.local.get_conanfile_path('.', Path.cwd(), py=True), - # these 4 are provided by recipe - name=None, - version=None, - user=None, - channel=None, - # ============================== - profile_build=build_profile, - profile_host=host_profile, - lockfile=None, - remotes=remotes, - update=True, - check_updates=True - ) - print_graph_basic(graph) - graph.report_graph_error() - api.graph.analyze_binaries(graph, build_mode=['missing'], remotes=remotes, update=True) - print_graph_packages(graph) - - except ConanException as conan_error: - out.error(str(conan_error)) - return False - - # make sure to define cmake layout in conanfile.py - try: - api.install.install_binaries(graph, remotes) - api.install.install_consumer(graph, source_folder=Path.cwd()) - except ConanException as conan_error: - out.error(str(conan_error)) - return False - - return True - - def _run(self: 'Routines', command: typing.List[str]) -> None: - logger.info('running command: ' + ' '.join(command)) - code = subprocess.run(command, encoding='UTF-8', stderr=subprocess.STDOUT, env=os.environ).returncode - if code: - sys.exit(f'error: subprocess failed: {errno.errorcode[code]} (code: {code})') - - def _decorate_cmake_variable(self: 'Routines', var: str, value: str, var_type: Union[str, None] = None) -> str: - if var_type is not None: - return f'-D{var.upper()}:{var_type}={value}' - return f'-D{var.upper()}={value}' - - -def resolve_profiles(config: Config, args: argparse.Namespace): - if args.profile_all is not None: - config.build_profile = config.host_profile = args.profile_all - logger.info(f'using specified "all" (build and host) profile: {args.profile_all}') - return - - if args.profile_host is not None: - config.host_profile = args.profile_host - logger.info(f'using specified "host" profile: {args.profile_host}') - - if args.profile_build is not None: - config.build_profile = args.profile_build - logger.info(f'using specified "host" profile: {args.profile_build}') - - if all(profile is None for profile in (args.profile_all, args.profile_host, args.profile_build)): - logger.info('no profiles were specified. Using default for both "host" and "build"') - - -def resolve_defines(config: Config, args: argparse.Namespace): - for define in args.defines: - name, value = define.split('=') - var_name, var_type = name.split(':') - config.defines.append((var_name, var_type, value)) - - -def parse_cli_args() -> argparse.Namespace: - parser = argparse.ArgumentParser(description=DESCRIPTION, formatter_class=argparse.RawDescriptionHelpFormatter) - # Routines - parser.add_argument('-b', '--build', action='store_true', dest='build') - parser.add_argument('-c', '--configure', action='store_true', dest='configure') - parser.add_argument('-i', '--conan-install', action='store_true', dest='conan_install') - parser.add_argument('-r', '--remove', action='store_true', dest='remove') - parser.add_argument('-l', '--symlink-compile-commands', action='store_true', dest='symlink_compile_commands') - # Environment - parser.add_argument('--build-dir', action='store', dest='build_directory') - # TODO: allow more configs - parser.add_argument('--config', action='append', dest='configs', choices=['Debug', 'Release']) - parser.add_argument('--parallel', action='store', dest='cores') - parser.add_argument('--generator', action='store', dest='generator') - # Profiles - parser.add_argument('--pr:a', action='store', dest='profile_all') - parser.add_argument('--pr:h', action='store', dest='profile_host') - parser.add_argument('--pr:b', action='store', dest='profile_build') - parser.add_argument('--profiles-detection', action='store_true', dest='profile_detect') - # Arbitrary CMake flags - parser.add_argument('-D', metavar='KEY:TYPE=VALUE', action='append', default=[], dest='defines') - return parser.parse_args() - - -def main(): - try: - from rich.logging import RichHandler - from rich.traceback import install - - install(show_locals=True) - handler = RichHandler( - level=logging.DEBUG, - rich_tracebacks=True, - show_path=False, - show_time=False, - show_level=True, - ) - except ImportError: - handler = logging.StreamHandler(sys.stdout) - - logging.root.addHandler(handler) - logging.root.setLevel(logging.INFO) - - args = parse_cli_args() - - params = Config() - if getattr(args, 'build_directory') is not None: - params.build_directory = Path.cwd().joinpath(args.build_directory) - logger.info(f'config: user-provided build directory: "{params.build_directory}"') - if getattr(args, 'configs') is not None: - params.build_configs = args.configs - logger.info(f'config: user-provided build configs: {params.build_configs}') - if getattr(args, 'cores') is not None: - params.cores = int(args.cores) - logger.info(f'config: user-provided threads, that will be run in parallel: "{params.cores}"') - if getattr(args, 'generator') is not None: - params.generator = args.generator - logger.info(f'config: user-provided generator: "{params.generator}"') - params.allow_profile_detection = args.profile_detect - - resolve_profiles(params, args) - resolve_defines(params, args) - - r = Routines(params) - for routine, f in r.routines(): - if not hasattr(args, routine): - logger.info(f'routine \'{routine}\' is not configured for CLI, skipping') - continue - if getattr(args, routine): - logger.info(f'running {routine}') - f() - - logger.info('done!') - - -if __name__ == '__main__': - try: - main() - except KeyboardInterrupt: - print('exited by user') \ No newline at end of file diff --git a/tools/increment_version.py b/tools/increment_version.py index 645b02a5..c50e8a3b 100755 --- a/tools/increment_version.py +++ b/tools/increment_version.py @@ -17,8 +17,8 @@ def factory(func: Callable): nonlocal file if not isinstance(file, Path): file = Path(file) - setattr(func, 'is_dispatcher', True) - setattr(func, 'file', file) + setattr(func, "is_dispatcher", True) + setattr(func, "file", file) @wraps(func) def dispatcher(*args, **kwargs): @@ -37,101 +37,111 @@ class Version: patch: int def __str__(self) -> str: - return f'{self.major}.{self.minor}.{self.patch}' + return f"{self.major}.{self.minor}.{self.patch}" @classmethod - def from_str(cls, s: str) -> 'Version': - major, minor, patch = map(int, s.split('.')) + def from_str(cls, s: str) -> "Version": + major, minor, patch = map(int, s.split(".")) return cls(major=major, minor=minor, patch=patch) class Incrementors: def fetch_version(self) -> Version: # we fetch current version from bazel module - with open('MODULE.bazel', 'r') as fd: + with open("MODULE.bazel", "r") as fd: contents = fd.read() module = self.__bazel_find_module(contents) current_version = self.__bazel_find_version(module) - grouping = r'(.*)=\s*[\'\"](.*)[\'\"]' + grouping = r"(.*)=\s*[\'\"](.*)[\'\"]" if (result := re.search(grouping, current_version, flags=re.DOTALL)) is None: - raise ValueError(f'could not apply grouping: {grouping}') + raise ValueError(f"could not apply grouping: {grouping}") version_str = result.group(2) return Version.from_str(version_str) - @dispatching_file('src/Common/Version.hpp') + @dispatching_file("src/Common/Version.hpp") def update_version_file(self, file: Path, version: Version): contents = StringIO() version_matches = 0 - with open(file, 'r') as fd: + with open(file, "r") as fd: for line in fd: - if 'HCPU_VERSION' not in line.upper(): - contents.write(line + '\n') + if "HCPU_VERSION" not in line.upper(): + contents.write(line + "\n") continue version_matches += 1 - prefix, _ = line.split('=') + prefix, _ = line.split("=") contents.write(f'{prefix.strip()} = "{str(version)}";\n') if version_matches < 1: - raise ValueError('could not find a line with version string') + raise ValueError("could not find a line with version string") if version_matches > 1: - raise ValueError(f'found {version_matches} lines with version string, expected a single line') + raise ValueError( + f"found {version_matches} lines with version string, expected a single line" + ) - with open(file, 'w') as fd: + with open(file, "w") as fd: fd.write(contents.getvalue()) - @dispatching_file('MODULE.bazel') - def update_module_file(self, file: Path, version = Version): - with open(file, 'r') as fd: + @dispatching_file("MODULE.bazel") + def update_module_file(self, file: Path, version=Version): + with open(file, "r") as fd: contents = fd.read() module = self.__bazel_find_module(contents) current_version = self.__bazel_find_version(module) - newly_versioned_module = module.replace(current_version, f'version = \'{str(version)}\'') + newly_versioned_module = module.replace( + current_version, f"version = '{str(version)}'" + ) contents = contents.replace(module, newly_versioned_module) - with open(file, 'w') as fd: + with open(file, "w") as fd: fd.write(contents) def __bazel_find_module(self, contents: str) -> str: - module_pattern = r'module\(.*?\)' + module_pattern = r"module\(.*?\)" matches = re.findall(module_pattern, contents, flags=re.DOTALL) if len(matches) != 1: - raise ValueError(f'regex {module_pattern} matched {len(matches)} times, expected to match only once') + raise ValueError( + f"regex {module_pattern} matched {len(matches)} times, expected to match only once" + ) return matches[0] def __bazel_find_version(self, module: str) -> str: - version_pattern = r'version\s*=\s*[\'\"].*[\'\"]' + version_pattern = r"version\s*=\s*[\'\"].*[\'\"]" matches = re.findall(version_pattern, module, flags=re.DOTALL) if len(matches) != 1: - raise ValueError(f'regex {version_pattern} matched {len(matches)} times, expected to match only once') + raise ValueError( + f"regex {version_pattern} matched {len(matches)} times, expected to match only once" + ) return matches[0] def main(): parser = argparse.ArgumentParser() - parser.add_argument('--increment', action='store', dest='target', choices=['patch', 'minor']) + parser.add_argument( + "--increment", action="store", dest="target", choices=["patch", "minor"] + ) args = parser.parse_args() incrementors = Incrementors() new_version = incrementors.fetch_version() match args.target: - case 'patch': + case "patch": new_version.patch += 1 - case 'minor': + case "minor": new_version.patch = 0 new_version.minor += 1 for name, method in inspect.getmembers(incrementors, predicate=inspect.ismethod): - if hasattr(method, 'is_dispatcher'): + if hasattr(method, "is_dispatcher"): method(version=new_version) -if __name__ == '__main__': +if __name__ == "__main__": main() From 0b13bb26ab0fede57d191ff5ac86035841fbc459 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sun, 11 May 2025 02:35:15 +0300 Subject: [PATCH 29/40] opt should not be strict --- .bazelrc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.bazelrc b/.bazelrc index e55a8920..e59f2812 100644 --- a/.bazelrc +++ b/.bazelrc @@ -41,7 +41,7 @@ build:linux-dbg --config=linux-fragile build:linux-dbg --cxxopt=-ggdb3 # Linux, Release build:linux-opt --compilation_mode opt -build:linux-opt --config=linux-strict +build:linux-opt --config=linux build:linux-opt --cxxopt=-O3 # ---------------------------- From a64a3d7ec09d5a07a211b8a68ae56b1034e08110 Mon Sep 17 00:00:00 2001 From: HyperWinX Date: Sun, 11 May 2025 18:29:57 +0400 Subject: [PATCH 30/40] Fix all tests --- src/Assembler/Core/Compiler.cpp | 36 +-- src/Common/Exit.hpp | 25 ++ src/Common/LanguageSpec/Opcodes.hpp | 2 + .../Integration/EmulatorCore/CPU/CPU_CALL.cpp | 2 +- .../Integration/EmulatorCore/CPU/CPU_DEC.cpp | 8 +- .../Integration/EmulatorCore/CPU/CPU_DIV.cpp | 4 +- .../Integration/EmulatorCore/CPU/CPU_INC.cpp | 8 +- .../EmulatorCore/CPU/CPU_LOIVT.cpp | 2 +- .../Integration/EmulatorCore/CPU/CPU_MOV.cpp | 3 - .../Integration/EmulatorCore/CPU/CPU_POP.cpp | 4 +- .../Integration/EmulatorCore/CPU/CPU_PUSH.cpp | 4 +- .../AssemblerCore/Parser/Statements.cpp | 1 - tests/Modular/BUILD.bazel | 3 +- .../Modular/EmulatorCore/CPUInit/CPUInit.cpp | 6 +- .../EmulatorCore/Decoding/ADCInstr/R_IMM.cpp | 52 ++-- .../EmulatorCore/Decoding/ADCInstr/R_M.cpp | 58 ++-- .../EmulatorCore/Decoding/ADCInstr/R_R.cpp | 76 +++-- .../EmulatorCore/Decoding/ADCInstr/R_RM.cpp | 78 +++-- .../Decoding/ADCInstr/Unsupported.cpp | 134 ++++---- .../EmulatorCore/Decoding/ADDInstr/R_IMM.cpp | 52 ++-- .../EmulatorCore/Decoding/ADDInstr/R_M.cpp | 56 ++-- .../EmulatorCore/Decoding/ADDInstr/R_R.cpp | 76 +++-- .../EmulatorCore/Decoding/ADDInstr/R_RM.cpp | 78 +++-- .../Decoding/ADDInstr/Unsupported.cpp | 134 ++++---- .../EmulatorCore/Decoding/ANDInstr/R_IMM.cpp | 52 ++-- .../EmulatorCore/Decoding/ANDInstr/R_M.cpp | 54 ++-- .../EmulatorCore/Decoding/ANDInstr/R_R.cpp | 76 +++-- .../EmulatorCore/Decoding/ANDInstr/R_RM.cpp | 78 +++-- .../Decoding/ANDInstr/Unsupported.cpp | 134 ++++---- .../EmulatorCore/Decoding/ANDNInstr/R_IMM.cpp | 52 ++-- .../EmulatorCore/Decoding/ANDNInstr/R_M.cpp | 54 ++-- .../EmulatorCore/Decoding/ANDNInstr/R_R.cpp | 76 +++-- .../EmulatorCore/Decoding/ANDNInstr/R_RM.cpp | 78 +++-- .../Decoding/ANDNInstr/Unsupported.cpp | 134 ++++---- .../EmulatorCore/Decoding/BSWAPInstr/R.cpp | 62 ++-- .../Decoding/BSWAPInstr/Unsupported.cpp | 236 +++++++------- .../Decoding/CALLEInstr/test_decoder_imm.cpp | 8 +- .../Decoding/CALLEInstr/test_decoder_r.cpp | 12 +- .../CALLEInstr/test_decoder_unsupported.cpp | 254 ++++++++------- .../Decoding/CALLGRInstr/test_decoder_imm.cpp | 8 +- .../Decoding/CALLGRInstr/test_decoder_r.cpp | 13 +- .../CALLGRInstr/test_decoder_unsupported.cpp | 254 ++++++++------- .../Decoding/CALLInstr/test_decoder_imm.cpp | 9 +- .../Decoding/CALLInstr/test_decoder_r.cpp | 12 +- .../CALLInstr/test_decoder_unsupported.cpp | 254 ++++++++------- .../Decoding/CALLLInstr/test_decoder_imm.cpp | 8 +- .../Decoding/CALLLInstr/test_decoder_r.cpp | 12 +- .../CALLLInstr/test_decoder_unsupported.cpp | 254 ++++++++------- .../Decoding/CCRFInstr/test_decoder_none.cpp | 8 +- .../CCRFInstr/test_decoder_unsupported.cpp | 290 +++++++++--------- .../EmulatorCore/Decoding/CMPInstr/M_R.cpp | 54 ++-- .../EmulatorCore/Decoding/CMPInstr/RM_IMM.cpp | 55 ++-- .../EmulatorCore/Decoding/CMPInstr/RM_M.cpp | 57 ++-- .../EmulatorCore/Decoding/CMPInstr/RM_R.cpp | 81 +++-- .../EmulatorCore/Decoding/CMPInstr/R_IMM.cpp | 52 ++-- .../EmulatorCore/Decoding/CMPInstr/R_M.cpp | 54 ++-- .../EmulatorCore/Decoding/CMPInstr/R_R.cpp | 77 +++-- .../EmulatorCore/Decoding/CMPInstr/R_RM.cpp | 78 +++-- .../Decoding/CMPInstr/Unsupported.cpp | 31 +- .../Decoding/COVFInstr/test_decoder_none.cpp | 9 +- .../COVFInstr/test_decoder_unsupported.cpp | 288 +++++++++-------- .../EmulatorCore/Decoding/CUDFInstr/None.cpp | 8 +- .../Decoding/CUDFInstr/Unsupported.cpp | 290 +++++++++--------- .../EmulatorCore/Decoding/DECInstr/R.cpp | 62 ++-- .../Decoding/DECInstr/Unsupported.cpp | 236 +++++++------- .../EmulatorCore/Decoding/DIVInstr/R.cpp | 62 ++-- .../Decoding/DIVInstr/Unsupported.cpp | 246 ++++++++------- .../Decoding/Features/AddressAddition.cpp | 48 ++- .../EmulatorCore/Decoding/HALTInstr/None.cpp | 8 +- .../Decoding/HALTInstr/Unsupported.cpp | 288 +++++++++-------- .../EmulatorCore/Decoding/HIDInstr/None.cpp | 8 +- .../Decoding/HIDInstr/Unsupported.cpp | 288 +++++++++-------- .../EmulatorCore/Decoding/INCInstr/R.cpp | 62 ++-- .../Decoding/INCInstr/Unsupported.cpp | 236 +++++++------- .../Decoding/JMEInstr/test_decoder_imm.cpp | 8 +- .../Decoding/JMEInstr/test_decoder_r.cpp | 12 +- .../JMEInstr/test_decoder_unsupported.cpp | 254 ++++++++------- .../Decoding/JMGRInstr/test_decoder_imm.cpp | 8 +- .../Decoding/JMGRInstr/test_decoder_r.cpp | 12 +- .../JMGRInstr/test_decoder_unsupported.cpp | 254 ++++++++------- .../Decoding/JMLInstr/test_decoder_imm.cpp | 8 +- .../Decoding/JMLInstr/test_decoder_r.cpp | 12 +- .../JMLInstr/test_decoder_unsupported.cpp | 254 ++++++++------- .../Decoding/JMPInstr/test_decoder_imm.cpp | 8 +- .../Decoding/JMPInstr/test_decoder_r.cpp | 12 +- .../JMPInstr/test_decoder_unsupported.cpp | 254 ++++++++------- .../EmulatorCore/Decoding/MOVInstr/M_R.cpp | 54 ++-- .../EmulatorCore/Decoding/MOVInstr/RM_IMM.cpp | 54 ++-- .../EmulatorCore/Decoding/MOVInstr/RM_M.cpp | 54 ++-- .../EmulatorCore/Decoding/MOVInstr/RM_R.cpp | 78 +++-- .../EmulatorCore/Decoding/MOVInstr/R_IMM.cpp | 52 ++-- .../EmulatorCore/Decoding/MOVInstr/R_M.cpp | 54 ++-- .../EmulatorCore/Decoding/MOVInstr/R_R.cpp | 76 +++-- .../EmulatorCore/Decoding/MOVInstr/R_RM.cpp | 78 +++-- .../Decoding/MOVInstr/Unsupported.cpp | 30 +- .../EmulatorCore/Decoding/MULInstr/R_IMM.cpp | 54 ++-- .../EmulatorCore/Decoding/MULInstr/R_M.cpp | 54 ++-- .../EmulatorCore/Decoding/MULInstr/R_R.cpp | 76 +++-- .../EmulatorCore/Decoding/MULInstr/R_RM.cpp | 80 +++-- .../Decoding/MULInstr/Unsupported.cpp | 136 ++++---- .../EmulatorCore/Decoding/ORInstr/R_IMM.cpp | 54 ++-- .../EmulatorCore/Decoding/ORInstr/R_M.cpp | 54 ++-- .../EmulatorCore/Decoding/ORInstr/R_R.cpp | 76 +++-- .../EmulatorCore/Decoding/ORInstr/R_RM.cpp | 78 +++-- .../Decoding/ORInstr/Unsupported.cpp | 134 ++++---- .../EmulatorCore/Decoding/READInstr/IMM.cpp | 17 +- .../Decoding/READInstr/Unsupported.cpp | 229 +++++++------- .../EmulatorCore/Decoding/SHFLInstr/R_IMM.cpp | 52 ++-- .../EmulatorCore/Decoding/SHFLInstr/R_R.cpp | 76 +++-- .../Decoding/SHFLInstr/Unsupported.cpp | 158 +++++----- .../EmulatorCore/Decoding/SHFRInstr/R_IMM.cpp | 52 ++-- .../EmulatorCore/Decoding/SHFRInstr/R_R.cpp | 76 +++-- .../Decoding/SHFRInstr/Unsupported.cpp | 160 +++++----- .../EmulatorCore/Decoding/SUBInstr/R_IMM.cpp | 52 ++-- .../EmulatorCore/Decoding/SUBInstr/R_M.cpp | 54 ++-- .../EmulatorCore/Decoding/SUBInstr/R_R.cpp | 76 +++-- .../EmulatorCore/Decoding/SUBInstr/R_RM.cpp | 78 +++-- .../Decoding/SUBInstr/Unsupported.cpp | 134 ++++---- .../Decoding/WRITEInstr/R_IMM.cpp | 2 +- .../EmulatorCore/Decoding/WRITEInstr/R_R.cpp | 21 +- .../Decoding/WRITEInstr/Unsupported.cpp | 228 +++++++------- 121 files changed, 4762 insertions(+), 5187 deletions(-) create mode 100644 src/Common/Exit.hpp diff --git a/src/Assembler/Core/Compiler.cpp b/src/Assembler/Core/Compiler.cpp index f038a654..6344c88d 100644 --- a/src/Assembler/Core/Compiler.cpp +++ b/src/Assembler/Core/Compiler.cpp @@ -3,6 +3,7 @@ #include "Assembler/Core/BinaryTransformer.hpp" #include "Assembler/Core/Compiler.hpp" #include "Common/Helpers/Classes.hpp" +#include "Common/Exit.hpp" #include "Common/LanguageSpec/Flags.hpp" #include "PCH/CStd.hpp" #include "Pog/Pog.hpp" @@ -311,22 +312,22 @@ HCAsm::BinaryResult HCAsm::HCAsmCompiler::TransformToBinary(HCAsm::CompilerState if (label.is_entry_point) { ir.entry_point = ir.code_size; } }, [&ir](RawValue& raw) mutable -> void { ir.code_size += [&raw]() -> std::uint8_t { - switch (raw.mode) { - case Mode::b8_str: - return std::get>(raw.value.variant)->size(); - case Mode::b8: - return 1; - case Mode::b16: - return 2; - case Mode::b32: - return 4; - case Mode::b64_label: - case Mode::b64: - return 8; - default: - std::abort(); - } - }(); }); + switch (raw.mode) { + case Mode::b8_str: + return std::get>(raw.value.variant)->size(); + case Mode::b8: + return 1; + case Mode::b16: + return 2; + case Mode::b32: + return 4; + case Mode::b64_label: + case Mode::b64: + return 8; + default: + std::abort(); + } + }(); }); } // Resolve references - pass 2 @@ -421,8 +422,7 @@ std::string_view HCAsm::FindLine(const pog::LineSpecialization& line_spec, const "", std::to_string(err_token.line_spec.line).length(), "", err_token.line_spec.offset, std::string(err_token.line_spec.length, '^')); - std::abort(); - // handle error + HyperCPU::exit(1); } void HCAsm::WriteResultFile(HyperCPU::FileType type, HCAsm::BinaryResult& result, std::ofstream& output, std::uint32_t code_size, std::uint32_t entry_point) { diff --git a/src/Common/Exit.hpp b/src/Common/Exit.hpp new file mode 100644 index 00000000..db3fb111 --- /dev/null +++ b/src/Common/Exit.hpp @@ -0,0 +1,25 @@ +#include + +namespace HyperCPU { + /* + Some dynamic functions. + When the program was compiled on debug profile, any exit must be easy to catch by debugger - same thing with unreachable call, + as using this can cause serious bugs. When we are on release profile - allow these things to behave how they were intented. + */ + + [[noreturn]] constexpr void exit([[maybe_unused]] int code) { +#ifdef NDEBUG + std::abort(); +#else + std::exit(code); +#endif + } + + constexpr void unreachable() { +#ifdef NDEBUG + std::abort(); +#else + __builtin_unreachable(); +#endif + } +} \ No newline at end of file diff --git a/src/Common/LanguageSpec/Opcodes.hpp b/src/Common/LanguageSpec/Opcodes.hpp index d62daafa..616238a6 100644 --- a/src/Common/LanguageSpec/Opcodes.hpp +++ b/src/Common/LanguageSpec/Opcodes.hpp @@ -56,11 +56,13 @@ namespace HyperCPU { case Opcode::CCRF: case Opcode::COVF: case Opcode::CUDF: + case Opcode::HALT: case Opcode::HID: case Opcode::INC: case Opcode::DEC: case Opcode::DIV: case Opcode::MUL: + case Opcode::MOV: case Opcode::SUB: case Opcode::SHFR: case Opcode::SHFL: diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp index 5aa1506b..18c856bb 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp @@ -20,7 +20,7 @@ TEST_F(CPU_TEST, INSTR_CALL_R) { TEST_F(CPU_TEST, INSTR_CALL_IMM) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::CALL); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::IMM)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); cpu.mem_controller->Load64(*cpu.xip + 3, 1536); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp b/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp index df72062c..ef8b5a02 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp @@ -19,7 +19,7 @@ static constexpr std::uint64_t QWORD_RESULT_UF = 0xFFFFFFFFFFFFFFFF; TEST_F(CPU_TEST, INSTR_DEC_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DEC); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); @@ -33,7 +33,7 @@ TEST_F(CPU_TEST, INSTR_DEC_R_b8) { TEST_F(CPU_TEST, INSTR_DEC_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DEC); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); @@ -75,7 +75,7 @@ TEST_F(CPU_TEST, INSTR_DEC_R_b64) { TEST_F(CPU_TEST, INSTR_DEC_R_b8_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DEC); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); @@ -89,7 +89,7 @@ TEST_F(CPU_TEST, INSTR_DEC_R_b8_UF) { TEST_F(CPU_TEST, INSTR_DEC_R_b16_UF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DEC); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp b/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp index 895d596c..3e02fff9 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp @@ -25,7 +25,7 @@ static constexpr std::uint64_t QWORD_REMAINDER = DWORD_DATA1 % DWORD_DIVIDER; TEST_F(CPU_TEST, INSTR_DIV_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DIV); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); @@ -40,7 +40,7 @@ TEST_F(CPU_TEST, INSTR_DIV_R_b8) { TEST_F(CPU_TEST, INSTR_DIV_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::DIV); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp b/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp index 92762507..8bdaaec0 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp @@ -19,7 +19,7 @@ static constexpr std::uint64_t QWORD_DATA1_OF = 0xFFFFFFFFFFFFFFFF; TEST_F(CPU_TEST, INSTR_INC_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::INC); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); @@ -33,7 +33,7 @@ TEST_F(CPU_TEST, INSTR_INC_R_b8) { TEST_F(CPU_TEST, INSTR_INC_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::INC); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); @@ -75,7 +75,7 @@ TEST_F(CPU_TEST, INSTR_INC_R_b64) { TEST_F(CPU_TEST, INSTR_INC_R_b8_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::INC); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); @@ -89,7 +89,7 @@ TEST_F(CPU_TEST, INSTR_INC_R_b8_OF) { TEST_F(CPU_TEST, INSTR_INC_R_b16_OF) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::INC); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp b/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp index 6f44cd69..0418ea31 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp @@ -5,7 +5,7 @@ TEST_F(CPU_TEST, INSTR_LOIVT_R_b64) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::LOIVT); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::X1); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp b/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp index 61fbd4c0..cdda494a 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp @@ -1,6 +1,3 @@ -#include -#include - #include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA = 0x55; diff --git a/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp b/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp index 87217dad..9934b5cb 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_POP.cpp @@ -8,7 +8,7 @@ static constexpr std::uint64_t QWORD_DATA1 = 0x555555555555555; TEST_F(CPU_TEST, INSTR_POP_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::POP); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); @@ -24,7 +24,7 @@ TEST_F(CPU_TEST, INSTR_POP_R_b8) { TEST_F(CPU_TEST, INSTR_POP_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::POP); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); diff --git a/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp b/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp index 68e680d6..88230582 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_PUSH.cpp @@ -9,7 +9,7 @@ static constexpr std::uint64_t QWORD_DATA1 = 0x555555555555555; TEST_F(CPU_TEST, INSTR_PUSH_R_b8) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::PUSH); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); @@ -24,7 +24,7 @@ TEST_F(CPU_TEST, INSTR_PUSH_R_b8) { TEST_F(CPU_TEST, INSTR_PUSH_R_b16) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::PUSH); - cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); + cpu.mem_controller->Load8(*cpu.xip + 2, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); cpu.mem_controller->Load8(*cpu.xip + 3, HyperCPU::Reg::XLL0); cpu.mem_controller->Load16(*cpu.xip + 4, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(*cpu.xip + 6, HyperCPU::OperandTypes::NONE); diff --git a/tests/Modular/AssemblerCore/Parser/Statements.cpp b/tests/Modular/AssemblerCore/Parser/Statements.cpp index 34669811..17739916 100644 --- a/tests/Modular/AssemblerCore/Parser/Statements.cpp +++ b/tests/Modular/AssemblerCore/Parser/Statements.cpp @@ -1,4 +1,3 @@ -#include "Assembler/Core/Compiler.hpp" #include "tests/fixtures.hpp" TEST_F(ASM_PARSER_STMT_TEST, STMT1) { diff --git a/tests/Modular/BUILD.bazel b/tests/Modular/BUILD.bazel index 79eff704..04a2b0bd 100644 --- a/tests/Modular/BUILD.bazel +++ b/tests/Modular/BUILD.bazel @@ -4,8 +4,7 @@ cc_test( name = "modular-test", # TODO: remove when tests are fixed srcs = glob( - ["**/*.cpp"], - exclude = ["EmulatorCore/Decoding/**/*.cpp"], + ["**/*.cpp"] ), linkstatic = True, deps = [ diff --git a/tests/Modular/EmulatorCore/CPUInit/CPUInit.cpp b/tests/Modular/EmulatorCore/CPUInit/CPUInit.cpp index b34000a7..3ac06a43 100644 --- a/tests/Modular/EmulatorCore/CPUInit/CPUInit.cpp +++ b/tests/Modular/EmulatorCore/CPUInit/CPUInit.cpp @@ -1,8 +1,4 @@ -#include "tests/gtest.hpp" - -#define private public -#include "Emulator/Core/CPU/CPU.hpp" -#undef private +#include "tests/fixtures.hpp" static constexpr std::uint64_t FULL_CONST = 0x0001020304050607; static constexpr std::uint32_t CONSTH = 0x00010203; diff --git a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_IMM.cpp index 594257b0..e66c3f7b 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_IMM.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } diff --git a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_M.cpp index 9aa6cf87..07ce2f71 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_M.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ADC_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_M_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, ADC_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_M_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, ADC_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_M_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, ADC_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,10 +90,8 @@ TEST_F(DECODER_TEST, ADC_INSTR_R_M_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); -} -PTR); -} +} \ No newline at end of file diff --git a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_R.cpp index 35c069af..ddbeac6c 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_R.cpp @@ -1,95 +1,91 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ADC_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ADC_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ADC_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ADC_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_RM.cpp index 68cf50af..1a33f282 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_RM.cpp @@ -1,97 +1,93 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ADC_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ADC_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ADC_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ADC_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp index 0107e2e1..7bcc5c94 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,114 +7,114 @@ #endif TEST_F(DECODER_TEST, ADC_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADC_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADC_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADC_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADC_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADC_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADC_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADC_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADC_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -127,11 +123,11 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, ADC_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -140,11 +136,11 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, ADC_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -153,11 +149,11 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, ADC_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -166,11 +162,11 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, ADC_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -179,11 +175,11 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, ADC_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -192,11 +188,11 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, ADC_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -205,11 +201,11 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, ADC_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -218,52 +214,52 @@ TEST_F(DECODER_TEST, ADC_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, ADC_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::R); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADC_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADC_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADC_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::ADC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADC); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_IMM.cpp index b9201495..00e41fe5 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_IMM.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } diff --git a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_M.cpp index 3901965f..5623b4f9 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_M.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ADD_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_M_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, ADD_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_M_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, ADD_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_M_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, ADD_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,10 +90,8 @@ TEST_F(DECODER_TEST, ADD_INSTR_R_M_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } -PTR); -} diff --git a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_R.cpp index 9d89bf4a..4995a828 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_R.cpp @@ -1,95 +1,91 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ADD_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADD); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ADD_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADD); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ADD_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADD); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ADD_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADD); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_RM.cpp index 79b348ed..e275cf4c 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_RM.cpp @@ -1,97 +1,93 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ADD_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADD); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ADD_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADD); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ADD_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADD); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ADD_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ADD); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp index 1a73862c..6f72dd05 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,115 +7,115 @@ #endif TEST_F(DECODER_TEST, ADD_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADD_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADD_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADD_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADD_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADD_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADD_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADD_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADD_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -128,11 +124,11 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, ADD_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -141,11 +137,11 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, ADD_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -154,11 +150,11 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, ADD_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,11 +163,11 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, ADD_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -180,11 +176,11 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, ADD_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -193,11 +189,11 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, ADD_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -206,11 +202,11 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, ADD_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -219,52 +215,52 @@ TEST_F(DECODER_TEST, ADD_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, ADD_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::R); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADD_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADD_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ADD_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::ADD); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ADD); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_IMM.cpp index 4330dc86..3b7412ce 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_IMM.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, AND_INSTR_R_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } diff --git a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_M.cpp index e8c9249f..150a6b2e 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_M.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, AND_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, AND_INSTR_R_M_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, AND_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, AND_INSTR_R_M_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, AND_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, AND_INSTR_R_M_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, AND_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, AND_INSTR_R_M_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } diff --git a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_R.cpp index 4c4d1c5b..8fe32cbf 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_R.cpp @@ -1,95 +1,91 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, AND_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::AND); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, AND_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::AND); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, AND_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::AND); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, AND_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::AND); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_RM.cpp index cd125b20..c2680e7c 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDInstr/R_RM.cpp @@ -1,97 +1,93 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, AND_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::AND); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, AND_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::AND); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, AND_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::AND); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, AND_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::AND); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp index 9ef3c183..7f37f6ff 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,115 +7,115 @@ #endif TEST_F(DECODER_TEST, AND_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, AND_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, AND_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, AND_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, AND_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, AND_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, AND_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, AND_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, AND_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -128,11 +124,11 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, AND_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -141,11 +137,11 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, AND_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -154,11 +150,11 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, AND_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,11 +163,11 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, AND_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -180,11 +176,11 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, AND_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -193,11 +189,11 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, AND_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -206,11 +202,11 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, AND_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -219,52 +215,52 @@ TEST_F(DECODER_TEST, AND_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, AND_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::R); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, AND_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, AND_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, AND_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::AND); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::AND); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_IMM.cpp index f4f347cd..789a0d41 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_IMM.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } diff --git a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_M.cpp index ceb70f0e..143b5b9c 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_M.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, ANDN_INSTR_R_M_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } diff --git a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_R.cpp index b53f6303..10d5dd2f 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_R.cpp @@ -1,95 +1,91 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ANDN_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ANDN); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ANDN_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ANDN); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ANDN_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ANDN); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ANDN_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ANDN); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_RM.cpp index 5fc836c8..e6ae3f31 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/R_RM.cpp @@ -1,97 +1,93 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ANDN_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ANDN); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ANDN_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ANDN); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ANDN_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ANDN); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, ANDN_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::ANDN); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp index fc89f117..e31f6089 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,115 +7,115 @@ #endif TEST_F(DECODER_TEST, ANDN_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ANDN_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ANDN_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ANDN_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ANDN_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ANDN_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ANDN_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ANDN_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ANDN_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -128,11 +124,11 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, ANDN_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -141,11 +137,11 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, ANDN_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -154,11 +150,11 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, ANDN_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,11 +163,11 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, ANDN_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -180,11 +176,11 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, ANDN_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -193,11 +189,11 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, ANDN_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -206,11 +202,11 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, ANDN_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -219,52 +215,52 @@ TEST_F(DECODER_TEST, ANDN_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, ANDN_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::R); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ANDN_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ANDN_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, ANDN_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::ANDN); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::ANDN); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/R.cpp b/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/R.cpp index d541e58b..2048a6c0 100644 --- a/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/R.cpp @@ -1,89 +1,85 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, BSWAP_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::BSWAP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } TEST_F(DECODER_TEST, BSWAP_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::BSWAP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } TEST_F(DECODER_TEST, BSWAP_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::BSWAP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } TEST_F(DECODER_TEST, BSWAP_INSTR_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::BSWAP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } diff --git a/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp index 66342711..ccd81fc1 100644 --- a/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, BSWAP_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, BSWAP_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, BSWAP_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, BSWAP_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_M_B64) { TEST_F(DECODER_TEST, BSWAP_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, BSWAP_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, BSWAP_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, BSWAP_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, BSWAP_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, BSWAP_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, BSWAP_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, BSWAP_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, BSWAP_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, BSWAP_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, BSWAP_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, BSWAP_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,39 +421,39 @@ TEST_F(DECODER_TEST, BSWAP_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, BSWAP_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, BSWAP_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::BSWAP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::BSWAP); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_imm.cpp index a011d785..be76fa77 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_imm.cpp @@ -1,13 +1,9 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CALLE_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; diff --git a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_r.cpp index b43d0f04..12eafd0f 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_r.cpp @@ -1,17 +1,13 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CALLE_INSTR_R) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); diff --git a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp index 115eab63..81328e8a 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, CALLE_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, CALLE_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, CALLE_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, CALLE_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_M_B64) { TEST_F(DECODER_TEST, CALLE_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, CALLE_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, CALLE_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, CALLE_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, CALLE_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, CALLE_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, CALLE_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, CALLE_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, CALLE_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, CALLE_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, CALLE_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, CALLE_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, CALLE_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,65 +421,65 @@ TEST_F(DECODER_TEST, CALLE_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, CALLE_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLE_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLE); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_imm.cpp index 9994cbce..254ed4f7 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_imm.cpp @@ -1,13 +1,9 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CALLGR_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; diff --git a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_r.cpp index 0d1c84e8..9d50ad8f 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_r.cpp @@ -1,17 +1,13 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CALLGR_INSTR_R) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +16,3 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); } -} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp index db9493b6..bfd1de82 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, CALLGR_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, CALLGR_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, CALLGR_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, CALLGR_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_M_B64) { TEST_F(DECODER_TEST, CALLGR_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, CALLGR_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, CALLGR_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, CALLGR_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, CALLGR_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, CALLGR_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, CALLGR_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, CALLGR_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, CALLGR_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, CALLGR_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, CALLGR_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, CALLGR_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,65 +421,65 @@ TEST_F(DECODER_TEST, CALLGR_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, CALLGR_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLGR_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLGR); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_imm.cpp index 42a5d5e8..e7f67323 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_imm.cpp @@ -1,13 +1,9 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CALL_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -21,4 +17,3 @@ TEST_F(DECODER_TEST, CALL_INSTR_IMM) { memcpy(&mem_ptr, &instr.m_op1, sizeof(std::uint64_t)); ASSERT_EQ(mem_ptr, MEM_PTR); } -} diff --git a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_r.cpp index 26a5e26a..eb1e7ce5 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_r.cpp @@ -1,17 +1,13 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CALL_INSTR_R) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); diff --git a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp index 62b673ba..0dda4486 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, CALL_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, CALL_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, CALL_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, CALL_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_M_B64) { TEST_F(DECODER_TEST, CALL_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, CALL_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, CALL_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, CALL_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, CALL_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, CALL_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, CALL_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, CALL_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, CALL_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, CALL_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, CALL_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, CALL_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, CALL_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,65 +421,65 @@ TEST_F(DECODER_TEST, CALL_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, CALL_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALL_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::CALL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALL); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_imm.cpp index 0e84a303..a1088c7b 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_imm.cpp @@ -1,13 +1,9 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CALLL_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; diff --git a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_r.cpp index cf406431..8c60ced2 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_r.cpp @@ -1,17 +1,13 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CALLL_INSTR_R) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); diff --git a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp index c187018c..6904c94d 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, CALLL_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, CALLL_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, CALLL_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, CALLL_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_M_B64) { TEST_F(DECODER_TEST, CALLL_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, CALLL_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, CALLL_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, CALLL_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, CALLL_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, CALLL_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, CALLL_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, CALLL_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, CALLL_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, CALLL_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, CALLL_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, CALLL_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, CALLL_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,65 +421,65 @@ TEST_F(DECODER_TEST, CALLL_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, CALLL_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CALLL_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::CALLL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CALLL); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_none.cpp b/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_none.cpp index 726d51ff..e5e38717 100644 --- a/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_none.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_none.cpp @@ -1,11 +1,7 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CCRF_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); counter = 0; diff --git a/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp index 060794ea..d2ffdc91 100644 --- a/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, CCRF_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, CCRF_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, CCRF_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, CCRF_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_M_B64) { TEST_F(DECODER_TEST, CCRF_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, CCRF_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, CCRF_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, CCRF_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, CCRF_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, CCRF_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, CCRF_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, CCRF_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, CCRF_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, CCRF_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, CCRF_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, CCRF_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, CCRF_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,120 +421,118 @@ TEST_F(DECODER_TEST, CCRF_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, CCRF_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CCRF_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::CCRF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CCRF); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } -XIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/M_R.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/M_R.cpp index 0af2e858..be3a58d3 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/M_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/M_R.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CMP_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg2; + HyperCPU::Reg reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -23,22 +19,22 @@ TEST_F(DECODER_TEST, CMP_INSTR_M_R_B8) { ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::M_R); memcpy(&mem_ptr, &instr.m_op1, sizeof(std::size_t)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); ASSERT_EQ(mem_ptr, MEM_PTR); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, CMP_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg2; + HyperCPU::Reg reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -47,22 +43,22 @@ TEST_F(DECODER_TEST, CMP_INSTR_M_R_B16) { ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::M_R); memcpy(&mem_ptr, &instr.m_op1, sizeof(std::size_t)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); ASSERT_EQ(mem_ptr, MEM_PTR); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, CMP_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg2; + HyperCPU::Reg reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -71,22 +67,22 @@ TEST_F(DECODER_TEST, CMP_INSTR_M_R_B32) { ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::M_R); memcpy(&mem_ptr, &instr.m_op1, sizeof(std::size_t)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); ASSERT_EQ(mem_ptr, MEM_PTR); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, CMP_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg2; + HyperCPU::Reg reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -95,7 +91,7 @@ TEST_F(DECODER_TEST, CMP_INSTR_M_R_B64) { ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::M_R); memcpy(&mem_ptr, &instr.m_op1, sizeof(std::size_t)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); ASSERT_EQ(mem_ptr, MEM_PTR); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_IMM.cpp index b06e382d..9a082fce 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_IMM.cpp @@ -1,21 +1,16 @@ -#include "Core/CPU/Instructions/Opcodes.hpp" -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -23,23 +18,23 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -47,23 +42,23 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -71,23 +66,23 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -95,8 +90,8 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_M.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_M.cpp index ec247ba1..4385ace3 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_M.cpp @@ -1,21 +1,16 @@ -#include "Core/CPU/Instructions/Opcodes.hpp" -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -23,23 +18,23 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -47,23 +42,23 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -71,23 +66,23 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -95,10 +90,8 @@ TEST_F(DECODER_TEST, CMP_INSTR_RM_M_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } -PTR); -} diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_R.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_R.cpp index c450d68f..e9eb63f2 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_R.cpp @@ -1,100 +1,93 @@ -#include "Core/CPU/Instructions/Opcodes.hpp" -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CMP_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, CMP_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, CMP_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, CMP_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} -:X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_IMM.cpp index 8f1baf41..50c50f5e 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_IMM.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CMP_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, CMP_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, CMP_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, CMP_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_M.cpp index 3bdacd84..6dd431e1 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_M.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CMP_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_M_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, CMP_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_M_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, CMP_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_M_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, CMP_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, CMP_INSTR_R_M_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_R.cpp index ac6cfbcc..90c32118 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_R.cpp @@ -1,96 +1,91 @@ -#include "Core/CPU/Instructions/Opcodes.hpp" -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CMP_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, CMP_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, CMP_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, CMP_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_RM.cpp index e81929ef..7d17ee26 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/R_RM.cpp @@ -1,97 +1,93 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CMP_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, CMP_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, CMP_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, CMP_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::CMP); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp index 90a9f4fd..b64d5791 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp @@ -1,9 +1,4 @@ -#include "Core/CPU/Instructions/Opcodes.hpp" -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -12,52 +7,52 @@ #endif TEST_F(DECODER_TEST, CMP_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::R); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CMP_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CMP_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CMP_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::CMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CMP); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_none.cpp b/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_none.cpp index 98c79f98..bb78faaa 100644 --- a/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_none.cpp +++ b/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_none.cpp @@ -1,11 +1,7 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, COVF_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); counter = 0; @@ -15,4 +11,3 @@ TEST_F(DECODER_TEST, COVF_INSTR_NONE) { ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::COVF); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::NONE); } -} diff --git a/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp index c8b8098b..a24c6919 100644 --- a/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, COVF_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, COVF_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, COVF_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, COVF_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_M_B64) { TEST_F(DECODER_TEST, COVF_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, COVF_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, COVF_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, COVF_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, COVF_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, COVF_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, COVF_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, COVF_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, COVF_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, COVF_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, COVF_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, COVF_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, COVF_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,117 +421,117 @@ TEST_F(DECODER_TEST, COVF_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, COVF_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, COVF_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::COVF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::COVF); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/CUDFInstr/None.cpp b/tests/Modular/EmulatorCore/Decoding/CUDFInstr/None.cpp index b34b3533..4f97cb5f 100644 --- a/tests/Modular/EmulatorCore/Decoding/CUDFInstr/None.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CUDFInstr/None.cpp @@ -1,11 +1,7 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, CUDF_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); counter = 0; diff --git a/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp index e671a18c..de1efe99 100644 --- a/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, CUDF_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, CUDF_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, CUDF_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, CUDF_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_M_B64) { TEST_F(DECODER_TEST, CUDF_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, CUDF_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, CUDF_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, CUDF_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, CUDF_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, CUDF_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, CUDF_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, CUDF_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, CUDF_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, CUDF_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, CUDF_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, CUDF_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, CUDF_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,120 +421,118 @@ TEST_F(DECODER_TEST, CUDF_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, CUDF_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, CUDF_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::CUDF); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::CUDF); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } -XIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); -} diff --git a/tests/Modular/EmulatorCore/Decoding/DECInstr/R.cpp b/tests/Modular/EmulatorCore/Decoding/DECInstr/R.cpp index 14865aaa..99de76c8 100644 --- a/tests/Modular/EmulatorCore/Decoding/DECInstr/R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DECInstr/R.cpp @@ -1,89 +1,85 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, DEC_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::DEC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } TEST_F(DECODER_TEST, DEC_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::DEC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } TEST_F(DECODER_TEST, DEC_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::DEC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } TEST_F(DECODER_TEST, DEC_INSTR_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::DEC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } diff --git a/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp index 981cf89f..fb2fabf0 100644 --- a/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, DEC_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, DEC_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, DEC_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, DEC_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_M_B64) { TEST_F(DECODER_TEST, DEC_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, DEC_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, DEC_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, DEC_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, DEC_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, DEC_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, DEC_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, DEC_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, DEC_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, DEC_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, DEC_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, DEC_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, DEC_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,39 +421,39 @@ TEST_F(DECODER_TEST, DEC_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, DEC_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DEC_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::DEC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DEC); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/DIVInstr/R.cpp b/tests/Modular/EmulatorCore/Decoding/DIVInstr/R.cpp index 80743c2c..1a490561 100644 --- a/tests/Modular/EmulatorCore/Decoding/DIVInstr/R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DIVInstr/R.cpp @@ -1,89 +1,85 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, DIV_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::DIV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } TEST_F(DECODER_TEST, DIV_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::DIV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } TEST_F(DECODER_TEST, DIV_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::DIV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } TEST_F(DECODER_TEST, DIV_INSTR_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::DIV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } diff --git a/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp index 9ce1955c..b60aa5b9 100644 --- a/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,9 +7,9 @@ #endif TEST_F(DECODER_TEST, DIV_INSTR_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -22,9 +18,9 @@ TEST_F(DECODER_TEST, DIV_INSTR_IMM_B8) { } TEST_F(DECODER_TEST, DIV_INSTR_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -33,9 +29,9 @@ TEST_F(DECODER_TEST, DIV_INSTR_IMM_B16) { } TEST_F(DECODER_TEST, DIV_INSTR_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -44,9 +40,9 @@ TEST_F(DECODER_TEST, DIV_INSTR_IMM_B32) { } TEST_F(DECODER_TEST, DIV_INSTR_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -55,113 +51,113 @@ TEST_F(DECODER_TEST, DIV_INSTR_IMM_B64) { } TEST_F(DECODER_TEST, DIV_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -170,11 +166,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, DIV_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -183,11 +179,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, DIV_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -196,11 +192,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, DIV_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -211,9 +207,9 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_M_B64) { TEST_F(DECODER_TEST, DIV_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -222,11 +218,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, DIV_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -235,11 +231,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, DIV_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -248,11 +244,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, DIV_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -261,115 +257,115 @@ TEST_F(DECODER_TEST, DIV_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, DIV_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -378,11 +374,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, DIV_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -391,11 +387,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, DIV_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -404,11 +400,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, DIV_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -417,11 +413,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, DIV_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -430,11 +426,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, DIV_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -443,11 +439,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, DIV_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -456,11 +452,11 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, DIV_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -469,26 +465,26 @@ TEST_F(DECODER_TEST, DIV_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, DIV_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, DIV_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::DIV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::DIV); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/Features/AddressAddition.cpp b/tests/Modular/EmulatorCore/Decoding/Features/AddressAddition.cpp index 3772acee..bc67c27a 100644 --- a/tests/Modular/EmulatorCore/Decoding/Features/AddressAddition.cpp +++ b/tests/Modular/EmulatorCore/Decoding/Features/AddressAddition.cpp @@ -1,20 +1,16 @@ -#include - -#include "pch.hpp" - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, ADDR_ADDITION_DISABLED) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -23,25 +19,25 @@ TEST_F(DECODER_TEST, ADDR_ADDITION_DISABLED) { ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_IMM); ASSERT_EQ(instr.addr_extension_status, HyperCPU::AddrExtensionStatus::Disabled); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, ADDR_ADDITION_OP1) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (0b10 << 6) | (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, (0b10 << 6) | EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; decoder.mem_controller->Load8(counter, 16); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -51,25 +47,25 @@ TEST_F(DECODER_TEST, ADDR_ADDITION_OP1) { ASSERT_EQ(instr.addr_extension_status, HyperCPU::AddrExtensionStatus::EnabledOp1); ASSERT_EQ(instr.extension, 16); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, ADDR_ADDITION_OP2) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (0b11 << 6) | (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, (0b11 << 6) | EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; decoder.mem_controller->Load8(counter, 16); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); @@ -78,8 +74,8 @@ TEST_F(DECODER_TEST, ADDR_ADDITION_OP2) { ASSERT_EQ(instr.addr_extension_status, HyperCPU::AddrExtensionStatus::EnabledOp2); ASSERT_EQ(instr.extension, 16); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/HALTInstr/None.cpp b/tests/Modular/EmulatorCore/Decoding/HALTInstr/None.cpp index 0f87ce72..dbd207cd 100644 --- a/tests/Modular/EmulatorCore/Decoding/HALTInstr/None.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HALTInstr/None.cpp @@ -1,11 +1,7 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, HALT_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); counter = 0; diff --git a/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp index 9b9e15f8..4896cdea 100644 --- a/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, HALT_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, HALT_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, HALT_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, HALT_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_M_B64) { TEST_F(DECODER_TEST, HALT_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, HALT_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, HALT_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, HALT_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, HALT_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, HALT_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, HALT_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, HALT_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, HALT_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, HALT_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, HALT_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, HALT_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, HALT_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,117 +421,117 @@ TEST_F(DECODER_TEST, HALT_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, HALT_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HALT_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::HALT); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HALT); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/HIDInstr/None.cpp b/tests/Modular/EmulatorCore/Decoding/HIDInstr/None.cpp index e4de2a8d..8b1502bb 100644 --- a/tests/Modular/EmulatorCore/Decoding/HIDInstr/None.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HIDInstr/None.cpp @@ -1,11 +1,7 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, HID_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); counter = 0; diff --git a/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp index 43a5f98c..020d6dac 100644 --- a/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, HID_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, HID_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, HID_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, HID_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, HID_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, HID_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, HID_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, HID_INSTR_R_M_B64) { TEST_F(DECODER_TEST, HID_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, HID_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, HID_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, HID_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, HID_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, HID_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, HID_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, HID_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, HID_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, HID_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, HID_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, HID_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, HID_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, HID_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, HID_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, HID_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,117 +421,117 @@ TEST_F(DECODER_TEST, HID_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, HID_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, HID_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::HID); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::HID); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/INCInstr/R.cpp b/tests/Modular/EmulatorCore/Decoding/INCInstr/R.cpp index 6fcde901..eb776f9a 100644 --- a/tests/Modular/EmulatorCore/Decoding/INCInstr/R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/INCInstr/R.cpp @@ -1,89 +1,85 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, INC_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::INC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } TEST_F(DECODER_TEST, INC_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::INC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } TEST_F(DECODER_TEST, INC_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::INC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } TEST_F(DECODER_TEST, INC_INSTR_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::INC); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); } diff --git a/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp index 045a4203..11a2a8ae 100644 --- a/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, INC_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, INC_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, INC_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, INC_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, INC_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, INC_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, INC_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, INC_INSTR_R_M_B64) { TEST_F(DECODER_TEST, INC_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, INC_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, INC_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, INC_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, INC_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, INC_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, INC_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, INC_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, INC_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, INC_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, INC_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, INC_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, INC_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, INC_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, INC_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, INC_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,39 +421,39 @@ TEST_F(DECODER_TEST, INC_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, INC_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, INC_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::INC); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::INC); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_imm.cpp index 890234db..9de36623 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_imm.cpp @@ -1,13 +1,9 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, JME_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; diff --git a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_r.cpp index 0d0669c9..aee5c2c2 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_r.cpp @@ -1,17 +1,13 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, JME_INSTR_R) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); diff --git a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp index c24a3f9d..27560a2c 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, JME_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, JME_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, JME_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, JME_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, JME_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, JME_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, JME_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, JME_INSTR_R_M_B64) { TEST_F(DECODER_TEST, JME_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, JME_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, JME_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, JME_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, JME_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, JME_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, JME_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, JME_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, JME_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, JME_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, JME_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, JME_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, JME_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, JME_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, JME_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, JME_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,65 +421,65 @@ TEST_F(DECODER_TEST, JME_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, JME_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JME_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::JME); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JME); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_imm.cpp index 09cda145..049c36a4 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_imm.cpp @@ -1,13 +1,9 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, JMGR_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; diff --git a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_r.cpp index 64c8efa4..74302d30 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_r.cpp @@ -1,17 +1,13 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, JMGR_INSTR_R) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); diff --git a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp index 5fa19a3c..2b35d0a1 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, JMGR_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, JMGR_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, JMGR_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, JMGR_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_M_B64) { TEST_F(DECODER_TEST, JMGR_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, JMGR_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, JMGR_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, JMGR_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, JMGR_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, JMGR_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, JMGR_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, JMGR_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, JMGR_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, JMGR_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, JMGR_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, JMGR_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, JMGR_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,65 +421,65 @@ TEST_F(DECODER_TEST, JMGR_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, JMGR_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMGR_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::JMGR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMGR); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_imm.cpp index 90346e97..199d0132 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_imm.cpp @@ -1,13 +1,9 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, JML_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; diff --git a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_r.cpp index 4a23684f..6453c330 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_r.cpp @@ -1,17 +1,13 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, JML_INSTR_R) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); diff --git a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp index 483315cc..b4127c08 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, JML_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, JML_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, JML_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, JML_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, JML_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, JML_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, JML_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, JML_INSTR_R_M_B64) { TEST_F(DECODER_TEST, JML_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, JML_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, JML_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, JML_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, JML_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, JML_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, JML_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, JML_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, JML_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, JML_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, JML_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, JML_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, JML_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, JML_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, JML_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, JML_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,65 +421,65 @@ TEST_F(DECODER_TEST, JML_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, JML_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JML_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::JML); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JML); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_imm.cpp b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_imm.cpp index 97e19405..5d0b3d26 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_imm.cpp @@ -1,13 +1,9 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, JMP_INSTR_IMM) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; diff --git a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_r.cpp b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_r.cpp index 7738e71b..80024964 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_r.cpp @@ -1,17 +1,13 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, JMP_INSTR_R) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); diff --git a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp index 830b6076..320340ee 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,113 +7,113 @@ #endif TEST_F(DECODER_TEST, JMP_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -126,11 +122,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, JMP_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -139,11 +135,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, JMP_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -152,11 +148,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, JMP_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,9 +163,9 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_M_B64) { TEST_F(DECODER_TEST, JMP_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -178,11 +174,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, JMP_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -191,11 +187,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, JMP_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -204,11 +200,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, JMP_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -217,115 +213,115 @@ TEST_F(DECODER_TEST, JMP_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, JMP_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -334,11 +330,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, JMP_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -347,11 +343,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, JMP_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -360,11 +356,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, JMP_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -373,11 +369,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, JMP_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -386,11 +382,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, JMP_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -399,11 +395,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, JMP_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -412,11 +408,11 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, JMP_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -425,65 +421,65 @@ TEST_F(DECODER_TEST, JMP_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, JMP_INSTR_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, JMP_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::JMP); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::JMP); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/M_R.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/M_R.cpp index 471b426e..b20aa5ce 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/M_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/M_R.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, MOV_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg2; + HyperCPU::Reg reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -23,22 +19,22 @@ TEST_F(DECODER_TEST, MOV_INSTR_M_R_B8) { ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::M_R); memcpy(&mem_ptr, &instr.m_op1, sizeof(std::size_t)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); ASSERT_EQ(mem_ptr, MEM_PTR); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MOV_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg2; + HyperCPU::Reg reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -47,22 +43,22 @@ TEST_F(DECODER_TEST, MOV_INSTR_M_R_B16) { ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::M_R); memcpy(&mem_ptr, &instr.m_op1, sizeof(std::size_t)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); ASSERT_EQ(mem_ptr, MEM_PTR); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MOV_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg2; + HyperCPU::Reg reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -71,22 +67,22 @@ TEST_F(DECODER_TEST, MOV_INSTR_M_R_B32) { ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::M_R); memcpy(&mem_ptr, &instr.m_op1, sizeof(std::size_t)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); ASSERT_EQ(mem_ptr, MEM_PTR); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MOV_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg2; + HyperCPU::Reg reg2; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -95,7 +91,7 @@ TEST_F(DECODER_TEST, MOV_INSTR_M_R_B64) { ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::M_R); memcpy(&mem_ptr, &instr.m_op1, sizeof(std::size_t)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); ASSERT_EQ(mem_ptr, MEM_PTR); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_IMM.cpp index f7c2a967..c5b00baa 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_IMM.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_M.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_M.cpp index 8ae5fab4..380adf20 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_M.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, MOV_INSTR_RM_M_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_R.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_R.cpp index 362e56d2..2d844417 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/RM_R.cpp @@ -1,97 +1,93 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, MOV_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MOV_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MOV_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MOV_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::RM_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_IMM.cpp index 9b6dff25..302eb5c6 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_IMM.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, MOV_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, MOV_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, MOV_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, MOV_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_M.cpp index 16d5e855..b7a4da9a 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_M.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, MOV_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_M_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, MOV_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_M_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, MOV_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_M_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, MOV_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, MOV_INSTR_R_M_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_R.cpp index 0ec0b09b..9ee4acf6 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_R.cpp @@ -1,95 +1,91 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, MOV_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MOV_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MOV_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MOV_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_RM.cpp index 818d04c1..d094c098 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/R_RM.cpp @@ -1,97 +1,93 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, MOV_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MOV_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MOV_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MOV_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MOV); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp index 8c68f070..a9e9b4a8 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,52 +7,52 @@ #endif TEST_F(DECODER_TEST, MOV_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::R); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MOV_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MOV_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MOV_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::MOV); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MOV); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_IMM.cpp index 86685095..63464007 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_IMM.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,10 +90,8 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } -555); -} diff --git a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_M.cpp index bf13ec38..69ae0184 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_M.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, MUL_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_M_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, MUL_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_M_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, MUL_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_M_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, MUL_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, MUL_INSTR_R_M_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } diff --git a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_R.cpp index ffc4c3ae..35275692 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_R.cpp @@ -1,95 +1,91 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, MUL_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MUL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MUL_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MUL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MUL_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MUL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MUL_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MUL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_RM.cpp index 651d5242..ae37a57e 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_RM.cpp @@ -1,99 +1,93 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, MUL_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MUL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MUL_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MUL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MUL_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MUL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, MUL_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::MUL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); -} -:X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp index 493ea1c1..a3d8e0b5 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,115 +7,115 @@ #endif TEST_F(DECODER_TEST, MUL_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MUL_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MUL_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MUL_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MUL_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MUL_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MUL_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MUL_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MUL_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -128,11 +124,11 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, MUL_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -141,11 +137,11 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, MUL_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -154,11 +150,11 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, MUL_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,11 +163,11 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, MUL_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -180,11 +176,11 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, MUL_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -193,11 +189,11 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, MUL_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -206,11 +202,11 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, MUL_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -219,55 +215,53 @@ TEST_F(DECODER_TEST, MUL_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, MUL_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::R); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MUL_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MUL_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, MUL_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::MUL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::MUL); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } -xitedWithCode(1), "Invalid opcode!"); -} diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_IMM.cpp index 58aef598..408d0231 100644 --- a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_IMM.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,10 +90,8 @@ TEST_F(DECODER_TEST, OR_INSTR_R_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } -555); -} diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_M.cpp index 827e1828..af1588da 100644 --- a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_M.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, OR_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, OR_INSTR_R_M_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, OR_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, OR_INSTR_R_M_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, OR_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, OR_INSTR_R_M_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, OR_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, OR_INSTR_R_M_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_R.cpp index ffe298b1..4e32833a 100644 --- a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_R.cpp @@ -1,95 +1,91 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, OR_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::OR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, OR_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::OR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, OR_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::OR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, OR_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::OR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_RM.cpp index 6dadd77e..4878d552 100644 --- a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_RM.cpp @@ -1,97 +1,93 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, OR_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::OR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, OR_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::OR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, OR_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::OR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, OR_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::OR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp index 569525e6..a7208a1d 100644 --- a/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,115 +7,115 @@ #endif TEST_F(DECODER_TEST, OR_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, OR_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, OR_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, OR_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, OR_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, OR_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, OR_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, OR_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, OR_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -128,11 +124,11 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, OR_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -141,11 +137,11 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, OR_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -154,11 +150,11 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, OR_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,11 +163,11 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, OR_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -180,11 +176,11 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, OR_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -193,11 +189,11 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, OR_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -206,11 +202,11 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, OR_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -219,52 +215,52 @@ TEST_F(DECODER_TEST, OR_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, OR_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::R); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, OR_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, OR_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, OR_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::OR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::OR); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/READInstr/IMM.cpp b/tests/Modular/EmulatorCore/Decoding/READInstr/IMM.cpp index 948fbf1b..4decf89f 100644 --- a/tests/Modular/EmulatorCore/Decoding/READInstr/IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/READInstr/IMM.cpp @@ -1,12 +1,9 @@ -#include "Core/CPU/Instructions/Registers.hpp" -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, READ_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::IMM)); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -21,11 +18,11 @@ TEST_F(DECODER_TEST, READ_INSTR_IMM) { } TEST_F(DECODER_TEST, READ_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::XLLL0); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::XLLL0); counter = 0; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -34,5 +31,5 @@ TEST_F(DECODER_TEST, READ_INSTR_R) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R); - ASSERT_EQ(HyperCPU::bit_cast_from(&instr.m_op1), HyperCPU::Registers::XLLL0); + ASSERT_EQ(HyperCPU::bit_cast_from(&instr.m_op1), HyperCPU::Reg::XLLL0); } diff --git a/tests/Modular/EmulatorCore/Decoding/READInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/READInstr/Unsupported.cpp index 200d7cce..c3c8bbdf 100644 --- a/tests/Modular/EmulatorCore/Decoding/READInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/READInstr/Unsupported.cpp @@ -1,5 +1,4 @@ -#include - +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) #else @@ -7,11 +6,11 @@ #endif TEST_F(DECODER_TEST, READ_INSTR_R_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -20,11 +19,11 @@ TEST_F(DECODER_TEST, READ_INSTR_R_IMM_B8) { } TEST_F(DECODER_TEST, READ_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -33,11 +32,11 @@ TEST_F(DECODER_TEST, READ_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, READ_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -46,11 +45,11 @@ TEST_F(DECODER_TEST, READ_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, READ_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -59,63 +58,63 @@ TEST_F(DECODER_TEST, READ_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, READ_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -124,11 +123,11 @@ TEST_F(DECODER_TEST, READ_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, READ_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -137,11 +136,11 @@ TEST_F(DECODER_TEST, READ_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, READ_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -150,11 +149,11 @@ TEST_F(DECODER_TEST, READ_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, READ_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -163,113 +162,113 @@ TEST_F(DECODER_TEST, READ_INSTR_R_M_B64) { } TEST_F(DECODER_TEST, READ_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -278,11 +277,11 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, READ_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -291,11 +290,11 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, READ_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -304,11 +303,11 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, READ_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -317,11 +316,11 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, READ_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -330,11 +329,11 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, READ_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -343,11 +342,11 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, READ_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -356,11 +355,11 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, READ_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -369,78 +368,78 @@ TEST_F(DECODER_TEST, READ_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, READ_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, READ_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::READ); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_IMM.cpp index 72108d19..d63d1ef5 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_IMM.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } diff --git a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_R.cpp index 5a5a2b3c..6ec23cc7 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/R_R.cpp @@ -1,95 +1,91 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, SHFL_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SHFL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, SHFL_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SHFL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, SHFL_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SHFL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, SHFL_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SHFL); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp index 97298360..db0d929f 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,11 +7,11 @@ #endif TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -24,11 +20,11 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -37,11 +33,11 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -50,11 +46,11 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -63,115 +59,115 @@ TEST_F(DECODER_TEST, SHFL_INSTR_R_M_B64) { } TEST_F(DECODER_TEST, SHFL_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFL_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFL_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFL_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFL_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFL_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFL_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFL_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFL_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -180,11 +176,11 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, SHFL_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -193,11 +189,11 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, SHFL_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -206,11 +202,11 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, SHFL_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -219,11 +215,11 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, SHFL_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -232,11 +228,11 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, SHFL_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -245,11 +241,11 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, SHFL_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -258,11 +254,11 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, SHFL_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -271,52 +267,52 @@ TEST_F(DECODER_TEST, SHFL_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, SHFL_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::R); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFL_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFL_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFL_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFL); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFL); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_IMM.cpp index b178c2cc..65366534 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_IMM.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } diff --git a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_R.cpp index b5f73a5a..7d9458df 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/R_R.cpp @@ -1,95 +1,91 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, SHFR_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SHFR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, SHFR_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SHFR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, SHFR_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SHFR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, SHFR_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SHFR); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp index a7b129d7..aba3f4ca 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,11 +7,11 @@ #endif TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -24,11 +20,11 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -37,11 +33,11 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -50,11 +46,11 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -63,115 +59,115 @@ TEST_F(DECODER_TEST, SHFR_INSTR_R_M_B64) { } TEST_F(DECODER_TEST, SHFR_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFR_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFR_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFR_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFR_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFR_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFR_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFR_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFR_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -180,11 +176,11 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, SHFR_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -193,11 +189,11 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, SHFR_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -206,11 +202,11 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, SHFR_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -219,11 +215,11 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, SHFR_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -232,11 +228,11 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, SHFR_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -245,11 +241,11 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, SHFR_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -258,11 +254,11 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, SHFR_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -271,55 +267,53 @@ TEST_F(DECODER_TEST, SHFR_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, SHFR_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::R); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFR_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFR_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SHFR_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::SHFR); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SHFR); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } -sting::ExitedWithCode(1), "Invalid opcode!"); -} diff --git a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_IMM.cpp index a9747cb5..01ea83a3 100644 --- a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_IMM.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint8_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint8_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55); } TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint16_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint16_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555); } TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint32_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint32_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x55555555); } TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::uint64_t data; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_IMM_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_IMM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&data, &instr.m_op2, sizeof(std::uint64_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(data, 0x5555555555555555); } diff --git a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_M.cpp index 12e51e1f..25fbc85a 100644 --- a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_M.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_M.cpp @@ -1,20 +1,16 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, SUB_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -22,23 +18,23 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_M_B8) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, SUB_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -46,23 +42,23 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_M_B16) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, SUB_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -70,23 +66,23 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_M_B32) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } TEST_F(DECODER_TEST, SUB_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; - HyperCPU::Registers reg1; + HyperCPU::Reg reg1; std::size_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -94,8 +90,8 @@ TEST_F(DECODER_TEST, SUB_INSTR_R_M_B64) { ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_M); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); memcpy(&mem_ptr, &instr.m_op2, sizeof(std::size_t)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); ASSERT_EQ(mem_ptr, MEM_PTR); } diff --git a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_R.cpp index 58d8320c..fffab53f 100644 --- a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_R.cpp @@ -1,95 +1,91 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, SUB_INSTR_R_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 3; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SUB); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, SUB_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SUB); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, SUB_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SUB); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, SUB_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SUB); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_RM.cpp b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_RM.cpp index 3f2952cf..c8013301 100644 --- a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_RM.cpp @@ -1,97 +1,93 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, SUB_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SUB); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, SUB_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SUB); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b16); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, SUB_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SUB); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b32); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } TEST_F(DECODER_TEST, SUB_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; - HyperCPU::Registers reg1, reg2; + HyperCPU::Reg reg1, reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::SUB); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b64); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_RM); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X7); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X7); } diff --git a/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp index 6b96d723..c2b466eb 100644 --- a/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp @@ -1,8 +1,4 @@ -#include "pch.hpp" - -#include - -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -11,115 +7,115 @@ #endif TEST_F(DECODER_TEST, SUB_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SUB_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SUB_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SUB_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SUB_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SUB_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SUB_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SUB_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SUB_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -128,11 +124,11 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, SUB_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -141,11 +137,11 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, SUB_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -154,11 +150,11 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, SUB_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -167,11 +163,11 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, SUB_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -180,11 +176,11 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, SUB_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -193,11 +189,11 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, SUB_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -206,11 +202,11 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, SUB_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -219,52 +215,52 @@ TEST_F(DECODER_TEST, SUB_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, SUB_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::R); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SUB_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SUB_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, SUB_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::SUB); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::SUB); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); diff --git a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp index 391de023..54c46be5 100644 --- a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp @@ -3,7 +3,7 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_IMM)); ++counter; decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; diff --git a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_R.cpp index 21ab0327..d9e5cc33 100644 --- a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_R.cpp @@ -1,26 +1,25 @@ -#include "Core/CPU/Instructions/Registers.hpp" -#include +#include "tests/fixtures.hpp" TEST_F(DECODER_TEST, WRITE_INSTR_R_R_B8) { decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X1); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X1); counter = 0; - HyperCPU::Registers reg1; - HyperCPU::Registers reg2; + HyperCPU::Reg reg1; + HyperCPU::Reg reg2; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::WRITE); ASSERT_EQ(instr.m_opcode_mode, HyperCPU::Mode::b8); ASSERT_EQ(instr.m_op_types, HyperCPU::OperandTypes::R_R); - memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Registers)); - memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Registers)); - ASSERT_EQ(reg1, HyperCPU::Registers::X3); - ASSERT_EQ(reg2, HyperCPU::Registers::X1); + memcpy(®1, &instr.m_op1, sizeof(HyperCPU::Reg)); + memcpy(®2, &instr.m_op2, sizeof(HyperCPU::Reg)); + ASSERT_EQ(reg1, HyperCPU::Reg::X3); + ASSERT_EQ(reg2, HyperCPU::Reg::X1); } diff --git a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/Unsupported.cpp b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/Unsupported.cpp index 65fdcbd4..d0ac7039 100644 --- a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/Unsupported.cpp @@ -1,4 +1,4 @@ -#include +#include "tests/fixtures.hpp" #ifdef __HCPU_DEBUG #define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) @@ -7,11 +7,11 @@ #endif TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -20,11 +20,11 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B16) { } TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -33,11 +33,11 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B32) { } TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -46,63 +46,63 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_IMM_B64) { } TEST_F(DECODER_TEST, WRITE_INSTR_M_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_M_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_M_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_M_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::M_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::M_R)); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter += 8; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_R_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -111,11 +111,11 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_M_B8) { } TEST_F(DECODER_TEST, WRITE_INSTR_R_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -124,11 +124,11 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_M_B16) { } TEST_F(DECODER_TEST, WRITE_INSTR_R_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -137,11 +137,11 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_M_B32) { } TEST_F(DECODER_TEST, WRITE_INSTR_R_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -150,102 +150,102 @@ TEST_F(DECODER_TEST, WRITE_INSTR_R_M_B64) { } TEST_F(DECODER_TEST, WRITE_INSTR_R_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_R_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_R_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_R_RM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_R_RM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_R_RM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_R_RM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::R_RM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::R_RM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_RM_IMM_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load8(counter, 0x55); counter = 0; @@ -254,11 +254,11 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_IMM_B8) { } TEST_F(DECODER_TEST, WRITE_INSTR_RM_IMM_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load16(counter, 0x5555); counter = 0; @@ -267,11 +267,11 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_IMM_B16) { } TEST_F(DECODER_TEST, WRITE_INSTR_RM_IMM_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load32(counter, 0x55555555); counter = 0; @@ -280,11 +280,11 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_IMM_B32) { } TEST_F(DECODER_TEST, WRITE_INSTR_RM_IMM_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_IMM); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_IMM)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, 0x5555555555555555); counter = 0; @@ -293,11 +293,11 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_IMM_B64) { } TEST_F(DECODER_TEST, WRITE_INSTR_RM_M_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -306,11 +306,11 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_M_B8) { } TEST_F(DECODER_TEST, WRITE_INSTR_RM_M_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -319,11 +319,11 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_M_B16) { } TEST_F(DECODER_TEST, WRITE_INSTR_RM_M_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -332,11 +332,11 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_M_B32) { } TEST_F(DECODER_TEST, WRITE_INSTR_RM_M_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_M); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_M)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; decoder.mem_controller->Load64(counter, MEM_PTR); counter = 0; @@ -345,104 +345,104 @@ TEST_F(DECODER_TEST, WRITE_INSTR_RM_M_B64) { } TEST_F(DECODER_TEST, WRITE_INSTR_RM_R_B8) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b8, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_RM_R_B16) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b16 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b16, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_RM_R_B32) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b32 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b32, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_RM_R_B64) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; - decoder.mem_controller->Load8(counter, (HyperCPU::Mode::b64 << 4) | HyperCPU::OperandTypes::RM_R); + decoder.mem_controller->Load8(counter, EncodeTestFlags(HyperCPU::Mode::b64, HyperCPU::OperandTypes::RM_R)); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_R) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::R); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_M) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::M); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_IMM) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::IMM); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } TEST_F(DECODER_TEST, WRITE_INSTR_NONE) { - decoder.mem_controller->Load16(counter, HyperCPU::WRITE); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::WRITE); counter += 2; decoder.mem_controller->Load8(counter, HyperCPU::OperandTypes::NONE); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X3); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X3); ++counter; - decoder.mem_controller->Load8(counter, HyperCPU::Registers::X7); + decoder.mem_controller->Load8(counter, HyperCPU::Reg::X7); counter = 0; HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); From 536e18764287dd75cdadfe2aa15a689b120de7c2 Mon Sep 17 00:00:00 2001 From: HyperWinX Date: Sun, 11 May 2025 19:00:39 +0400 Subject: [PATCH 31/40] Fix all warnings --- src/Assembler/Core/BinaryTransformer.cpp | 98 ++++++++------- src/Assembler/Core/Compiler.cpp | 116 +++++++++++------- .../Core/CPU/InstructionsImpl/DIV.cpp | 2 +- 3 files changed, 126 insertions(+), 90 deletions(-) diff --git a/src/Assembler/Core/BinaryTransformer.cpp b/src/Assembler/Core/BinaryTransformer.cpp index 2cd90be7..f27fdd11 100644 --- a/src/Assembler/Core/BinaryTransformer.cpp +++ b/src/Assembler/Core/BinaryTransformer.cpp @@ -4,55 +4,59 @@ #include "Assembler/Core/Compiler.hpp" #include "Common/LanguageSpec/Flags.hpp" #include "Common/LanguageSpec/Opcodes.hpp" +#include "Common/Exit.hpp" #include "PCH/CStd.hpp" -#include "Pog/Pog.hpp" HyperCPU::OperandTypes HCAsm::BinaryTransformer::DetermineOperandTypes(Operand& op1, Operand& op2) { - Op1T tp1; - Op2T tp2; + Op1T tp1 = Op1T::NONE; // Placeholder + Op2T tp2 = Op2T::NONE; // Placeholder switch (op1.type) { - case HCAsm::OperandType::reg: - tp1 = Op1T::R; - break; - case HCAsm::OperandType::mem_reg_add_int: - case HCAsm::OperandType::memaddr_reg: - tp1 = Op1T::RM; - break; - case HCAsm::OperandType::sint: - case HCAsm::OperandType::uint: - case HCAsm::OperandType::label: - tp1 = Op1T::IMM; - break; - case HCAsm::OperandType::memaddr_int: - case HCAsm::OperandType::memaddr_lbl: - tp1 = Op1T::M; - break; - case HCAsm::OperandType::none: - tp1 = Op1T::NONE; - break; + case HCAsm::OperandType::reg: + tp1 = Op1T::R; + break; + case HCAsm::OperandType::mem_reg_add_int: + case HCAsm::OperandType::memaddr_reg: + tp1 = Op1T::RM; + break; + case HCAsm::OperandType::sint: + case HCAsm::OperandType::uint: + case HCAsm::OperandType::label: + tp1 = Op1T::IMM; + break; + case HCAsm::OperandType::memaddr_int: + case HCAsm::OperandType::memaddr_lbl: + tp1 = Op1T::M; + break; + case HCAsm::OperandType::none: + tp1 = Op1T::NONE; + break; + default: + HyperCPU::unreachable(); } switch (op2.type) { - case HCAsm::OperandType::reg: - tp2 = Op2T::R; - break; - case HCAsm::OperandType::mem_reg_add_int: - case HCAsm::OperandType::memaddr_reg: - tp2 = Op2T::RM; - break; - case HCAsm::OperandType::sint: - case HCAsm::OperandType::uint: - case HCAsm::OperandType::label: - tp2 = Op2T::IMM; - break; - case HCAsm::OperandType::memaddr_int: - case HCAsm::OperandType::memaddr_lbl: - tp2 = Op2T::M; - break; - case HCAsm::OperandType::none: - tp2 = Op2T::NONE; - break; + case HCAsm::OperandType::reg: + tp2 = Op2T::R; + break; + case HCAsm::OperandType::mem_reg_add_int: + case HCAsm::OperandType::memaddr_reg: + tp2 = Op2T::RM; + break; + case HCAsm::OperandType::sint: + case HCAsm::OperandType::uint: + case HCAsm::OperandType::label: + tp2 = Op2T::IMM; + break; + case HCAsm::OperandType::memaddr_int: + case HCAsm::OperandType::memaddr_lbl: + tp2 = Op2T::M; + break; + case HCAsm::OperandType::none: + tp2 = Op2T::NONE; + break; + default: + HyperCPU::unreachable(); } return QuickCast(QuickOR(tp1, tp2)); @@ -103,7 +107,7 @@ void HCAsm::BinaryTransformer::EncodeInstruction(HCAsm::Instruction& instr) { break; } - HCAsm::Mode md; + HCAsm::Mode md = HCAsm::Mode::b8; // Placeholder switch (types) { case HyperCPU::OperandTypes::RM_M: if (instr.op2.mode != HCAsm::Mode::none) { @@ -138,6 +142,8 @@ void HCAsm::BinaryTransformer::EncodeInstruction(HCAsm::Instruction& instr) { case HyperCPU::OperandTypes::NONE: md = HCAsm::Mode::b8; // Placeholder break; + default: + HyperCPU::unreachable(); } encoded_operands |= (static_cast(md) << 4); @@ -174,6 +180,8 @@ void HCAsm::BinaryTransformer::EncodeInstruction(HCAsm::Instruction& instr) { case HCAsm::Mode::b64: res.push(static_cast(std::get(instr.op2.variant))); break; + default: + HyperCPU::unreachable(); } } else { switch (md) { @@ -189,6 +197,8 @@ void HCAsm::BinaryTransformer::EncodeInstruction(HCAsm::Instruction& instr) { case HCAsm::Mode::b64: res.push(static_cast(std::get(instr.op2.variant))); break; + default: + HyperCPU::unreachable(); } } break; @@ -213,6 +223,8 @@ void HCAsm::BinaryTransformer::EncodeInstruction(HCAsm::Instruction& instr) { case HCAsm::Mode::b64: res.push(static_cast(std::get(instr.op1.variant))); break; + default: + HyperCPU::unreachable(); } } else { switch (md) { @@ -228,6 +240,8 @@ void HCAsm::BinaryTransformer::EncodeInstruction(HCAsm::Instruction& instr) { case HCAsm::Mode::b64: res.push(static_cast(std::get(instr.op1.variant))); break; + default: + HyperCPU::unreachable(); } } break; diff --git a/src/Assembler/Core/Compiler.cpp b/src/Assembler/Core/Compiler.cpp index 6344c88d..e08c1ae4 100644 --- a/src/Assembler/Core/Compiler.cpp +++ b/src/Assembler/Core/Compiler.cpp @@ -4,7 +4,6 @@ #include "Assembler/Core/Compiler.hpp" #include "Common/Helpers/Classes.hpp" #include "Common/Exit.hpp" -#include "Common/LanguageSpec/Flags.hpp" #include "PCH/CStd.hpp" #include "Pog/Pog.hpp" @@ -245,6 +244,8 @@ std::uint8_t HCAsm::HCAsmCompiler::InstructionSize(HCAsm::Instruction& instr) { case OperandType::none: // R result += 1; break; + default: + HyperCPU::unreachable(); } break; case OperandType::mem_reg_add_int: @@ -268,6 +269,8 @@ std::uint8_t HCAsm::HCAsmCompiler::InstructionSize(HCAsm::Instruction& instr) { case OperandType::mem_reg_add_int: result += 10; break; + default: + HyperCPU::unreachable(); } break; case OperandType::sint: @@ -288,6 +291,8 @@ std::uint8_t HCAsm::HCAsmCompiler::InstructionSize(HCAsm::Instruction& instr) { case OperandType::reg: // M_R ++result; break; + default: + HyperCPU::unreachable(); } break; case OperandType::label: @@ -307,27 +312,35 @@ HCAsm::BinaryResult HCAsm::HCAsmCompiler::TransformToBinary(HCAsm::CompilerState spdlog::info("Running pass 1 - counting code size"); for (auto& instr : ir.ir) { - VisitVariant(instr, [this, &ir](Instruction& instruction) mutable -> void { ir.code_size += InstructionSize(instruction); }, [&ir](Label& label) mutable -> void { - ir.labels[label.name] = ir.code_size; - if (label.is_entry_point) { - ir.entry_point = ir.code_size; - } }, [&ir](RawValue& raw) mutable -> void { ir.code_size += [&raw]() -> std::uint8_t { - switch (raw.mode) { - case Mode::b8_str: - return std::get>(raw.value.variant)->size(); - case Mode::b8: - return 1; - case Mode::b16: - return 2; - case Mode::b32: - return 4; - case Mode::b64_label: - case Mode::b64: - return 8; - default: - std::abort(); - } - }(); }); + VisitVariant(instr, + [this, &ir](Instruction& instruction) mutable -> void { + ir.code_size += InstructionSize(instruction); + }, + [&ir](Label& label) mutable -> void { + ir.labels[label.name] = ir.code_size; + if (label.is_entry_point) { + ir.entry_point = ir.code_size; + } + }, + [&ir](RawValue& raw) mutable -> void { + ir.code_size += [&raw]() -> std::uint8_t { + switch (raw.mode) { + case Mode::b8_str: + return std::get>(raw.value.variant)->size(); + case Mode::b8: + return 1; + case Mode::b16: + return 2; + case Mode::b32: + return 4; + case Mode::b64_label: + case Mode::b64: + return 8; + default: + std::abort(); + } + }(); + }); } // Resolve references - pass 2 @@ -352,7 +365,7 @@ HCAsm::BinaryResult HCAsm::HCAsmCompiler::TransformToBinary(HCAsm::CompilerState BinaryResult binary = {new unsigned char[ir.code_size]}; if (!binary.binary) { spdlog::error("Failed to allocate memory for binary data!"); - // TODO: handle error + HyperCPU::exit(1); } spdlog::info("Running pass 3 - compiling"); @@ -360,30 +373,39 @@ HCAsm::BinaryResult HCAsm::HCAsmCompiler::TransformToBinary(HCAsm::CompilerState BinaryTransformer transformer(binary, &ir); for (auto& instr : ir.ir) { - VisitVariant(instr, [&transformer](Instruction& instruction) mutable -> void { transformer.EncodeInstruction(instruction); }, [&binary, &ir, this](RawValue& raw) mutable -> void { - switch (raw.mode) { - case Mode::b8_str: - binary.push(*std::get>(raw.value.variant)); - break; - case Mode::b8: - binary.push(static_cast(std::get(raw.value.variant))); - break; - case Mode::b16: - binary.push(static_cast(std::get(raw.value.variant))); - break; - case Mode::b32: - binary.push(static_cast(std::get(raw.value.variant))); - break; - case Mode::b64_label: - if (!ir.labels.contains(*std::get>(raw.value.variant))) { - ThrowError(*raw.value.tokens[1], parser, fmt::format("failed to resolve undefined reference to \"{}\"", *std::get>(raw.value.variant))); - } - binary.push(static_cast(ir.labels.at(*std::get>(raw.value.variant)))); - break; - case Mode::b64: - binary.push(static_cast(std::get(raw.value.variant))); - break; - } }, [](Label&) {}); + VisitVariant(instr, + [&transformer](Instruction& instruction) mutable -> void { + transformer.EncodeInstruction(instruction); + }, + [&binary, &ir, this](RawValue& raw) mutable -> void { + switch (raw.mode) { + case Mode::b8_str: + binary.push(*std::get>(raw.value.variant)); + break; + case Mode::b8: + binary.push(static_cast(std::get(raw.value.variant))); + break; + case Mode::b16: + binary.push(static_cast(std::get(raw.value.variant))); + break; + case Mode::b32: + binary.push(static_cast(std::get(raw.value.variant))); + break; + case Mode::b64_label: + if (!ir.labels.contains(*std::get>(raw.value.variant))) { + ThrowError(*raw.value.tokens[1], parser, fmt::format("failed to resolve undefined reference to \"{}\"", *std::get>(raw.value.variant))); + } + binary.push(static_cast(ir.labels.at(*std::get>(raw.value.variant)))); + break; + case Mode::b64: + binary.push(static_cast(std::get(raw.value.variant))); + break; + default: + HyperCPU::unreachable(); + } + }, + [](Label&) {} + ); } binary.entry_point = ir.entry_point; diff --git a/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp b/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp index 8cdb1540..820f65b3 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp @@ -4,7 +4,7 @@ using namespace HyperALU; -void HyperCPU::CPU::ExecDIV(const IInstruction& instr, OperandContainer op1, OperandContainer op2) { +void HyperCPU::CPU::ExecDIV(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(*x2)) { TriggerInterrupt(cpu_exceptions::ZRDIV); return; From c3095f5189a38dceb855ade3b9c57888993f389c Mon Sep 17 00:00:00 2001 From: HyperWinX Date: Sun, 11 May 2025 19:53:06 +0400 Subject: [PATCH 32/40] Fix dockerfiles (remove custom user creation) and add temporary workflow permission issue workaround --- .github/workflows/distro-ci.yml | 4 +++- .github/workflows/run-tests-feature-branch.yml | 4 +++- .github/workflows/testing.yml | 4 +++- .github/workflows/version-increment.yml | 4 +++- docker/archlinux/Dockerfile | 7 ------- docker/debian-stable/Dockerfile | 7 ------- docker/debian-unstable/Dockerfile | 7 ------- docker/ubuntu/Dockerfile | 7 ------- 8 files changed, 12 insertions(+), 32 deletions(-) diff --git a/.github/workflows/distro-ci.yml b/.github/workflows/distro-ci.yml index 3f605ab7..7c11a589 100644 --- a/.github/workflows/distro-ci.yml +++ b/.github/workflows/distro-ci.yml @@ -11,7 +11,9 @@ permissions: jobs: build: runs-on: ubuntu-latest - container: hyperwin/hcpu-ci:${{ matrix.config.tag }} + container: + image: hyperwin/hcpu-ci:${{ matrix.config.tag }} + options: --user root name: "Build on ${{matrix.config.name}}" strategy: matrix: diff --git a/.github/workflows/run-tests-feature-branch.yml b/.github/workflows/run-tests-feature-branch.yml index 7ec06ff7..b97eb4b7 100644 --- a/.github/workflows/run-tests-feature-branch.yml +++ b/.github/workflows/run-tests-feature-branch.yml @@ -6,7 +6,9 @@ on: jobs: testing: runs-on: ubuntu-latest - container: hyperwin/hcpu-ci:debian-unstable + container: + image: hyperwin/hcpu-ci:debian-unstable + options: --user root if: (github.ref != 'refs/heads/master' && github.ref != 'refs/heads/dev') || !contains(github.event.head_commit.message, '[ci skip]') steps: diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index b36b323e..387a0a21 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -8,7 +8,9 @@ on: jobs: testing: runs-on: ubuntu-latest - container: hyperwin/hcpu-ci:debian-unstable + container: + image: hyperwin/hcpu-ci:debian-unstable + options: --user root name: Run full test suite steps: diff --git a/.github/workflows/version-increment.yml b/.github/workflows/version-increment.yml index b221fad3..887ea69e 100644 --- a/.github/workflows/version-increment.yml +++ b/.github/workflows/version-increment.yml @@ -8,7 +8,9 @@ on: jobs: versioning-patch-increment: runs-on: ubuntu-latest - container: hyperwin/hcpu-ci:debian-unstable + container: + image: hyperwin/hcpu-ci:debian-unstable + options: --user root if: "contains(github.event.head_commit.message, '[ci patch inc]')" permissions: contents: write diff --git a/docker/archlinux/Dockerfile b/docker/archlinux/Dockerfile index 48a0c6d0..0ec2acd1 100644 --- a/docker/archlinux/Dockerfile +++ b/docker/archlinux/Dockerfile @@ -12,10 +12,3 @@ RUN pacman -Syu --noconfirm --needed \ RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG}/bazelisk-linux-amd64 && \ chmod 755 bazelisk-linux-amd64 && \ mv bazelisk-linux-amd64 /usr/bin/bazelisk - -RUN useradd -m ${USER} && \ - mkdir /home/${USER}/workspace && \ - chown ${USER}:${USER} /home/${USER}/workspace - -USER ${USER} -WORKDIR /home/${USER}/workspace diff --git a/docker/debian-stable/Dockerfile b/docker/debian-stable/Dockerfile index 045c3280..e4afab25 100644 --- a/docker/debian-stable/Dockerfile +++ b/docker/debian-stable/Dockerfile @@ -11,10 +11,3 @@ RUN apt-get update && apt-get install -y --no-install-recommends \ RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG}/bazelisk-linux-amd64 && \ chmod 755 bazelisk-linux-amd64 && \ mv bazelisk-linux-amd64 /usr/bin/bazelisk - -RUN useradd -m ${USER} && \ - mkdir /home/${USER}/workspace && \ - chown ${USER}:${USER} /home/${USER}/workspace - -USER ${USER} -WORKDIR /home/${USER}/workspace diff --git a/docker/debian-unstable/Dockerfile b/docker/debian-unstable/Dockerfile index ce0335e6..2b76506f 100644 --- a/docker/debian-unstable/Dockerfile +++ b/docker/debian-unstable/Dockerfile @@ -11,10 +11,3 @@ RUN apt-get update && apt-get install -y --no-install-recommends \ RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG}/bazelisk-linux-amd64 && \ chmod 755 bazelisk-linux-amd64 && \ mv bazelisk-linux-amd64 /usr/bin/bazelisk - -RUN useradd -m ${USER} && \ - mkdir /home/${USER}/workspace && \ - chown ${USER}:${USER} /home/${USER}/workspace - -USER ${USER} -WORKDIR /home/${USER}/workspace diff --git a/docker/ubuntu/Dockerfile b/docker/ubuntu/Dockerfile index 25c13150..88d785f4 100644 --- a/docker/ubuntu/Dockerfile +++ b/docker/ubuntu/Dockerfile @@ -11,10 +11,3 @@ RUN apt update && apt install -y --no-install-recommends \ RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG}/bazelisk-linux-amd64 && \ chmod 755 bazelisk-linux-amd64 && \ mv bazelisk-linux-amd64 /usr/bin/bazelisk - -RUN useradd -m ${USER} && \ - mkdir /home/${USER}/workspace && \ - chown ${USER}:${USER} /home/${USER}/workspace - -USER ${USER} -WORKDIR /home/${USER}/workspace From cd08ccf8d6f6dabaa304a3267682427e5461d9d8 Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sun, 11 May 2025 19:43:17 +0300 Subject: [PATCH 33/40] fix ci --- .github/workflows/distro-ci.yml | 3 +- .../workflows/run-tests-feature-branch.yml | 3 +- .github/workflows/testing.yml | 3 +- MODULE.bazel | 2 +- README.md | 268 +++++++++--------- tools/increment_version.py | 15 +- 6 files changed, 154 insertions(+), 140 deletions(-) diff --git a/.github/workflows/distro-ci.yml b/.github/workflows/distro-ci.yml index 7c11a589..19be7c77 100644 --- a/.github/workflows/distro-ci.yml +++ b/.github/workflows/distro-ci.yml @@ -13,7 +13,8 @@ jobs: runs-on: ubuntu-latest container: image: hyperwin/hcpu-ci:${{ matrix.config.tag }} - options: --user root + # see https://github.com/bazelbuild/bazel/issues/13823 + options: --init name: "Build on ${{matrix.config.name}}" strategy: matrix: diff --git a/.github/workflows/run-tests-feature-branch.yml b/.github/workflows/run-tests-feature-branch.yml index b97eb4b7..f162b636 100644 --- a/.github/workflows/run-tests-feature-branch.yml +++ b/.github/workflows/run-tests-feature-branch.yml @@ -8,7 +8,8 @@ jobs: runs-on: ubuntu-latest container: image: hyperwin/hcpu-ci:debian-unstable - options: --user root + # see https://github.com/bazelbuild/bazel/issues/13823 + options: --init if: (github.ref != 'refs/heads/master' && github.ref != 'refs/heads/dev') || !contains(github.event.head_commit.message, '[ci skip]') steps: diff --git a/.github/workflows/testing.yml b/.github/workflows/testing.yml index 387a0a21..cf42f349 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -10,7 +10,8 @@ jobs: runs-on: ubuntu-latest container: image: hyperwin/hcpu-ci:debian-unstable - options: --user root + # see https://github.com/bazelbuild/bazel/issues/13823 + options: --init name: Run full test suite steps: diff --git a/MODULE.bazel b/MODULE.bazel index 43688e9c..c9f4fc0f 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -2,7 +2,7 @@ module( name = "hyper-cpu", - version = "0.4.13", + version = "0.4.14", compatibility_level = 1, ) diff --git a/README.md b/README.md index 7ce73b76..46365e92 100644 --- a/README.md +++ b/README.md @@ -1,134 +1,134 @@ -
    - - - - HyperCPU - -
    - -

    HyperCPU — the hyper toolkit for custom hyper ISA

    - -

    - - GitHub opened issues - Version - CI status - Status - License - Stars -

    - ->[!IMPORTANT] -> HyperCPU is almost ready for use! Wait for 1.0 release to try it out or build the project yourself, test it and report issues. - -HyperCPU screenshot - -### What is this - -HyperCPU is a set of programs created to work with my own simple ISA (instruction set architecture). The project was created for fun, but it took a lot of time (and nerves), and I learned a lot while working on it. - -HyperCPU project includes: -* **hCPU emulator** (aka `hcemul`); -* **hASM assembler** (aka `hcasm`); -* ~~**hASM disassembler**~~ (planned). - -See [ROADMAP.md](ROADMAP.md) for project ideas and tasks. - -### Installation - ->[!WARNING] -> HyperCPU supports 64-bit GNU/Linux systems only. It is known to be successfully built and running on `amd64` and `aarch64` architectures. -> -> HyperCPU fails to build and/or work properly under \*BSD systems ­— please do not ask us for support of these systems. Windows support is also not planned. - -#### Binaries - -Pre-compiled binaries are currently not available. Sorry. - -#### Building from sources - -Building HyperCPU requires these dependencies to be installed: - -* **C++20 compilers:** GCC 12+, Clang 14+. -* **Build systems:** CMake 3.25+, Ninja, GNU make. -* **Libraries:** re2, fmt (development files, of course). - -Building the tests requires googletest (gtest) to be installed. Generating the documentation in HTML format requires Python 3 and a few modules (`python3-pip`, `python3-sphinx`, `python3-sphinx-rtd-theme`) to be installed. - -After installing dependencies run these commands in the terminal: - -```bash -$ git clone --recursive https://github.com/HyperCPU-Project/HyperCPU -$ cd HyperCPU -$ cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -$ make -C build default -j$(nproc) -``` - -The build process can be customized using various build options (`cmake ... -DBUILD_OPTION=VALUE ...`): - -* `CMAKE_BUILD_TYPE:STRING` — project build profile (`Release`, `RelWithDebInfo` or `Debug`). Mandatory to be specified. -* `HCPU_COMPILER:STRING` allows to select a compiler that will be used to build the project. Supported values: - * `auto` (default) — let CMake automatically detect a needed compiler or use compiler paths defined by user. - * `clang` — use Clang, search for `clang` and `clang++` binaries. Hinting is supported, so if your `clang` binary is called `clang-19`, you can pass: `-DHCPU_COMPILER=clang -DCMAKE_C_COMPILER=clang-19 -DCMAKE_CXX_COMPILER=clang++-19`. - * `gcc` — use GCC, search for `gcc` and `g++` binaries. Be careful: in some environments Clang can do `gcc --> clang` symlinks. You can hint the binary name the same way as with `clang` mode: `-DHCPU_COMPILER=gcc -DCMAKE_C_COMPILER=gcc-14 -DCMAKE_CXX_COMPILER=g++-14`. -* `HCPU_LTO:BOOL` — enable building with LTO. If Clang is used, CMake will search for LLD. If LLD is found, LTO will be enabled, otherwise not. If using GCC, there are no dependencies. -* `HCPU_MARCH_NATIVE:BOOL` — use native architecture (`-march=native`). -* `HCPU_SANITIZERS:BOOL` — use ASan and LSan sanitizers. Enabled by default — set to `OFF` to disable. - -The compiled binaries should be located in `build` directory, and the generated documentation should be located in `docs/_build/html` directory. After building the project open `index.html` file and start reading the documentation. - -Check out [examples](examples) folder for interesting code examples that will help you better understand the syntax of hASM and the power of HyperCPU. - -### Usage - -#### `hcasm` (hASM assembler) - -```bash -$ ./hcasm [-h] [--help] [--version] [-o VAR] [-c] [-v VAR] source -``` - -* `source` — source code file to be compiled. -* `-h`, `--help` — display help message and exit. -* `--version` — display program version and exit. -* `-o VAR` — specify output binary file name. -* `-c` — generate an object file. -* `-v VAR` — specify verbosity level (`debug`, `info`, `warning`, `error`). Default value is `warning`. - -#### `hcemul` (hCPU emulator) - -```bash -$ ./hcemul [-h] [--help] [--version] [-v VAR] [-m VAR] [--memory VAR] binary -``` - -* `binary` — binary file to be executed. -* `-h`, `--help` — display help message and exit. -* `--version` — display program version and exit. -* `-v VAR` — specify verbosity level (`debug`, `info`, `warning`, `error`). Default value is `warning`. -* `-m`, `--memory` — specify max. memory amount to be used. Postfixes are supported. Default value is `8K`. - -### Contributing - -We will be happy to hear any feedback from you. Do not hesitate to report bugs or suggest any ideas using "Issues" page. - -Want to contribute to the project? Read [CONTRIBUTION.md](CONTRIBUTION.md) firstly. - -Thank you for your interest in HyperCPU. - -### Authors - -* **[HyperWin](https://github.com/HyperWinX) (2024 - present time)** — HyperCPU Project founder, lead developer and documentation author. -* **[Ivan Movchan](https://github.com/ivan-movchan) (2025 - present time)** — beta tester, artist and just a contributor. - -### License - -HyperCPU is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. - -This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - -You should have received a copy of the GNU General Public License along with this program. If not, see . +
    + + + + HyperCPU + +
    + +

    HyperCPU — the hyper toolkit for custom hyper ISA

    + +

    + + GitHub opened issues + Version + CI status + Status + License + Stars +

    + +>[!IMPORTANT] +> HyperCPU is almost ready for use! Wait for 1.0 release to try it out or build the project yourself, test it and report issues. + +HyperCPU screenshot + +### What is this + +HyperCPU is a set of programs created to work with my own simple ISA (instruction set architecture). The project was created for fun, but it took a lot of time (and nerves), and I learned a lot while working on it. + +HyperCPU project includes: +* **hCPU emulator** (aka `hcemul`); +* **hASM assembler** (aka `hcasm`); +* ~~**hASM disassembler**~~ (planned). + +See [ROADMAP.md](ROADMAP.md) for project ideas and tasks. + +### Installation + +>[!WARNING] +> HyperCPU supports 64-bit GNU/Linux systems only. It is known to be successfully built and running on `amd64` and `aarch64` architectures. +> +> HyperCPU fails to build and/or work properly under \*BSD systems ­— please do not ask us for support of these systems. Windows support is also not planned. + +#### Binaries + +Pre-compiled binaries are currently not available. Sorry. + +#### Building from sources + +Building HyperCPU requires these dependencies to be installed: + +* **C++20 compilers:** GCC 12+, Clang 14+. +* **Build systems:** CMake 3.25+, Ninja, GNU make. +* **Libraries:** re2, fmt (development files, of course). + +Building the tests requires googletest (gtest) to be installed. Generating the documentation in HTML format requires Python 3 and a few modules (`python3-pip`, `python3-sphinx`, `python3-sphinx-rtd-theme`) to be installed. + +After installing dependencies run these commands in the terminal: + +```bash +$ git clone --recursive https://github.com/HyperCPU-Project/HyperCPU +$ cd HyperCPU +$ cmake -S . -B build -DCMAKE_BUILD_TYPE=Release +$ make -C build default -j$(nproc) +``` + +The build process can be customized using various build options (`cmake ... -DBUILD_OPTION=VALUE ...`): + +* `CMAKE_BUILD_TYPE:STRING` — project build profile (`Release`, `RelWithDebInfo` or `Debug`). Mandatory to be specified. +* `HCPU_COMPILER:STRING` allows to select a compiler that will be used to build the project. Supported values: + * `auto` (default) — let CMake automatically detect a needed compiler or use compiler paths defined by user. + * `clang` — use Clang, search for `clang` and `clang++` binaries. Hinting is supported, so if your `clang` binary is called `clang-19`, you can pass: `-DHCPU_COMPILER=clang -DCMAKE_C_COMPILER=clang-19 -DCMAKE_CXX_COMPILER=clang++-19`. + * `gcc` — use GCC, search for `gcc` and `g++` binaries. Be careful: in some environments Clang can do `gcc --> clang` symlinks. You can hint the binary name the same way as with `clang` mode: `-DHCPU_COMPILER=gcc -DCMAKE_C_COMPILER=gcc-14 -DCMAKE_CXX_COMPILER=g++-14`. +* `HCPU_LTO:BOOL` — enable building with LTO. If Clang is used, CMake will search for LLD. If LLD is found, LTO will be enabled, otherwise not. If using GCC, there are no dependencies. +* `HCPU_MARCH_NATIVE:BOOL` — use native architecture (`-march=native`). +* `HCPU_SANITIZERS:BOOL` — use ASan and LSan sanitizers. Enabled by default — set to `OFF` to disable. + +The compiled binaries should be located in `build` directory, and the generated documentation should be located in `docs/_build/html` directory. After building the project open `index.html` file and start reading the documentation. + +Check out [examples](examples) folder for interesting code examples that will help you better understand the syntax of hASM and the power of HyperCPU. + +### Usage + +#### `hcasm` (hASM assembler) + +```bash +$ ./hcasm [-h] [--help] [--version] [-o VAR] [-c] [-v VAR] source +``` + +* `source` — source code file to be compiled. +* `-h`, `--help` — display help message and exit. +* `--version` — display program version and exit. +* `-o VAR` — specify output binary file name. +* `-c` — generate an object file. +* `-v VAR` — specify verbosity level (`debug`, `info`, `warning`, `error`). Default value is `warning`. + +#### `hcemul` (hCPU emulator) + +```bash +$ ./hcemul [-h] [--help] [--version] [-v VAR] [-m VAR] [--memory VAR] binary +``` + +* `binary` — binary file to be executed. +* `-h`, `--help` — display help message and exit. +* `--version` — display program version and exit. +* `-v VAR` — specify verbosity level (`debug`, `info`, `warning`, `error`). Default value is `warning`. +* `-m`, `--memory` — specify max. memory amount to be used. Postfixes are supported. Default value is `8K`. + +### Contributing + +We will be happy to hear any feedback from you. Do not hesitate to report bugs or suggest any ideas using "Issues" page. + +Want to contribute to the project? Read [CONTRIBUTION.md](CONTRIBUTION.md) firstly. + +Thank you for your interest in HyperCPU. + +### Authors + +* **[HyperWin](https://github.com/HyperWinX) (2024 - present time)** — HyperCPU Project founder, lead developer and documentation author. +* **[Ivan Movchan](https://github.com/ivan-movchan) (2025 - present time)** — beta tester, artist and just a contributor. + +### License + +HyperCPU is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. + +This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. + +You should have received a copy of the GNU General Public License along with this program. If not, see . diff --git a/tools/increment_version.py b/tools/increment_version.py index c50e8a3b..d2d43e34 100755 --- a/tools/increment_version.py +++ b/tools/increment_version.py @@ -87,20 +87,31 @@ def update_version_file(self, file: Path, version: Version): fd.write(contents.getvalue()) @dispatching_file("MODULE.bazel") - def update_module_file(self, file: Path, version=Version): + def update_module_file(self, file: Path, version: Version): with open(file, "r") as fd: contents = fd.read() module = self.__bazel_find_module(contents) current_version = self.__bazel_find_version(module) newly_versioned_module = module.replace( - current_version, f"version = '{str(version)}'" + current_version, f"version = \"{str(version)}\"" ) contents = contents.replace(module, newly_versioned_module) with open(file, "w") as fd: fd.write(contents) + @dispatching_file("README.md") + def update_readme(self, file: Path, version: Version): + with open(file, "r") as fd: + content = fd.read() + + new_version = f' str: module_pattern = r"module\(.*?\)" matches = re.findall(module_pattern, contents, flags=re.DOTALL) From 6e41a2a429f1b89e6c055e57fdc14fd1bcaf1a29 Mon Sep 17 00:00:00 2001 From: HyperWinX Date: Sun, 11 May 2025 21:47:07 +0400 Subject: [PATCH 34/40] Add awk to fedora dockerfile --- docker/fedora/Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docker/fedora/Dockerfile b/docker/fedora/Dockerfile index 1994eb78..ac24acd2 100644 --- a/docker/fedora/Dockerfile +++ b/docker/fedora/Dockerfile @@ -2,7 +2,7 @@ FROM fedora:latest RUN dnf update -y \ && dnf install -y --setopt=install_weak_deps=False git cmake \ - clang gcc which nodejs python3 python3-pip make \ + clang gcc which nodejs python3 python3-pip make awk \ && pip3 install --no-cache-dir --break-system-packages conan \ && dnf clean all \ && rm -rf /var/cache/dnf From 59657482e893bfeaba5b014768b51691e4a6c44b Mon Sep 17 00:00:00 2001 From: AshFungor Date: Sun, 11 May 2025 22:12:25 +0300 Subject: [PATCH 35/40] patch docker --- docker/alpine/Dockerfile | 12 ++++++++---- docker/archlinux/Dockerfile | 1 - docker/debian-stable/Dockerfile | 1 - docker/debian-unstable/Dockerfile | 1 - docker/fedora/Dockerfile | 6 +++++- docker/gentoo-glibc/Dockerfile | 8 +++++++- 6 files changed, 20 insertions(+), 9 deletions(-) diff --git a/docker/alpine/Dockerfile b/docker/alpine/Dockerfile index 52918024..ecea2c60 100644 --- a/docker/alpine/Dockerfile +++ b/docker/alpine/Dockerfile @@ -1,7 +1,11 @@ FROM alpine:latest +ARG BAZELISK_TAG=v1.15.0 -RUN apk update && \ - apk add --no-cache python3 py3-pip clang gcc git cmake make \ - ninja nodejs grep g++ linux-headers \ - && pip3 install --no-cache-dir --break-system-packages conan \ No newline at end of file +RUN apk update \ + && apk add --no-cache python3 py3-pip clang gcc git cmake make ninja grep g++ linux-headers wget \ + && pip3 install --no-cache-dir --break-system-packages conan + +RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG}/bazelisk-linux-amd64 && \ + chmod 755 bazelisk-linux-amd64 && \ + mv bazelisk-linux-amd64 /usr/bin/bazelisk diff --git a/docker/archlinux/Dockerfile b/docker/archlinux/Dockerfile index 0ec2acd1..655622db 100644 --- a/docker/archlinux/Dockerfile +++ b/docker/archlinux/Dockerfile @@ -1,6 +1,5 @@ FROM archlinux:latest -ARG USER=bazel ARG BAZELISK_TAG=v1.15.0 RUN pacman -Syu --noconfirm --needed \ diff --git a/docker/debian-stable/Dockerfile b/docker/debian-stable/Dockerfile index e4afab25..041d377b 100644 --- a/docker/debian-stable/Dockerfile +++ b/docker/debian-stable/Dockerfile @@ -1,6 +1,5 @@ FROM debian:latest -ARG USER=bazel ARG BAZELISK_TAG=v1.15.0 RUN apt-get update && apt-get install -y --no-install-recommends \ diff --git a/docker/debian-unstable/Dockerfile b/docker/debian-unstable/Dockerfile index 2b76506f..5e84b468 100644 --- a/docker/debian-unstable/Dockerfile +++ b/docker/debian-unstable/Dockerfile @@ -1,6 +1,5 @@ FROM debian:unstable -ARG USER=bazel ARG BAZELISK_TAG=v1.15.0 RUN apt-get update && apt-get install -y --no-install-recommends \ diff --git a/docker/fedora/Dockerfile b/docker/fedora/Dockerfile index ac24acd2..6534748d 100644 --- a/docker/fedora/Dockerfile +++ b/docker/fedora/Dockerfile @@ -2,7 +2,11 @@ FROM fedora:latest RUN dnf update -y \ && dnf install -y --setopt=install_weak_deps=False git cmake \ - clang gcc which nodejs python3 python3-pip make awk \ + clang gcc which nodejs python3 python3-pip make awk wget \ && pip3 install --no-cache-dir --break-system-packages conan \ && dnf clean all \ && rm -rf /var/cache/dnf + +RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG}/bazelisk-linux-amd64 && \ + chmod 755 bazelisk-linux-amd64 && \ + mv bazelisk-linux-amd64 /usr/bin/bazelisk diff --git a/docker/gentoo-glibc/Dockerfile b/docker/gentoo-glibc/Dockerfile index 975179b7..d67b47d2 100644 --- a/docker/gentoo-glibc/Dockerfile +++ b/docker/gentoo-glibc/Dockerfile @@ -1,6 +1,12 @@ FROM gentoo/stage3:systemd +ARG BAZELISK_TAG=v1.15.0 + RUN emerge --sync > /dev/null && \ getuto && \ - emerge llvm-core/clang cmake dev-vcs/git re2 libfmt gtest which nodejs conan --getbinpkg -j2 && \ + emerge llvm-core/clang cmake dev-vcs/git re2 libfmt gtest which wget conan --getbinpkg -j2 && \ rm -rf /var/lib/repos/gentoo + +RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG}/bazelisk-linux-amd64 && \ + chmod 755 bazelisk-linux-amd64 && \ + mv bazelisk-linux-amd64 /usr/bin/bazelisk From 10576fb2db39c140c313a90238f999cfefe32eb6 Mon Sep 17 00:00:00 2001 From: HyperWinX Date: Mon, 12 May 2025 08:59:39 +0400 Subject: [PATCH 36/40] Fix dockerfiles - add bazelisk tag --- docker/fedora/Dockerfile | 2 ++ docker/gentoo-musl/stage2/Dockerfile | 6 ++++++ 2 files changed, 8 insertions(+) diff --git a/docker/fedora/Dockerfile b/docker/fedora/Dockerfile index 6534748d..09d4a225 100644 --- a/docker/fedora/Dockerfile +++ b/docker/fedora/Dockerfile @@ -1,5 +1,7 @@ FROM fedora:latest +ARG BAZELISK_TAG=v1.15.0 + RUN dnf update -y \ && dnf install -y --setopt=install_weak_deps=False git cmake \ clang gcc which nodejs python3 python3-pip make awk wget \ diff --git a/docker/gentoo-musl/stage2/Dockerfile b/docker/gentoo-musl/stage2/Dockerfile index 15b46378..b39ee4ab 100644 --- a/docker/gentoo-musl/stage2/Dockerfile +++ b/docker/gentoo-musl/stage2/Dockerfile @@ -1,4 +1,10 @@ FROM hyperwin/hcpu-ci:gentoo-musl-build +ARG BAZELISK_TAG=v1.15.0 + RUN emerge llvm-core/clang --getbinpkg && \ rm -rf /var/lib/repos/gentoo + +RUN wget https://github.com/bazelbuild/bazelisk/releases/download/${BAZELISK_TAG}/bazelisk-linux-amd64 && \ + chmod 755 bazelisk-linux-amd64 && \ + mv bazelisk-linux-amd64 /usr/bin/bazelisk From 0b43bb771b42c160b70214d93607acb4a7fc26fd Mon Sep 17 00:00:00 2001 From: HyperWinX Date: Mon, 12 May 2025 09:17:54 +0400 Subject: [PATCH 37/40] List cmake as conan dependency --- conandata.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/conandata.yml b/conandata.yml index aa465698..7cac546e 100644 --- a/conandata.yml +++ b/conandata.yml @@ -10,3 +10,4 @@ requirements: libunwind: "1.8.1" boost: "1.87.0" spdlog: "1.15.0" + cmake: "3.27.0" From 72c29fb9d41224e1e16c3e2bf8f8d05a49fbad6a Mon Sep 17 00:00:00 2001 From: HyperWinX Date: Mon, 12 May 2025 10:06:58 +0400 Subject: [PATCH 38/40] Fix alpine build --- .github/workflows/distro-ci.yml | 2 +- conandata.yml | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/.github/workflows/distro-ci.yml b/.github/workflows/distro-ci.yml index 19be7c77..75d97e7c 100644 --- a/.github/workflows/distro-ci.yml +++ b/.github/workflows/distro-ci.yml @@ -47,5 +47,5 @@ jobs: git checkout ${{ github.event.pull_request.head.sha }} git submodule update --init --recursive - conan profile detect && conan install . --build=missing + conan profile detect && conan install . --build=cmake --build=missing bazelisk build //src/... //tests/... --config=linux-opt diff --git a/conandata.yml b/conandata.yml index 7cac546e..aa465698 100644 --- a/conandata.yml +++ b/conandata.yml @@ -10,4 +10,3 @@ requirements: libunwind: "1.8.1" boost: "1.87.0" spdlog: "1.15.0" - cmake: "3.27.0" From 79d0f7ce4d62b1fca9646f244dde45b209071ebe Mon Sep 17 00:00:00 2001 From: HyperWinX Date: Mon, 12 May 2025 14:31:53 +0400 Subject: [PATCH 39/40] Temporarily disable Alpine for distro-ci workflow --- .github/workflows/distro-ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/distro-ci.yml b/.github/workflows/distro-ci.yml index 75d97e7c..012abdba 100644 --- a/.github/workflows/distro-ci.yml +++ b/.github/workflows/distro-ci.yml @@ -31,8 +31,8 @@ jobs: name: Gentoo GLibc - tag: gentoo-musl name: Gentoo Musl - - tag: alpine - name: Alpine +# - tag: alpine +# name: Alpine - tag: ubuntu name: Ubuntu From b4434e4f0fd34d2e8b20e63f0772f8ce12b03673 Mon Sep 17 00:00:00 2001 From: HyperWinX Date: Mon, 12 May 2025 14:36:06 +0400 Subject: [PATCH 40/40] Temporarily disable Gentoo Musl for distro-ci workflow --- .github/workflows/distro-ci.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/distro-ci.yml b/.github/workflows/distro-ci.yml index 012abdba..d7860526 100644 --- a/.github/workflows/distro-ci.yml +++ b/.github/workflows/distro-ci.yml @@ -29,8 +29,8 @@ jobs: name: Arch Linux - tag: gentoo-glibc name: Gentoo GLibc - - tag: gentoo-musl - name: Gentoo Musl +# - tag: gentoo-musl +# name: Gentoo Musl # - tag: alpine # name: Alpine - tag: ubuntu