diff --git a/.bazelrc b/.bazelrc new file mode 100644 index 00000000..e59f2812 --- /dev/null +++ b/.bazelrc @@ -0,0 +1,49 @@ +# 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 +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 +# 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 +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 +build:linux-opt --cxxopt=-O3 +# ---------------------------- + +# Distro-specific configurations +# ... 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/.github/workflows/distro-ci.yml b/.github/workflows/distro-ci.yml index 0a938baf..d7860526 100644 --- a/.github/workflows/distro-ci.yml +++ b/.github/workflows/distro-ci.yml @@ -11,7 +11,10 @@ permissions: jobs: build: runs-on: ubuntu-latest - container: hyperwin/hcpu-ci:${{ matrix.config.tag }} + container: + image: hyperwin/hcpu-ci:${{ matrix.config.tag }} + # see https://github.com/bazelbuild/bazel/issues/13823 + options: --init name: "Build on ${{matrix.config.name}}" strategy: matrix: @@ -26,13 +29,13 @@ jobs: name: Arch Linux - tag: gentoo-glibc name: Gentoo GLibc - - tag: gentoo-musl - name: Gentoo Musl - - tag: alpine - name: Alpine +# - tag: gentoo-musl +# name: Gentoo Musl +# - tag: alpine +# name: Alpine - tag: ubuntu name: Ubuntu - + steps: - run: | set -e @@ -43,11 +46,6 @@ 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 \ - --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=cmake --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 07630e22..f162b636 100644 --- a/.github/workflows/run-tests-feature-branch.yml +++ b/.github/workflows/run-tests-feature-branch.yml @@ -6,37 +6,28 @@ on: jobs: testing: runs-on: ubuntu-latest - container: hyperwin/hcpu-ci:debian-unstable + container: + image: hyperwin/hcpu-ci:debian-unstable + # 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: - name: Checkout code uses: actions/checkout@v4 with: - submodules: 'true' - - - name: Build and test with GCC on Release profile + submodules: "true" + + - name: Install conan dependecies run: | - python3 scripts/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 - - - name: Build and test with LLVM on Release profile + conan profile detect && conan install . --build=missing + + - name: Build and test with GCC on Release profile run: | - python3 scripts/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 + 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 90a44b1e..cf42f349 100644 --- a/.github/workflows/testing.yml +++ b/.github/workflows/testing.yml @@ -8,59 +8,38 @@ on: jobs: testing: runs-on: ubuntu-latest - container: hyperwin/hcpu-ci:debian-unstable + container: + image: hyperwin/hcpu-ci:debian-unstable + # see https://github.com/bazelbuild/bazel/issues/13823 + options: --init name: Run full test suite steps: - name: Checkout code uses: actions/checkout@v4 with: - submodules: 'true' - + 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 scripts/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 + bazelisk test //src/... //tests/... --config=linux-dbg --compiler=gcc + bazelisk clean --expunge - name: Build and test with GCC on Release profile run: | - python3 scripts/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 + bazelisk test //src/... //tests/... --config=linux-opt --compiler=gcc + bazelisk clean --expunge - name: Build and test with LLVM on Debug profile run: | - python3 scripts/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 + bazelisk test //src/... //tests/... --config=linux-dbg --compiler=clang + bazelisk clean --expunge - name: Build and test with LLVM on Release profile run: | - python3 scripts/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 - - - 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/.github/workflows/version-increment.yml b/.github/workflows/version-increment.yml index c63d7919..887ea69e 100644 --- a/.github/workflows/version-increment.yml +++ b/.github/workflows/version-increment.yml @@ -8,24 +8,26 @@ 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 - + 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 +41,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/.gitignore b/.gitignore index 87371c2c..6b436743 100644 --- a/.gitignore +++ b/.gitignore @@ -90,4 +90,15 @@ CMakeUserPresets* # Distribution packages dist/* +!dist/BUILD.bazel !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/.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/BUILD.bazel b/BUILD.bazel new file mode 100644 index 00000000..76e2bfa1 --- /dev/null +++ b/BUILD.bazel @@ -0,0 +1,41 @@ +"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") + +package( + default_visibility = [ + "//visibility:private", + ], +) + +config_setting( + name = "linux", + constraint_values = ["@platforms//os:linux"], +) + +refresh_compile_commands( + name = "refresh_compile_commands", + targets = { + "//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( + name = "format", + cc = "@llvm_toolchain//:bin/clang-format", + print_command = True, + python = "@aspect_rules_lint//format:ruff", + starlark = "@buildifier_prebuilt//:buildifier", +) 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/MODULE.bazel b/MODULE.bazel new file mode 100644 index 00000000..c9f4fc0f --- /dev/null +++ b/MODULE.bazel @@ -0,0 +1,49 @@ +"HyperCPU" + +module( + name = "hyper-cpu", + version = "0.4.14", + 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", + "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) + +git_override( + 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) + +llvm = use_extension("@toolchains_llvm//toolchain/extensions:llvm.bzl", "llvm") +llvm.toolchain( + llvm_version = "19.1.7", +) +use_repo(llvm, "llvm_toolchain") 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/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/conandata.yml b/conandata.yml new file mode 100644 index 00000000..aa465698 --- /dev/null +++ b/conandata.yml @@ -0,0 +1,12 @@ +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.0.2" + libunwind: "1.8.1" + boost: "1.87.0" + spdlog: "1.15.0" diff --git a/conanfile.py b/conanfile.py index 1fe452f0..0707284c 100644 --- a/conanfile.py +++ b/conanfile.py @@ -1,35 +1,26 @@ -from typing import Self, List -from functools import lru_cache +from typing import Dict, Any, Collection +from functools import cached_property, lru_cache from conan import ConanFile -from conan.tools.cmake import cmake_layout +from conan.tools.google import bazel_layout class HyperCPU(ConanFile): - generators: List[str] = ['CMakeToolchain', 'CMakeDeps'] - settings: List[str] = ['os', 'compiler', 'build_type', 'arch'] + name: "HyperCPU" + settings = ["os", "compiler", "build_type", "arch"] - def __init__(self: Self, display_name: str = '') -> None: - self.name = 'HyperCPU' + # conan data is fetched dynamically from + # conandata.yml + conan_data: Dict[str, Any] - 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) + @cached_property + def generators(self) -> Collection[str]: + return ["BazelToolchain", "BazelDeps"] @lru_cache - def requirements(self: Self) -> None: - for req, version in self.__requirements.items(): - self.requires(f'{req}/{version}') + def requirements(self) -> None: + for req, version in self.conan_data["requirements"].items(): + self.requires(f"{req}/{version}") def layout(self): - cmake_layout(self) + bazel_layout(self) diff --git a/dist/BUILD.bazel b/dist/BUILD.bazel new file mode 100644 index 00000000..39a3d6eb --- /dev/null +++ b/dist/BUILD.bazel @@ -0,0 +1,13 @@ +load("@rules_cc//cc:defs.bzl", "cc_library") + +package( + default_visibility = [ + "//:__subpackages__", + ], +) + +cc_library( + name = "hpool", + hdrs = ["HPool/hpool.hpp"], + includes = ["HPool"], +) 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/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/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 635e4611..655622db 100644 --- a/docker/archlinux/Dockerfile +++ b/docker/archlinux/Dockerfile @@ -1,7 +1,13 @@ FROM archlinux:latest +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 cmake 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 diff --git a/docker/debian-stable/Dockerfile b/docker/debian-stable/Dockerfile index d67171a4..041d377b 100644 --- a/docker/debian-stable/Dockerfile +++ b/docker/debian-stable/Dockerfile @@ -1,6 +1,12 @@ FROM debian:latest +ARG BAZELISK_TAG=v1.15.0 + 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 cmake wget 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 diff --git a/docker/debian-unstable/Dockerfile b/docker/debian-unstable/Dockerfile index ad2bf8a3..5e84b468 100644 --- a/docker/debian-unstable/Dockerfile +++ b/docker/debian-unstable/Dockerfile @@ -1,6 +1,12 @@ FROM debian:unstable +ARG BAZELISK_TAG=v1.15.0 + 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 cmake wget 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 diff --git a/docker/fedora/Dockerfile b/docker/fedora/Dockerfile index 1994eb78..09d4a225 100644 --- a/docker/fedora/Dockerfile +++ b/docker/fedora/Dockerfile @@ -1,8 +1,14 @@ 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 \ + 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 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 diff --git a/docker/ubuntu/Dockerfile b/docker/ubuntu/Dockerfile index ffc77e18..88d785f4 100644 --- a/docker/ubuntu/Dockerfile +++ b/docker/ubuntu/Dockerfile @@ -1,6 +1,13 @@ 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 gnu-which nodejs python3 python3-pip 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/* + +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/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/scripts/build.py b/scripts/build.py deleted file mode 100755 index 24cf7d52..00000000 --- a/scripts/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/scripts/increment_minor.sh b/scripts/increment_minor.sh deleted file mode 100755 index dc745e35..00000000 --- a/scripts/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/ -#include - -#include -#include -#include -#include -#include -#include +#include +#include "Assembler/Core/BinaryTransformer.hpp" +#include "Assembler/Core/Compiler.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" +#include "Common/Exit.hpp" +#include "PCH/CStd.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; + tp1 = Op1T::R; + break; case HCAsm::OperandType::mem_reg_add_int: case HCAsm::OperandType::memaddr_reg: - tp1 = Op1T::RM; break; + tp1 = Op1T::RM; + break; case HCAsm::OperandType::sint: case HCAsm::OperandType::uint: case HCAsm::OperandType::label: - tp1 = Op1T::IMM; break; + tp1 = Op1T::IMM; + break; case HCAsm::OperandType::memaddr_int: case HCAsm::OperandType::memaddr_lbl: - tp1 = Op1T::M; break; + tp1 = Op1T::M; + break; case HCAsm::OperandType::none: - tp1 = Op1T::NONE; break; + tp1 = Op1T::NONE; + break; default: - UNREACHABLE(); + HyperCPU::unreachable(); } switch (op2.type) { case HCAsm::OperandType::reg: - tp2 = Op2T::R; break; + tp2 = Op2T::R; + break; case HCAsm::OperandType::mem_reg_add_int: case HCAsm::OperandType::memaddr_reg: - tp2 = Op2T::RM; break; + tp2 = Op2T::RM; + break; case HCAsm::OperandType::sint: case HCAsm::OperandType::uint: case HCAsm::OperandType::label: - tp2 = Op2T::IMM; break; + tp2 = Op2T::IMM; + break; case HCAsm::OperandType::memaddr_int: case HCAsm::OperandType::memaddr_lbl: - tp2 = Op2T::M; break; + tp2 = Op2T::M; + break; case HCAsm::OperandType::none: - tp2 = Op2T::NONE; break; + tp2 = Op2T::NONE; + break; default: - UNREACHABLE(); + HyperCPU::unreachable(); } 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,136 +87,169 @@ 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: - 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; + HCAsm::Mode md = HCAsm::Mode::b8; // Placeholder 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; + default: + HyperCPU::unreachable(); } + 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; + default: + HyperCPU::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; - 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; + default: + HyperCPU::unreachable(); } - 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; + default: + HyperCPU::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: + HyperCPU::unreachable(); + } + } + 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 3cbe1c81..871b9813 100644 --- a/src/Assembler/Core/BinaryTransformer.hpp +++ b/src/Assembler/Core/BinaryTransformer.hpp @@ -1,10 +1,10 @@ #pragma once -#include - -#include -#include +#include +#include "Assembler/Core/Compiler.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "PCH/CStd.hpp" namespace HCAsm { struct BinaryResult; @@ -12,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) { @@ -36,61 +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: - 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!"); + 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: - 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; + 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 3df0b693..e08c1ae4 100644 --- a/src/Assembler/Core/Compiler.cpp +++ b/src/Assembler/Core/Compiler.cpp @@ -1,150 +1,145 @@ -#include -#include +#include -#include -#include -#include -#include -#include -#include - - -using HyperCPU::LogLevel; +#include "Assembler/Core/BinaryTransformer.hpp" +#include "Assembler/Core/Compiler.hpp" +#include "Common/Helpers/Classes.hpp" +#include "Common/Exit.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) { +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; @@ -158,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; @@ -168,144 +163,145 @@ 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; + default: + std::abort(); } } 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; + default: + std::abort(); } } 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; + default: + std::abort(); } } 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; + default: + HyperCPU::unreachable(); + } + 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: + default: + HyperCPU::unreachable(); + } + 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; + } + break; + case OperandType::memaddr_int: + result += 8; + switch (instr.op2.type) { + case OperandType::reg: // M_R + ++result; break; default: - ABORT(); + HyperCPU::unreachable(); + } + break; + case OperandType::label: + result += 8; + break; + case OperandType::none: + break; + default: + std::abort(); } return result; @@ -313,48 +309,48 @@ 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 { - ir.labels[label.name] = ir.code_size; - if (label.is_entry_point) { - ir.entry_point = ir.code_size; + 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(); } - }, - [&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(); - } - }(); - }); + }(); + }); } // 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]; - 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; @@ -366,48 +362,50 @@ 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!"); + HyperCPU::exit(1); } - 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 { - 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: ABORT(); - } - }, - [](Label&){}); + [&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; @@ -423,7 +421,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++; @@ -432,21 +430,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, '^')); + 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/Assembler/Core/Compiler.hpp b/src/Assembler/Core/Compiler.hpp index 1886a8ee..744465aa 100644 --- a/src/Assembler/Core/Compiler.hpp +++ b/src/Assembler/Core/Compiler.hpp @@ -1,16 +1,14 @@ #pragma once -#include -#include - -#include -#include -#include -#include -#include - +// TODO: fix this in hpool +#include #include +#include "Common/Helpers/Classes.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" +#include "Common/LanguageSpec/Registers.hpp" +#include "PCH/CStd.hpp" +#include "Pog/Pog.hpp" namespace HCAsm { enum class ValueType { @@ -34,7 +32,7 @@ namespace HCAsm { }; enum class Mode : std::uint8_t { - b8 = 0b00, + b8 = 0b00, b16 = 0b01, b32 = 0b10, b64 = 0b11, @@ -47,7 +45,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; @@ -74,18 +72,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); @@ -107,25 +109,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; @@ -136,55 +139,56 @@ 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; + default: + std::abort(); } + // TODO: handle missing return } std::string_view FindLine(const pog::LineSpecialization&, const std::string_view&); @@ -224,13 +228,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); @@ -248,4 +251,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 6ae6d56d..b1e7926b 100644 --- a/src/Assembler/Core/ModeNameAssoc.hpp +++ b/src/Assembler/Core/ModeNameAssoc.hpp @@ -1,14 +1,13 @@ #pragma once -#include - -#include - +#include #include +#include "Assembler/Core/Compiler.hpp" + constexpr inline const auto mode_assoc = mapbox::eternal::hash_map({ {"b8", HCAsm::Mode::b8}, {"b16", HCAsm::Mode::b16}, {"b32", HCAsm::Mode::b32}, {"b64", HCAsm::Mode::b64}, -}); \ No newline at end of file +}); diff --git a/src/Assembler/Core/OpcodeNameAssoc.hpp b/src/Assembler/Core/OpcodeNameAssoc.hpp index 0d7705f6..68aad063 100644 --- a/src/Assembler/Core/OpcodeNameAssoc.hpp +++ b/src/Assembler/Core/OpcodeNameAssoc.hpp @@ -1,46 +1,45 @@ #pragma once -#include - -#include - +#include #include -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} -}); +#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}}); diff --git a/src/Assembler/Core/Parsers.cpp b/src/Assembler/Core/Parsers.cpp index b2f8f144..af56dd90 100644 --- a/src/Assembler/Core/Parsers.cpp +++ b/src/Assembler/Core/Parsers.cpp @@ -1,21 +1,18 @@ -#include -#include - -#include -#include -#include +#include "Assembler/Core/Compiler.hpp" +#include "Assembler/Core/ModeNameAssoc.hpp" +#include "Assembler/Core/RegNameAssoc.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) { @@ -23,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)}}}; } } @@ -52,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) { @@ -81,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) { @@ -109,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) { @@ -142,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) { @@ -206,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 + }}; } } @@ -236,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) { @@ -258,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) { @@ -281,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 698261d5..9930ab18 100644 --- a/src/Assembler/Core/RegNameAssoc.hpp +++ b/src/Assembler/Core/RegNameAssoc.hpp @@ -1,51 +1,50 @@ #pragma once -#include - -#include - +#include #include -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} -}); \ No newline at end of file +#include "Common/LanguageSpec/Registers.hpp" +#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}}); diff --git a/src/Assembler/Core/StatementCompilers.cpp b/src/Assembler/Core/StatementCompilers.cpp index 3f0fa948..61739997 100644 --- a/src/Assembler/Core/StatementCompilers.cpp +++ b/src/Assembler/Core/StatementCompilers.cpp @@ -1,107 +1,100 @@ -#include -#include - -#include -#include -#include +#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) { // 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"); } @@ -110,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 {}; } @@ -119,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 {}; } @@ -128,13 +121,11 @@ 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 {}; } @@ -142,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 {}; } @@ -150,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 {}; } @@ -158,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 024f1a18..b3488796 100644 --- a/src/Assembler/Core/Tokenizers.cpp +++ b/src/Assembler/Core/Tokenizers.cpp @@ -1,12 +1,11 @@ -#include -#include - -#include +#include "Assembler/Core/Compiler.hpp" +#include "PCH/CStd.hpp" +#include "Pog/Pog.hpp" 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"); @@ -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.cpp similarity index 54% rename from src/Assembler/Main/Main.cpp rename to src/Assembler/Main.cpp index 320960b8..26452e4b 100644 --- a/src/Assembler/Main/Main.cpp +++ b/src/Assembler/Main.cpp @@ -1,27 +1,23 @@ -#include -#include - -#include -#include -#include -#include -#include -#include - #include - #include +#include + +#include "Assembler/Core/Compiler.hpp" +#include "Common/NotImplemented.hpp" +#include "PCH/CStd.hpp" +#include "Pog/Pog.hpp" #ifdef HCPU_ENABLE_LIBUNWIND -#include +#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 @@ -32,24 +28,23 @@ 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); } catch (const std::exception& err) { std::cerr << err.what() << '\n'; - EXIT(1); + return 1; } auto source = program.get("source"); @@ -57,32 +52,32 @@ 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"; } } - + if (program["-c"] == true) { 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) { @@ -90,11 +85,10 @@ int main(int argc, char** argv) { } src.close(); 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; @@ -102,12 +96,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 89885b5c..00000000 --- a/src/Assembler/Utils/Extension.hpp +++ /dev/null @@ -1,7 +0,0 @@ -#pragma once - -#include - -namespace HCAsm { - std::string CreateObjectFilename(std::string str); -} 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 new file mode 100644 index 00000000..b4222290 --- /dev/null +++ b/src/BacktraceProvider/BUILD.bazel @@ -0,0 +1,14 @@ +load("@rules_cc//cc:defs.bzl", "cc_library") + +cc_library( + name = "backtrace_provider", + srcs = ["BacktraceProvider.cpp"], + hdrs = ["BacktraceProvider.hpp"], + visibility = ["//visibility:public"], + deps = [ + "//src/PCH:pch_cstd", + "@fmt", + "@libbacktrace", + "@libunwind", + ], +) diff --git a/src/BacktraceProvider/BacktraceProvider.cpp b/src/BacktraceProvider/BacktraceProvider.cpp index da889253..71e6da22 100644 --- a/src/BacktraceProvider/BacktraceProvider.cpp +++ b/src/BacktraceProvider/BacktraceProvider.cpp @@ -1,81 +1,79 @@ #ifdef HCPU_ENABLE_LIBUNWIND #define UNW_LOCAL_ONLY -#include -#include #include - #include +#include -#include -#include +#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_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); - } +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; - } - - // 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); - +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); + + ++global_bt_controller.iteration; + return 0; +} } BacktraceController global_bt_controller; diff --git a/src/BacktraceProvider/BacktraceProvider.hpp b/src/BacktraceProvider/BacktraceProvider.hpp index d9a7f371..53966838 100644 --- a/src/BacktraceProvider/BacktraceProvider.hpp +++ b/src/BacktraceProvider/BacktraceProvider.hpp @@ -1,17 +1,21 @@ +#pragma once + #ifdef HCPU_ENABLE_LIBUNWIND -#include #include #include +#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); } @@ -24,6 +28,7 @@ class BacktraceController { // libunwind unw_cursor_t cursor; unw_context_t context; + private: // libbacktrace void* bt_state; diff --git a/src/BacktraceProvider/CMakeLists.txt b/src/BacktraceProvider/CMakeLists.txt deleted file mode 100644 index 1b2ddd51..00000000 --- a/src/BacktraceProvider/CMakeLists.txt +++ /dev/null @@ -1,24 +0,0 @@ -cmake_minimum_required(VERSION 3.25) - - -add_library( - backtrace-provider - STATIC - BacktraceProvider.cpp - BacktraceProvider.hpp -) -target_include_directories( - backtrace-provider - PUBLIC - ${CMAKE_SOURCE_DIR}/src -) -target_link_libraries( - backtrace-provider - PUBLIC - fmt::fmt - argparse::argparse - pog - eternal::eternal - hcpu_unwind - pch -) \ No newline at end of file diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt deleted file mode 100644 index 798be99a..00000000 --- a/src/CMakeLists.txt +++ /dev/null @@ -1,24 +0,0 @@ -# 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(Emulator) -add_subdirectory(Assembler) -add_subdirectory(BacktraceProvider) diff --git a/src/Common/BUILD.bazel b/src/Common/BUILD.bazel new file mode 100644 index 00000000..bcbca553 --- /dev/null +++ b/src/Common/BUILD.bazel @@ -0,0 +1,16 @@ +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", + visibility = ["//visibility:public"], + deps = [ + "//src/PCH:pch_cstd", + "@spdlog", + ], +) diff --git a/src/Common/Defs.hpp b/src/Common/Defs.hpp new file mode 100644 index 00000000..9d8f2d61 --- /dev/null +++ b/src/Common/Defs.hpp @@ -0,0 +1,7 @@ +#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/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/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 3eef498e..416633cf 100644 --- a/src/Emulator/Main/Main.hpp +++ b/src/Common/Helpers/Classes.hpp @@ -1,24 +1,23 @@ #pragma once -#include - +#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 }; - + using Magic = std::uint64_t; static inline constexpr Magic magic = 0xb7a6457636cf6c3a; @@ -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 new file mode 100644 index 00000000..8653cc6a --- /dev/null +++ b/src/Common/LanguageSpec/AllowedFlags.hpp @@ -0,0 +1,137 @@ +#pragma once + +#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 + }; +} // namespace HyperCPU diff --git a/src/Common/LanguageSpec/Flags.hpp b/src/Common/LanguageSpec/Flags.hpp new file mode 100644 index 00000000..f3afb30f --- /dev/null +++ b/src/Common/LanguageSpec/Flags.hpp @@ -0,0 +1,27 @@ +#pragma once + +#include "PCH/CStd.hpp" + +namespace HyperCPU { + enum class Mode : std::uint8_t { + 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 + }; +} // namespace HyperCPU diff --git a/src/Common/LanguageSpec/Opcodes.hpp b/src/Common/LanguageSpec/Opcodes.hpp new file mode 100644 index 00000000..616238a6 --- /dev/null +++ b/src/Common/LanguageSpec/Opcodes.hpp @@ -0,0 +1,91 @@ +#pragma once + +#include "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::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: + 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 new file mode 100644 index 00000000..146e69d8 --- /dev/null +++ b/src/Common/LanguageSpec/Registers.hpp @@ -0,0 +1,102 @@ +#pragma once + +#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 + }; + + 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; + } + } + } // namespace Validator +} // namespace HyperCPU diff --git a/src/Common/NotImplemented.hpp b/src/Common/NotImplemented.hpp new file mode 100644 index 00000000..6d81d6fb --- /dev/null +++ b/src/Common/NotImplemented.hpp @@ -0,0 +1,10 @@ +#pragma once + +#include "Common/Defs.hpp" +#include "PCH/CStd.hpp" + +namespace HyperCPU { + 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 new file mode 100644 index 00000000..93cf1423 --- /dev/null +++ b/src/Emulator/BUILD.bazel @@ -0,0 +1,28 @@ +load("@rules_cc//cc:defs.bzl", "cc_binary", "cc_library") + +cc_library( + name = "emulator_core", + srcs = glob( + ["**/*.cpp"], + exclude = ["Main.cpp"], + ), + hdrs = glob(["**/*.hpp"]), + visibility = ["//visibility:public"], + deps = [ + "//src/Assembler:assembler_core", + "//src/PCH:pch_cstd", + "//src/Pog:pog", + "@eternal", + "@fmt", + ], +) + +cc_binary( + name = "hcemul", + srcs = ["Main.cpp"], + visibility = ["//visibility:private"], + deps = [ + ":emulator_core", + "@argparse", + ], +) diff --git a/src/Emulator/CMakeLists.txt b/src/Emulator/CMakeLists.txt deleted file mode 100644 index f194c8d4..00000000 --- a/src/Emulator/CMakeLists.txt +++ /dev/null @@ -1,97 +0,0 @@ -cmake_minimum_required(VERSION 3.25) - - -add_library( - 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( - emulator-core - PUBLIC - ${CMAKE_SOURCE_DIR}/src - ${CMAKE_CURRENT_SOURCE_DIR} -) - -target_link_libraries( - emulator-core - PUBLIC - fmt::fmt - argparse::argparse - pog - eternal::eternal - pch - hpool -) - -add_executable( - 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 diff --git a/src/Emulator/Core/CPU/ALU.hpp b/src/Emulator/Core/CPU/ALU.hpp index 43a10c90..029b9a02 100644 --- a/src/Emulator/Core/CPU/ALU.hpp +++ b/src/Emulator/Core/CPU/ALU.hpp @@ -1,61 +1,60 @@ #pragma once -#include +#include "PCH/CStd.hpp" #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 b023891a..65e77103 100644 --- a/src/Emulator/Core/CPU/Assert.hpp +++ b/src/Emulator/Core/CPU/Assert.hpp @@ -1,6 +1,8 @@ #pragma once -#include +#include "PCH/CStd.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 db773b45..31d0f01e 100644 --- a/src/Emulator/Core/CPU/CPU.cpp +++ b/src/Emulator/Core/CPU/CPU.cpp @@ -1,155 +1,152 @@ -#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)] = +#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 "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))), + 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; @@ -162,7 +159,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 +193,7 @@ void HyperCPU::CPU::DecodingThread() { default: break; } - + if (interrupt_active.load(std::memory_order_acquire)) { skip_decoding_cycle = false; continue; @@ -212,7 +209,7 @@ void HyperCPU::CPU::DecodingThread() { buffer_used.store(true, std::memory_order_release); buffer_used.notify_one(); - } + } } void HyperCPU::CPU::ExecutingThread() { @@ -257,19 +254,19 @@ void HyperCPU::CPU::Run() { buffer = m_decoder->FetchAndDecode(); - switch (buffer.m_opcode) { - case _CONT: - continue; - case IRET: - *xip = StackPop64(); - continue; - default: - break; + switch (buffer.m_opcode) { + case HyperCPU::Opcode::_CONT: + continue; + case HyperCPU::Opcode::IRET: + *xip = StackPop64(); + continue; + default: + break; } 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() { @@ -279,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 b39538e0..8899dfd8 100644 --- a/src/Emulator/Core/CPU/CPU.hpp +++ b/src/Emulator/Core/CPU/CPU.hpp @@ -1,14 +1,12 @@ #pragma once -#include - -#include -#include -#include -#include -#include -#include +#include "PCH/CStd.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" +#include "Emulator/Core/CPU/IO/Simple.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) @@ -18,7 +16,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; @@ -29,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; @@ -40,7 +37,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; @@ -78,7 +75,7 @@ namespace HyperCPU { std::optional pending_interrupt; void DecodingThread(); void ExecutingThread(); - + // All instructions DECLARE_INSTR(ADD); DECLARE_INSTR(ADC); @@ -119,7 +116,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); @@ -127,8 +124,7 @@ namespace HyperCPU { bool CanExecuteInterrupts(); void SetEntryPoint(std::uint32_t entry_point); - const HyperCPU::Logger& GetLogger() const noexcept; - + ~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 85ffe863..73a28e23 100644 --- a/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp +++ b/src/Emulator/Core/CPU/Decoders/StdDecoder.cpp @@ -1,22 +1,23 @@ -#include +#include "PCH/CStd.hpp" -#include -#include -#include -#include -#include -#include -#include -#include +#include "Common/LanguageSpec/AllowedFlags.hpp" +#include "Common/LanguageSpec/Flags.hpp" +#include "Common/LanguageSpec/Opcodes.hpp" +#include "Common/LanguageSpec/Registers.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" - -#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} +// TODO: лишать кошка жена за такое +#define dcdr_assert(expr) \ + RaiseException((expr)); \ + if (cpu && cpu->pending_interrupt.has_value()) \ + 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); } @@ -25,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: - return byte & 0b11000000; - case b16: - return byte & 0b00110000; - case b32: - return byte & 0b00001100; - case b64: - return byte & 0b00000011; - default: - UNREACHABLE(); + case Mode::b8: + return byte & 0b11000000; + case Mode::b16: + return byte & 0b00110000; + case Mode::b32: + return byte & 0b00001100; + case Mode::b64: + return byte & 0b00000011; + default: + std::abort(); } } @@ -55,17 +56,17 @@ HyperCPU::IInstruction HyperCPU::Decoder::FetchAndDecode() { instruction.m_opcode = static_cast(opcode); switch (instruction.m_opcode) { - case IRET: - return instruction; - default: - break; + case Opcode::IRET: + return instruction; + default: + break; } // Fetch flags, set opcode Mode and verify operand types 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); @@ -74,116 +75,117 @@ 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)); + 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: { - 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 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)); + + tmp = mem_controller->Fetch8(*xip); + dcdr_assert(Validator::IsValidRegister(tmp)); + instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(tmp)); + break; + } + + 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)); + + instruction.m_op2 = OperandContainer{mem_controller->Fetch64(*xip)}; + break; + } + + 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 Mode::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 Mode::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 Mode::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 Mode::b64: { + instruction.m_op2 = OperandContainer{mem_controller->Fetch64(*xip)}; break; } + } + break; + } - case M_R: { - instruction.m_op1 = OperandContainer{mem_controller->Fetch64(*xip)}; + case OperandTypes::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)); + break; + } + + 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 OperandTypes::M: + instruction.m_op1 = OperandContainer{mem_controller->Fetch64(*xip)}; + break; + + case OperandTypes::IMM: + switch (instruction.m_opcode_mode) { + case Mode::b8: { + std::uint8_t vtmp = mem_controller->Fetch8(*xip); + instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(vtmp)); + break; + } - std::uint8_t tmp = mem_controller->Fetch8(*xip); - dcdr_assert(Validator::IsValidRegister(tmp)); - instruction.m_op2 = OperandContainer(HyperCPU::bit_cast(tmp)); + case Mode::b16: { + std::uint16_t vtmp = mem_controller->Fetch16(*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 Mode::b32: { + std::uint32_t vtmp = mem_controller->Fetch32(*xip); + instruction.m_op1 = OperandContainer(HyperCPU::bit_cast(vtmp)); break; } - case M: + case Mode::b64: { 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 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; - } + } } break; - case NONE: break; + case OperandTypes::NONE: + break; } return instruction; diff --git a/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp b/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp index 8d8c8deb..a225d6bf 100644 --- a/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp +++ b/src/Emulator/Core/CPU/Decoders/StdDecoder.hpp @@ -1,14 +1,12 @@ #pragma once -#include - -#include -#include -#include -#include -#include -#include +#include "PCH/CStd.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" namespace HyperCPU { enum class AddrExtensionStatus { @@ -19,37 +17,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() - - 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; } + 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; + } 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; }; @@ -77,15 +93,13 @@ 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) {} + explicit Decoder(IMemoryController* mc, std::uint64_t* counter, class CPU* cpu) + : mem_controller(mc), xip(counter), cpu(cpu), decoder_halted(false) { + } IInstruction FetchAndDecode() override; bool IsHalted() const noexcept override; ~Decoder() = default; }; -} \ No newline at end of file +}; // namespace HyperCPU diff --git a/src/Emulator/Core/CPU/IO/Simple.cpp b/src/Emulator/Core/CPU/IO/Simple.cpp index 44b9f918..01af7a4e 100644 --- a/src/Emulator/Core/CPU/IO/Simple.cpp +++ b/src/Emulator/Core/CPU/IO/Simple.cpp @@ -1,12 +1,13 @@ -#include +#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) { +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; } } @@ -71,6 +72,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..74ddf25e 100644 --- a/src/Emulator/Core/CPU/IO/Simple.hpp +++ b/src/Emulator/Core/CPU/IO/Simple.hpp @@ -1,4 +1,4 @@ -#include +#include "PCH/CStd.hpp" #include @@ -6,11 +6,12 @@ namespace HyperCPU { class SimpleIOImpl { public: SimpleIOImpl(); - + std::function GetPutchar(); std::function GetGetchar(); ~SimpleIOImpl(); + private: enum class CurrentState { Default, @@ -21,7 +22,7 @@ namespace HyperCPU { EnablePrinting = 0x10, DisablePrinting = 0x11, }; - + void Putchar(std::uint8_t); std::uint8_t Getchar(); @@ -33,4 +34,4 @@ namespace HyperCPU { bool was_printing, printing; struct termios oldt, newt; }; -} +} // namespace HyperCPU diff --git a/src/Emulator/Core/CPU/Instructions/AllowedFlags.cpp b/src/Emulator/Core/CPU/Instructions/AllowedFlags.cpp deleted file mode 100644 index d7b9050d..00000000 --- a/src/Emulator/Core/CPU/Instructions/AllowedFlags.cpp +++ /dev/null @@ -1,137 +0,0 @@ -#include - -#include - - -namespace HyperCPU { - const std::uint8_t allowed_op_modes[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 - }; -} 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..243a290d 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ADC.cpp @@ -1,161 +1,174 @@ -#include - -#include -#include - -#include -#include +#include "Emulator/Core/CPU/ALU.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#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(); - 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 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 df52d676..1c3769c9 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ADD.cpp @@ -1,143 +1,140 @@ -#include - -#include -#include - -#include -#include +#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 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 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 2ed7d08b..71301391 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/AND.cpp @@ -1,128 +1,125 @@ -#include - -#include -#include - -#include +#include "Emulator/Core/CPU/ALU.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#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); - 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: + 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; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp b/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp index a04dea5f..bf1b3568 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/ANDN.cpp @@ -1,148 +1,145 @@ -#include - -#include -#include - -#include +#include "Emulator/Core/CPU/ALU.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#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); - 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 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 c8931954..54156caf 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/BSWAP.cpp @@ -1,36 +1,28 @@ -#include +#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 Mode::b8: + break; - case b16: { - auto& dst = op1.deref(); - dst = HyperCPU::byteswap(dst); - break; - } + case Mode::b16: { + auto& dst = op1.deref(); + dst = HyperCPU::byteswap(dst); + break; + } - case b32: { - auto& dst = op1.deref(); - dst = HyperCPU::byteswap(dst); - break; - } + case Mode::b32: { + auto& dst = op1.deref(); + dst = HyperCPU::byteswap(dst); + break; + } - case b64: { - 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 7751e572..03ad91a6 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALL.cpp @@ -1,30 +1,19 @@ -#include +#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 c70a1dc7..3fc88c96 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLE.cpp @@ -1,34 +1,22 @@ -#include +#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 08e0aeac..a021052c 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLGR.cpp @@ -1,34 +1,23 @@ -#include +#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 49414d2e..8f7db594 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CALLL.cpp @@ -1,34 +1,23 @@ -#include +#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 7415e6f9..3c091087 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CCRF.cpp @@ -1,13 +1,5 @@ -#include +#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 dccafe94..957ab3fb 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CMP.cpp @@ -1,213 +1,210 @@ -#include - -#include -#include - -#include +#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 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())); - break; - } + case Mode::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 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)); - break; - } + case Mode::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; - - 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 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 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; + + 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 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 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 Mode::b64: + res = StdALU::__hcpu_cmp(HyperCPU::bit_cast_from(op1.ptr()), mem_controller->Read64(ptr)); break; } + break; + } - 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; - - 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 b64: - res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr1), mem_controller->Read64(ptr2)); - 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::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; } + break; + } - case RM_R: { - std::uint64_t ptr = op1.deref(); + 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(ptr), HyperCPU::bit_cast_from(op2.ptr())); - 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(ptr), HyperCPU::bit_cast_from(op2.ptr())); - 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(ptr), HyperCPU::bit_cast_from(op2.ptr())); - 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(ptr), HyperCPU::bit_cast_from(op2.ptr())); - 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(); + + 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 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; - - 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; - } + 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; } + break; + } - case M_R: { - std::size_t ptr = HyperCPU::bit_cast(op1); + 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_from(op2.ptr())); - 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_from(op2.ptr())); - 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_from(op2.ptr())); - 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_from(op2.ptr())); - 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); - default: + switch (instr.m_opcode_mode) { + case Mode::b8: + res = StdALU::__hcpu_cmp(mem_controller->Read8(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; - } - switch (res) { - case -1: - zrf = 0; - crf = 1; + case Mode::b16: + res = StdALU::__hcpu_cmp(mem_controller->Read16(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; - case 0: - zrf = 1; - crf = 0; + + case Mode::b32: + res = StdALU::__hcpu_cmp(mem_controller->Read32(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; - case 1: - zrf = 0; - crf = 0; + + case Mode::b64: + res = StdALU::__hcpu_cmp(mem_controller->Read64(ptr), HyperCPU::bit_cast_from(op2.ptr())); break; + } + 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; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp b/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp index 41e6787f..462771ab 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/COVF.cpp @@ -1,13 +1,5 @@ -#include +#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 2f4b1cc5..6a22d7db 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/CUDF.cpp @@ -1,13 +1,5 @@ -#include +#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 4561af36..7c58789a 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/DEC.cpp @@ -1,41 +1,33 @@ -#include +#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 4b76b4ab..820f65b3 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/DIV.cpp @@ -1,50 +1,42 @@ -#include - -#include -#include -#include - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" +#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) { +void HyperCPU::CPU::ExecDIV(const IInstruction& instr, OperandContainer op1, OperandContainer /* op2 */) { if (!(*x2)) { TriggerInterrupt(cpu_exceptions::ZRDIV); return; } 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 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 b32: { - 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 b64: { - 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; } -} -#pragma GCC diagnostic pop + 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 beb5ae16..ec310cfb 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/HALT.cpp @@ -1,13 +1,5 @@ -#include +#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 4fd64f49..5d6ace53 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/HID.cpp @@ -1,26 +1,18 @@ -#include +#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 1c5c7298..0007a67b 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/INC.cpp @@ -1,41 +1,33 @@ -#include +#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 71cb764e..3a9f5d93 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/INTR.cpp @@ -1,22 +1,25 @@ -#include - -#include -#include - -#include - +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp" #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) { @@ -25,5 +28,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 fec958f7..c1bf4b95 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JME.cpp @@ -1,32 +1,19 @@ -#include +#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 diff --git a/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp index 6878635c..b47271db 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JMGR.cpp @@ -1,32 +1,19 @@ -#include +#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 4e7419c5..a935db40 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JML.cpp @@ -1,32 +1,19 @@ -#include +#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 d70137bd..022088d6 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/JMP.cpp @@ -1,28 +1,15 @@ -#include +#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 4e5a35c0..ef898fa5 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/LOIVT.cpp @@ -1,25 +1,15 @@ -#include +#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 6a094886..d873c6c5 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/MOV.cpp @@ -1,204 +1,199 @@ -#include +#include "Emulator/Core/CPU/CPU.hpp" -#include +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; -#include + case Mode::b16: + std::memcpy(op1, op2.ptr(), 2); + break; + case Mode::b32: + std::memcpy(op1, op2.ptr(), 4); + break; -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 b16: - std::memcpy(op1, op2.ptr(), 2); - break; - - case b32: - std::memcpy(op1, op2.ptr(), 4); - break; - - case b64: - std::memcpy(op1, op2.ptr(), 8); - break; - } - break; - } - - 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; - - 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; - } - break; - } - - case R_M: { - std::uint64_t ptr = op2; - - 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 b32: - *static_cast(op1) = mem_controller->Read32(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 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; - } - break; - } - - 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; - - case b16: - mem_controller->Load16(ptr1, mem_controller->Read16(ptr2)); - break; - - case b32: - mem_controller->Load32(ptr1, mem_controller->Read32(ptr2)); - break; - - case b64: - mem_controller->Load64(ptr1, mem_controller->Read64(ptr2)); - break; - } - break; - } - - case RM_R: { - std::uint64_t ptr = op1.deref(); - - 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 b32: { - mem_controller->Load32(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(); - - 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 b32: - mem_controller->Load32(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 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::b64: + std::memcpy(op1, op2.ptr(), 8); + break; + } + break; + } + + 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; + + case Mode::b16: + *static_cast(op1) = mem_controller->Read16(ptr); + break; + + case Mode::b32: + *static_cast(op1) = mem_controller->Read32(ptr); + break; + + case Mode::b64: + *static_cast(op1) = mem_controller->Read64(ptr); + break; + } + break; + } + + 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; + + case Mode::b16: + *static_cast(op1) = mem_controller->Read16(ptr); + break; + + case Mode::b32: + *static_cast(op1) = mem_controller->Read32(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 Mode::b16: + std::memcpy(op1, &op2.ref(), 2); + break; + + case Mode::b32: + std::memcpy(op1, &op2.ref(), 4); + 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; + + 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 b64: { - mem_controller->Load64(ptr1, HyperCPU::bit_cast_from(op2.ptr())); - break; - } - } - break; - } - - default: + case Mode::b32: + mem_controller->Load32(ptr1, mem_controller->Read32(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(); + + 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::b32: { + mem_controller->Load32(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(); + + 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::b32: + mem_controller->Load32(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 Mode::b16: { + mem_controller->Load16(ptr1, HyperCPU::bit_cast_from(op2.ptr())); + break; + } + + case Mode::b32: { + mem_controller->Load32(ptr1, HyperCPU::bit_cast_from(op2.ptr())); + break; + } + + 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 ac710823..177be42f 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/MUL.cpp @@ -1,147 +1,141 @@ -#include - -#include - -#include -#include - -#include -#include +#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 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 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 460d87f3..b8265ef9 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/OR.cpp @@ -1,128 +1,123 @@ -#include - -#include -#include - -#include - +#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 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; - } - } - break; - } - - default: + 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; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp b/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp index ae74fb70..7d56215a 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/POP.cpp @@ -1,27 +1,26 @@ -#include +#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(); break; - default: UNREACHABLE(); - } + 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: - UNREACHABLE(); + std::abort(); + } + break; + default: + 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 b2fcd438..822614da 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/PUSH.cpp @@ -1,37 +1,44 @@ -#include +#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)); break; - default: UNREACHABLE(); - } + 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: - UNREACHABLE(); + 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(); } } - -#pragma GCC diagnostic pop diff --git a/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp b/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp index 7de544ac..32acb6d0 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/READ.cpp @@ -1,30 +1,19 @@ -#include +#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 6969e596..73771961 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SHFL.cpp @@ -1,63 +1,58 @@ -#include - -#include - -#include - +#include "Emulator/Core/CPU/CPU.hpp" 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 OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; - case b16: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; + case Mode::b16: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; - case b32: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; + case Mode::b32: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); + break; - case b64: - op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); - break; - } + case Mode::b64: + op1.deref() <<= HyperCPU::bit_cast_from(op2.ptr()); 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 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 OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() <<= val; break; } - default: + 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; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp index c97183ac..27ffbb7a 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SHFR.cpp @@ -1,64 +1,58 @@ -#include - -#include -#include - -#include - +#include "Emulator/Core/CPU/CPU.hpp" 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 OperandTypes::R_R: { + switch (instr.m_opcode_mode) { + case Mode::b8: + op1.deref() >>= op2.deref(); + break; - case b16: - op1.deref() >>= op2.deref(); - break; + case Mode::b16: + op1.deref() >>= op2.deref(); + break; - case b32: - op1.deref() >>= op2.deref(); - break; + case Mode::b32: + op1.deref() >>= op2.deref(); + break; - case b64: - op1.deref() >>= op2.deref(); - break; - } + case Mode::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 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 OperandTypes::R_IMM: { + switch (instr.m_opcode_mode) { + case Mode::b8: { + std::uint8_t val = HyperCPU::bit_cast(op2); + op1.deref() >>= val; break; } - default: + 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; + } + + default: + break; } } diff --git a/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp b/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp index f3a8f8e1..18eaae71 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/SUB.cpp @@ -1,145 +1,141 @@ -#include - -#include -#include - -#include -#include +#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 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 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 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_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 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 Mode::b16: { + std::uint16_t val = mem_controller->Read16(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 Mode::b32: { + std::uint32_t val = mem_controller->Read32(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 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; } - default: + 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 ae38520e..26356d45 100644 --- a/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp +++ b/src/Emulator/Core/CPU/InstructionsImpl/WRITE.cpp @@ -1,29 +1,18 @@ -#include - -#include -#include -#include -#include - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" +#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 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 da072fb3..3c3ed6f5 100644 --- a/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp +++ b/src/Emulator/Core/CPU/Interrupts/InterruptHandler.cpp @@ -1,18 +1,16 @@ -#include - -#include -#include -#include -#include -#include +#include +#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()) { - 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)))); /* @@ -27,8 +25,9 @@ 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) { return; diff --git a/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp b/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp index e1b48bfb..cff97b36 100644 --- a/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp +++ b/src/Emulator/Core/CPU/Interrupts/ReservedInterrupts.hpp @@ -1,7 +1,6 @@ #pragma once -#include - +#include "PCH/CStd.hpp" namespace HyperCPU { enum class cpu_exceptions : std::uint_fast8_t { @@ -10,4 +9,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..efbba705 100644 --- a/src/Emulator/Core/CPU/OperandsEvaluation.cpp +++ b/src/Emulator/Core/CPU/OperandsEvaluation.cpp @@ -1,123 +1,163 @@ -#include - -#include -#include -#include -#include +#include "PCH/CStd.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) { - HyperCPU::Registers reg; - memcpy(®, &op1, sizeof(HyperCPU::Registers)); + HyperCPU::Reg reg; + memcpy(®, &op1, sizeof(HyperCPU::Reg)); 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 HyperCPU::Reg::X0: + return OperandContainer{x0}; + case HyperCPU::Reg::X1: + return OperandContainer{x1}; + case HyperCPU::Reg::X2: + return OperandContainer{x2}; + case HyperCPU::Reg::X3: + return OperandContainer{x3}; + case HyperCPU::Reg::X4: + return OperandContainer{x4}; + case HyperCPU::Reg::X5: + return OperandContainer{x5}; + case HyperCPU::Reg::X6: + return OperandContainer{x6}; + case HyperCPU::Reg::X7: + return OperandContainer{x7}; + + case HyperCPU::Reg::XH0: + return OperandContainer{xh0}; + case HyperCPU::Reg::XH1: + return OperandContainer{xh1}; + case HyperCPU::Reg::XH2: + return OperandContainer{xh2}; + case HyperCPU::Reg::XH3: + return OperandContainer{xh3}; + case HyperCPU::Reg::XH4: + return OperandContainer{xh4}; + case HyperCPU::Reg::XH5: + return OperandContainer{xh5}; + case HyperCPU::Reg::XH6: + return OperandContainer{xh6}; + case HyperCPU::Reg::XH7: + return OperandContainer{xh7}; + + case HyperCPU::Reg::XL0: + return OperandContainer{xl0}; + case HyperCPU::Reg::XL1: + return OperandContainer{xl1}; + case HyperCPU::Reg::XL2: + return OperandContainer{xl2}; + case HyperCPU::Reg::XL3: + return OperandContainer{xl3}; + case HyperCPU::Reg::XL4: + return OperandContainer{xl4}; + case HyperCPU::Reg::XL5: + return OperandContainer{xl5}; + case HyperCPU::Reg::XL6: + return OperandContainer{xl6}; + case HyperCPU::Reg::XL7: + return OperandContainer{xl7}; + + case HyperCPU::Reg::XLL0: + return OperandContainer{xll0}; + case HyperCPU::Reg::XLL1: + return OperandContainer{xll1}; + case HyperCPU::Reg::XLL2: + return OperandContainer{xll2}; + case HyperCPU::Reg::XLL3: + return OperandContainer{xll3}; + + case HyperCPU::Reg::XLLH0: + return OperandContainer{xllh0}; + case HyperCPU::Reg::XLLH1: + return OperandContainer{xllh1}; + case HyperCPU::Reg::XLLH2: + return OperandContainer{xllh2}; + case HyperCPU::Reg::XLLH3: + return OperandContainer{xllh3}; + + case HyperCPU::Reg::XLLL0: + return OperandContainer{xlll0}; + case HyperCPU::Reg::XLLL1: + return OperandContainer{xlll1}; + case HyperCPU::Reg::XLLL2: + return OperandContainer{xlll2}; + case HyperCPU::Reg::XLLL3: + return OperandContainer{xlll3}; + + case HyperCPU::Reg::XBP: + return OperandContainer{xbp}; + case HyperCPU::Reg::XSP: + return OperandContainer{xsp}; + case HyperCPU::Reg::XIP: + return OperandContainer{xip}; + case HyperCPU::Reg::XGDP: + return OperandContainer{xgdp}; + case HyperCPU::Reg::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 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 OperandTypes::RM_M: + case OperandTypes::R_M: + return std::make_pair(GetRegister(op1), op2); + + case OperandTypes::RM_IMM: + case OperandTypes::R_IMM: { + switch (md) { + 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 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 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 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)}); } - - 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; } + break; + } + + case OperandTypes::M_R: + return std::make_pair(op1, GetRegister(op2)); + + case OperandTypes::R: + return std::make_pair(GetRegister(op1), nullptr); + + case OperandTypes::IMM: + case OperandTypes::M: + return std::make_pair(op1, nullptr); - 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); - - case NONE: - return std::make_pair(nullptr, nullptr); - default: - ABORT(); + case OperandTypes::NONE: + return std::make_pair(nullptr, nullptr); + default: + std::abort(); } return {}; } diff --git a/src/Emulator/Core/CPU/Stack.cpp b/src/Emulator/Core/CPU/Stack.cpp index 739a6932..2415b4a0 100644 --- a/src/Emulator/Core/CPU/Stack.cpp +++ b/src/Emulator/Core/CPU/Stack.cpp @@ -1,8 +1,7 @@ -#include - -#include -#include +#include "PCH/CStd.hpp" +#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); }); @@ -62,4 +61,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..99a559fd 100644 --- a/src/Emulator/Core/MemoryController/IMemoryController.hpp +++ b/src/Emulator/Core/MemoryController/IMemoryController.hpp @@ -1,16 +1,19 @@ #pragma once -#include +#include +#include "PCH/CStd.hpp" -#define mem_ctlr_assert(expr) \ - do { \ +// TODO: позор партии, убрать и переделать в функцию +#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]] { } \ + spdlog::error("Assertion failed: {}", #expr); \ + std::abort(); \ + } else if (!(expr) && cpu && cpu->CanExecuteInterrupts()) { \ + cpu->TriggerInterrupt(HyperCPU::cpu_exceptions::SEGF); \ + } else [[likely]] { \ + } \ } while (false) namespace HyperCPU { @@ -26,14 +29,68 @@ 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 + 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 + 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 = typename loadTypeChooser, T>::type; + 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 = typename loadTypeChooser, T>::type; + 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 = typename loadTypeChooser, T>::type; + 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 = typename loadTypeChooser, T>::type; + 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 5beeb57c..98d71609 100644 --- a/src/Emulator/Core/MemoryController/MemoryControllerST.hpp +++ b/src/Emulator/Core/MemoryController/MemoryControllerST.hpp @@ -1,11 +1,9 @@ #pragma once -#include - -#include -#include -#include +#include "PCH/CStd.hpp" +#include "Emulator/Core/CPU/CPU.hpp" +#include "Emulator/Core/MemoryController/IMemoryController.hpp" namespace HyperCPU { class MemoryControllerST final : public IMemoryController { @@ -15,7 +13,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!"); @@ -80,30 +79,32 @@ 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)); } - 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/Main.cpp b/src/Emulator/Main.cpp similarity index 56% rename from src/Emulator/Main/Main.cpp rename to src/Emulator/Main.cpp index 7271cf04..a70fc7ac 100644 --- a/src/Emulator/Main/Main.cpp +++ b/src/Emulator/Main.cpp @@ -1,101 +1,14 @@ -#include - -#include -#include -#include -#include -#include -#include - #include -#ifdef HCPU_ENABLE_LIBUNWIND -#include -#endif - -HyperCPU::GenericHeader ParseHeader(std::ifstream& binary); +#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" -int main(int argc, char** argv) { #ifdef HCPU_ENABLE_LIBUNWIND - global_bt_controller = BacktraceController(argv[0]); - - std::signal(SIGSEGV, SignalHandler); - std::signal(SIGFPE, SignalHandler); +#include #endif - HyperCPU::Logger logger{HyperCPU::LogLevel::ERROR}; - argparse::ArgumentParser program("hcemul", HCPU_VERSION); - program.add_argument("binary") - .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"); - program.add_argument("-m", "--memory") - .default_value(std::string{"8K"}) - .help("max memory to use"); - - try { - program.parse_args(argc, argv); - } catch (const std::exception& err) { - std::cerr << err.what() << '\n'; - EXIT(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); - } 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); - } - - 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); - } - - switch (header.version) { - 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); - } - - std::unique_ptr buf(new char[binarysize]); - file.read(buf.get(), binarysize); - - auto memory = HyperCPU::ParseMemoryString(program.get("-m")); - if (memory == std::numeric_limits::max()) { - logger.Log(HyperCPU::LogLevel::ERROR, "Failed to parse memory amount argument."); - EXIT(1); - } - - HyperCPU::CPU cpu{1, memory, buf.get(), static_cast(binarysize)}; - - cpu.SetEntryPoint(header.entry_point); - cpu.Run(); -} HyperCPU::GenericHeader ParseHeader(std::ifstream& file) { HyperCPU::GenericHeader header; @@ -104,7 +17,7 @@ HyperCPU::GenericHeader ParseHeader(std::ifstream& file) { return header; } -std::uint64_t HyperCPU::ParseMemoryString(const std::string& str) { +std::uint64_t ParseMemoryString(const std::string& str) { if (str.empty()) { return std::numeric_limits::max(); } @@ -133,20 +46,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; @@ -161,3 +74,84 @@ std::uint64_t HyperCPU::ParseMemoryString(const std::string& str) { return result * multiplier; } + +int main(int argc, char** argv) { +#ifdef HCPU_ENABLE_LIBUNWIND + global_bt_controller = BacktraceController(argv[0]); + + std::signal(SIGSEGV, SignalHandler); + std::signal(SIGFPE, SignalHandler); +#endif + + argparse::ArgumentParser program("hcemul", HCPU_VERSION); + program.add_argument("binary") + .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"); + program.add_argument("-m", "--memory") + .default_value(std::string{"8K"}) + .help("max memory to use"); + + try { + program.parse_args(argc, argv); + } catch (const std::exception& err) { + std::cerr << err.what() << '\n'; + return 1; + } + + auto source = program.get("binary"); + if (!std::filesystem::exists(source)) { + spdlog::error("Binary \"{}\" does not exist!", source); + return 1; + } else if (!std::filesystem::is_regular_file(source)) { + 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) { + spdlog::error("Invalid magic!"); + return 1; + } + + switch (header.version) { + case HyperCPU::Version::PreRelease: + case HyperCPU::Version::Release1_0: + break; + default: + spdlog::error("Invalid release field!"); + return 1; + } + + switch (header.type) { + case HyperCPU::FileType::Binary: + break; + case HyperCPU::FileType::Object: + spdlog::error("Executing object files is not supported, please link it first!"); + return 1; + default: + spdlog::error("Invalid type field!"); + return 1; + } + + std::unique_ptr buf(new char[binarysize]); + file.read(buf.get(), binarysize); + + auto memory = ParseMemoryString(program.get("-m")); + if (memory == std::numeric_limits::max()) { + spdlog::error("Failed to parse memory amount argument."); + return 1; + } + + HyperCPU::CPU cpu{1, memory, buf.get(), static_cast(binarysize)}; + + cpu.SetEntryPoint(header.entry_point); + cpu.Run(); +} diff --git a/src/Emulator/Main/ExceptionHandling.cpp b/src/Emulator/Main/ExceptionHandling.cpp deleted file mode 100644 index 83308482..00000000 --- a/src/Emulator/Main/ExceptionHandling.cpp +++ /dev/null @@ -1,13 +0,0 @@ -#include - -#include
-#include - -#include -#include - - -[[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 deleted file mode 100644 index 48968374..00000000 --- a/src/Emulator/Main/ExceptionHandling.hpp +++ /dev/null @@ -1,10 +0,0 @@ -#pragma once - -#include - - -namespace HyperCPU { - class CPU; - - [[noreturn]] void ThrowError(CPU* cpu, std::string message); -} diff --git a/src/Emulator/Misc/bit_cast.hpp b/src/Emulator/Misc/bit_cast.hpp index 42651749..516edd4d 100644 --- a/src/Emulator/Misc/bit_cast.hpp +++ b/src/Emulator/Misc/bit_cast.hpp @@ -1,20 +1,16 @@ #pragma once -#include -#include - -#include - +#include "PCH/CStd.hpp" 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 +18,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 a6582a0b..2667bc05 100644 --- a/src/Emulator/Misc/byteswap.hpp +++ b/src/Emulator/Misc/byteswap.hpp @@ -1,14 +1,13 @@ #pragma once -#include - -#include +#include "Emulator/Misc/bit_cast.hpp" +#include "PCH/CStd.hpp" 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..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 + template constexpr T& deref(std::uint64_t ptr) { return *static_cast(ptr); } -} \ No newline at end of file +} // namespace HyperCPU diff --git a/src/Emulator/Misc/overflow.hpp b/src/Emulator/Misc/overflow.hpp index bd2e8bce..487ee116 100644 --- a/src/Emulator/Misc/overflow.hpp +++ b/src/Emulator/Misc/overflow.hpp @@ -1,7 +1,6 @@ #pragma once -#include - +#include "PCH/CStd.hpp" namespace HyperCPU { template @@ -9,8 +8,8 @@ namespace HyperCPU { 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..e15766b5 100644 --- a/src/Emulator/Misc/print.hpp +++ b/src/Emulator/Misc/print.hpp @@ -1,16 +1,17 @@ #pragma once -#include #include +#include "PCH/CStd.hpp" + 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/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/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/PCH/BUILD.bazel b/src/PCH/BUILD.bazel new file mode 100644 index 00000000..123b0274 --- /dev/null +++ b/src/PCH/BUILD.bazel @@ -0,0 +1,7 @@ +load("//tools/bazel:pch.bzl", "precompiled_headers") + +precompiled_headers( + name = "pch_cstd", + main = "CStd.hpp", + visibility = ["//visibility:public"], +) 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/Action.hpp b/src/Pog/Action.hpp index 26ba034a..7ca65a74 100644 --- a/src/Pog/Action.hpp +++ b/src/Pog/Action.hpp @@ -1,28 +1,25 @@ #pragma once -#include #include -#include -#include +#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 731129c5..7fe8c9e1 100644 --- a/src/Pog/Automaton.hpp +++ b/src/Pog/Automaton.hpp @@ -6,154 +6,143 @@ #include -#include -#include -#include +#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/BUILD.bazel b/src/Pog/BUILD.bazel new file mode 100644 index 00000000..5cd65d04 --- /dev/null +++ b/src/Pog/BUILD.bazel @@ -0,0 +1,24 @@ +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"], + ), + visibility = ["//visibility:private"], + deps = [ + "@fmt", + "@re2", + ], +) + +precompiled_headers( + name = "pog", + main = "Pog.hpp", + visibility = ["//visibility:public"], + deps = [ + ":pog_core", + ], +) 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 5b517005..df7eead6 100644 --- a/src/Pog/Errors.hpp +++ b/src/Pog/Errors.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include #include @@ -7,57 +8,61 @@ #include #include -#include -#include +#include "Pog/Symbol.hpp" 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 6cdc4a54..af37d8a0 100644 --- a/src/Pog/Grammar.hpp +++ b/src/Pog/Grammar.hpp @@ -4,285 +4,247 @@ #include #include -#include -#include -#include -#include -#include +#include "Pog/LineSpecialization.hpp" +#include "Pog/Rule.hpp" +#include "Pog/Symbol.hpp" +#include "Pog/Token.hpp" +#include "Pog/Utils.hpp" 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 fc2edd40..2fe5d338 100644 --- a/src/Pog/HTMLReport.hpp +++ b/src/Pog/HTMLReport.hpp @@ -2,24 +2,24 @@ #include -#include +#include "Pog/Parser.hpp" 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 3d860010..771b0e58 100644 --- a/src/Pog/Item.hpp +++ b/src/Pog/Item.hpp @@ -1,140 +1,127 @@ #pragma once #include -#include -#include #include -#include -#include +#include "Pog/Rule.hpp" 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 34dd6bc2..6dbed4d9 100644 --- a/src/Pog/Operations/Follow.hpp +++ b/src/Pog/Operations/Follow.hpp @@ -1,56 +1,55 @@ #pragma once -#include -#include -#include -#include -#include +#include "Pog/DigraphAlgo.hpp" +#include "Pog/Operations/Operation.hpp" +#include "Pog/Operations/Read.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 4de7c0fc..15b768ed 100644 --- a/src/Pog/Operations/Lookahead.hpp +++ b/src/Pog/Operations/Lookahead.hpp @@ -1,75 +1,70 @@ #pragma once -#include -#include -#include -#include +#include "Pog/Operations/Follow.hpp" +#include "Pog/Operations/Operation.hpp" +#include "Pog/Relations/Lookback.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*>; + /** + * 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; + using AutomatonType = Automaton; + using GrammarType = Grammar; - using StateAndRuleType = StateAndRule; + using StateAndRuleType = StateAndRule; - // 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; + // 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; - 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; + 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())); - } - } - } + // 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 c4f323ab..4142ea6a 100644 --- a/src/Pog/Operations/Operation.hpp +++ b/src/Pog/Operations/Operation.hpp @@ -3,52 +3,55 @@ #include #include -#include -#include +#include "Pog/Automaton.hpp" +#include "Pog/Grammar.hpp" 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 dfb8c610..7aa4b94d 100644 --- a/src/Pog/Operations/Read.hpp +++ b/src/Pog/Operations/Read.hpp @@ -1,70 +1,67 @@ #pragma once -#include -#include +#include "Pog/Operations/Operation.hpp" +#include "Pog/Types/StateAndSymbol.hpp" 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 2a7243e2..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 -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include +#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/RuleBuilder.hpp" +#include "Pog/State.hpp" +#include "Pog/Symbol.hpp" +#include "Pog/TokenBuilder.hpp" +#include "Pog/Tokenizer.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 ebe8fa98..f9602c37 100644 --- a/src/Pog/ParserReport.hpp +++ b/src/Pog/ParserReport.hpp @@ -5,85 +5,88 @@ #include -#include -#include +#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 8abc1fc0..354b6635 100644 --- a/src/Pog/ParsingTable.hpp +++ b/src/Pog/ParsingTable.hpp @@ -2,169 +2,148 @@ #include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "Pog/Action.hpp" +#include "Pog/Automaton.hpp" +#include "Pog/Grammar.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/Pog.hpp b/src/Pog/Pog.hpp index 3651c84d..fcd4bec2 100644 --- a/src/Pog/Pog.hpp +++ b/src/Pog/Pog.hpp @@ -2,5 +2,5 @@ #define POG_VERSION "0.5.3" -#include -#include +#include "Pog/HTMLReport.hpp" +#include "Pog/Parser.hpp" 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 191b2db2..a4736871 100644 --- a/src/Pog/Relations/Includes.hpp +++ b/src/Pog/Relations/Includes.hpp @@ -4,145 +4,135 @@ #include -#include -#include +#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 925edc01..f3520dca 100644 --- a/src/Pog/Relations/Lookback.hpp +++ b/src/Pog/Relations/Lookback.hpp @@ -2,115 +2,109 @@ #include -#include -#include -#include +#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 d4313b5c..b8b154e2 100644 --- a/src/Pog/Relations/Relation.hpp +++ b/src/Pog/Relations/Relation.hpp @@ -3,62 +3,68 @@ #include #include -#include -#include +#include "Pog/Automaton.hpp" +#include "Pog/Grammar.hpp" 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 01fe7f9c..c2368000 100644 --- a/src/Pog/Rule.hpp +++ b/src/Pog/Rule.hpp @@ -9,86 +9,113 @@ #include #include -#include -#include -#include +#include "Pog/LineSpecialization.hpp" +#include "Pog/Symbol.hpp" 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 813d953b..bb822a58 100644 --- a/src/Pog/RuleBuilder.hpp +++ b/src/Pog/RuleBuilder.hpp @@ -1,140 +1,125 @@ #pragma once -#include -#include +#include "Pog/Grammar.hpp" +#include "Pog/Rule.hpp" 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 ad9ba829..e8f6f963 100644 --- a/src/Pog/State.hpp +++ b/src/Pog/State.hpp @@ -1,157 +1,150 @@ #pragma once -#include -#include +#include +#include -#include -#include -#include +#include "Pog/FilterView.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 3f913902..bd10d621 100644 --- a/src/Pog/Symbol.hpp +++ b/src/Pog/Symbol.hpp @@ -1,56 +1,71 @@ #pragma once -#include #include #include -#include -#include +#include "Pog/Precedence.hpp" 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 0134d04f..239f95d7 100644 --- a/src/Pog/Token.hpp +++ b/src/Pog/Token.hpp @@ -7,75 +7,85 @@ #include -#include +#include "Pog/Symbol.hpp" 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 a4c01c66..1cf37541 100644 --- a/src/Pog/TokenBuilder.hpp +++ b/src/Pog/TokenBuilder.hpp @@ -1,112 +1,103 @@ #pragma once -#include -#include -#include +#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 d61265b0..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 -#include -#include +#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; } - }; - } - 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; -}; + + 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)}}; + } 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 2a8cc2a2..051fc755 100644 --- a/src/Pog/Types/StateAndRule.hpp +++ b/src/Pog/Types/StateAndRule.hpp @@ -1,38 +1,33 @@ #pragma once -#include -#include +#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 271124f6..a59b9716 100644 --- a/src/Pog/Types/StateAndSymbol.hpp +++ b/src/Pog/Types/StateAndSymbol.hpp @@ -1,38 +1,33 @@ #pragma once -#include -#include +#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/BUILD.bazel b/tests/BUILD.bazel new file mode 100644 index 00000000..4a50d10c --- /dev/null +++ b/tests/BUILD.bazel @@ -0,0 +1,24 @@ +load("@rules_cc//cc:defs.bzl", "cc_library") +load("//tools/bazel:pch.bzl", "precompiled_headers") + +package( + default_visibility = [ + "//tests:__subpackages__", + ], +) + +precompiled_headers( + name = "pch_gtest", + main = "gtest.hpp", + deps = [ + "@gtest//:gtest-libgtest", + ], +) + +cc_library( + name = "test_fixtures", + hdrs = ["fixtures.hpp"], + deps = [ + "//src/PCH:pch_cstd", + ], +) 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/AssemblerCore/AssemblerFail.cpp b/tests/Integration/AssemblerCore/AssemblerFail.cpp index 729337be..c7a37fab 100644 --- a/tests/Integration/AssemblerCore/AssemblerFail.cpp +++ b/tests/Integration/AssemblerCore/AssemblerFail.cpp @@ -1,81 +1,71 @@ -#include +#include "PCH/CStd.hpp" +#include "tests/fixtures.hpp" -#include - -#ifdef __HCPU_DEBUG -# define HCPU_ASSERT_EXIT(statement, x, regex) ASSERT_DEATH(statement, regex) +#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) +#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..151d4160 100644 --- a/tests/Integration/AssemblerCore/AssemblerSuccess.cpp +++ b/tests/Integration/AssemblerCore/AssemblerSuccess.cpp @@ -1,9 +1,4 @@ -#include -#include -#include -#include - -#include +#include "tests/fixtures.hpp" TEST_F(ASSEMBLER, ASM_R_R_b8) { std::string data = "mov xlll0, xlll1;"; @@ -22,12 +17,12 @@ 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); - 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) { @@ -48,12 +43,12 @@ 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); - 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) { @@ -74,12 +69,12 @@ 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); - 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) { @@ -100,12 +95,12 @@ 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); - 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) { @@ -126,12 +121,12 @@ 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); - 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) { @@ -152,12 +147,12 @@ 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); - 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) { @@ -178,12 +173,12 @@ 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); - 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) { @@ -204,12 +199,12 @@ 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); - 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) { @@ -230,12 +225,12 @@ 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); 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) { @@ -256,12 +251,12 @@ 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); 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) { @@ -282,12 +277,12 @@ 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); 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) { @@ -308,12 +303,12 @@ 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); 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) { @@ -334,12 +329,12 @@ 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); 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) { @@ -360,12 +355,12 @@ 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); 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) { @@ -386,12 +381,12 @@ 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); 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) { @@ -412,12 +407,12 @@ 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); 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) { @@ -438,12 +433,12 @@ 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); - 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) { @@ -464,12 +459,12 @@ 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); - 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) { @@ -490,12 +485,12 @@ 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); - 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) { @@ -516,12 +511,12 @@ 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); - 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) { @@ -542,12 +537,12 @@ 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); 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) { @@ -568,12 +563,12 @@ 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); 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) { @@ -594,12 +589,12 @@ 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); 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) { @@ -620,12 +615,12 @@ 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); 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) { @@ -646,12 +641,12 @@ 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); 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) { @@ -672,12 +667,12 @@ 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); 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) { @@ -698,12 +693,12 @@ 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); 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) { @@ -724,12 +719,12 @@ 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); 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) { @@ -747,15 +742,15 @@ 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); 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) { @@ -773,15 +768,15 @@ 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); 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) { @@ -799,15 +794,15 @@ 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); 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) { @@ -825,15 +820,15 @@ 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); 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) { @@ -852,7 +847,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,12 +872,12 @@ 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); 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) { @@ -903,12 +898,12 @@ 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); 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 +928,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 +1010,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 5d8c3a45..58b5828b 100644 --- a/tests/Integration/AssemblerCore/FullAssembler.cpp +++ b/tests/Integration/AssemblerCore/FullAssembler.cpp @@ -1,13 +1,10 @@ -#include -#include "Main/Main.hpp" -#include "Misc/bit_cast.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;"; std::uint32_t code_size; auto binary = compiler.Compile(data, code_size); - + { std::ofstream file("test", std::ios::binary); @@ -28,19 +25,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; } @@ -49,7 +46,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); @@ -70,17 +67,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 90a0768b..d820de84 100644 --- a/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp +++ b/tests/Integration/AssemblerCore/TwoOperandsSuccess.cpp @@ -1,5 +1,4 @@ -#include -#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..f5269665 --- /dev/null +++ b/tests/Integration/BUILD.bazel @@ -0,0 +1,16 @@ +load("@rules_cc//cc:defs.bzl", "cc_test") + +cc_test( + name = "integration-test", + srcs = glob(["**/*.cpp"]), + linkstatic = True, + deps = [ + "//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/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/Integration/EmulatorCore/CPU/CPU_ADC.cpp b/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp index 7d514a5b..693b63c0 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ADC.cpp @@ -1,8 +1,4 @@ -#include -#include - -#include - +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; @@ -32,9 +28,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, 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; @@ -48,9 +44,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, 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; @@ -64,9 +60,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, 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; @@ -80,9 +76,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, 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; @@ -96,9 +92,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, 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; @@ -113,9 +109,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, 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; @@ -130,9 +126,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, 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; @@ -147,9 +143,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, 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; @@ -164,8 +160,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, 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); @@ -180,8 +176,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, 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); @@ -196,8 +192,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, 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); @@ -212,8 +208,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, 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); @@ -228,8 +224,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, 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); @@ -243,8 +239,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, 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); @@ -258,8 +254,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, 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); @@ -273,8 +269,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, 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); @@ -288,9 +284,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, 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; @@ -305,9 +301,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, 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; @@ -322,9 +318,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, 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; @@ -339,9 +335,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, 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; @@ -356,9 +352,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, 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; @@ -374,9 +370,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, 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; @@ -392,9 +388,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, 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; @@ -410,9 +406,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, 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; @@ -428,8 +424,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, 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); @@ -445,8 +441,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, 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); @@ -462,8 +458,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, 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); @@ -479,8 +475,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, 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); @@ -496,8 +492,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, 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); @@ -512,8 +508,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, 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); @@ -528,8 +524,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, 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); @@ -544,8 +540,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, 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_ADD.cpp b/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp index a32356b9..42461a62 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ADD.cpp @@ -1,8 +1,4 @@ -#include -#include - -#include - +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x55; static constexpr std::uint8_t BYTE_DATA2 = 0x60; @@ -32,9 +28,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, 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; @@ -47,9 +43,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, 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; @@ -62,9 +58,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, 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; @@ -77,9 +73,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, 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; @@ -92,9 +88,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, 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; @@ -108,9 +104,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, 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; @@ -124,9 +120,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, 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; @@ -140,9 +136,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, 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; @@ -156,8 +152,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, 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); @@ -171,8 +167,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, 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); @@ -186,8 +182,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, 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); @@ -201,8 +197,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, 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); @@ -216,8 +212,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, 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); @@ -230,8 +226,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, 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); @@ -244,8 +240,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, 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); @@ -258,8 +254,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, 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); @@ -272,9 +268,9 @@ 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 + 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; @@ -288,9 +284,9 @@ 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 + 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; @@ -304,9 +300,9 @@ 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 + 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; @@ -320,9 +316,9 @@ 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 + 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; @@ -336,9 +332,9 @@ 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 + 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; @@ -353,9 +349,9 @@ 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 + 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; @@ -370,9 +366,9 @@ 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 + 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; @@ -387,9 +383,9 @@ 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 + 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; @@ -404,8 +400,8 @@ 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 + 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); @@ -420,8 +416,8 @@ 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 + 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); @@ -436,8 +432,8 @@ 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 + 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); @@ -452,8 +448,8 @@ 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 + 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); @@ -468,8 +464,8 @@ 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 + 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); @@ -483,8 +479,8 @@ 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 + 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); @@ -498,8 +494,8 @@ 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 + 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); @@ -513,8 +509,8 @@ 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 + 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_AND.cpp b/tests/Integration/EmulatorCore/CPU/CPU_AND.cpp index f43802e5..317374b8 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_AND.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_AND.cpp @@ -1,8 +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; @@ -19,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; @@ -34,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; @@ -49,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; @@ -64,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; @@ -79,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; @@ -95,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; @@ -111,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; @@ -127,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; @@ -143,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); @@ -158,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); @@ -173,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); @@ -188,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); @@ -203,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); @@ -217,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); @@ -231,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); @@ -245,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 7a8c538e..abefd4a0 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_ANDN.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_ANDN.cpp @@ -1,8 +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; @@ -19,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; @@ -34,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; @@ -49,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; @@ -64,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; @@ -79,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; @@ -95,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; @@ -111,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; @@ -127,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; @@ -143,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); @@ -158,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); @@ -173,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); @@ -188,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); @@ -203,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); @@ -217,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); @@ -231,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); @@ -245,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 556581a9..286985b8 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_BSWAP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_BSWAP.cpp @@ -1,11 +1,10 @@ #include -#include -#include -#include - -#include +#include "Emulator/Misc/byteswap.hpp" +#include +#include +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA1 = 0x12; static constexpr std::uint8_t BYTE_RESULT = BYTE_DATA1; @@ -18,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; @@ -31,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; @@ -44,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; @@ -57,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 32b4eef2..18c856bb 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALL.cpp @@ -1,13 +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; @@ -21,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::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_CALLE.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CALLE.cpp index ba8194a8..05bfc830 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALLE.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALLE.cpp @@ -1,68 +1,68 @@ -#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->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, 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; + *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, 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); + 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, 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); + *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, 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); + 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); -} \ No newline at end of file + ASSERT_EQ(*cpu.xip, 14); +} diff --git a/tests/Integration/EmulatorCore/CPU/CPU_CALLGR.cpp b/tests/Integration/EmulatorCore/CPU/CPU_CALLGR.cpp index 63e746d8..b7037654 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALLGR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALLGR.cpp @@ -1,20 +1,18 @@ -#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; *cpu.xsp = *cpu.xbp; *cpu.x0 = 1536; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -22,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); @@ -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); @@ -41,14 +38,13 @@ 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); *cpu.xbp = 512; *cpu.xsp = *cpu.xbp; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -56,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); @@ -66,8 +62,7 @@ TEST_F(CPU_TEST, INSTR_CALLGR_IMM_FALSE) { *cpu.xsp = *cpu.xbp; cpu.zrf = 1; - 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 54ff3b43..695358a8 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CALLL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CALLL.cpp @@ -1,13 +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; @@ -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); @@ -23,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); @@ -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); @@ -41,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); @@ -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); @@ -57,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); @@ -66,8 +62,7 @@ TEST_F(CPU_TEST, INSTR_CALLL_IMM_FALSE) { *cpu.xbp = 512; *cpu.xsp = *cpu.xbp; - 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 300409c9..f5a81b99 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CCRF.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CCRF.cpp @@ -1,8 +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 27289628..0aefabcf 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CMP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CMP.cpp @@ -1,14 +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; @@ -22,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; @@ -38,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; @@ -54,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; @@ -70,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; @@ -86,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; @@ -102,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; @@ -118,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; @@ -134,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; @@ -150,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; @@ -166,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; @@ -182,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; @@ -198,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); @@ -215,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); @@ -232,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); @@ -249,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); @@ -266,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); @@ -283,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); @@ -300,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); @@ -317,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); @@ -334,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); @@ -351,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); @@ -368,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); @@ -385,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); @@ -402,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); @@ -418,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); @@ -434,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); @@ -450,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); @@ -466,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); @@ -482,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); @@ -498,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); @@ -514,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); @@ -530,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); @@ -546,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); @@ -562,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); @@ -578,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); @@ -594,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); @@ -609,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); @@ -624,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); @@ -639,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); @@ -654,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); @@ -669,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); @@ -684,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); @@ -699,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); @@ -714,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); @@ -729,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); @@ -744,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); @@ -759,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); @@ -774,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); @@ -791,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); @@ -808,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); @@ -825,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); @@ -842,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); @@ -859,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); @@ -876,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); @@ -893,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); @@ -910,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); @@ -927,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); @@ -944,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); @@ -961,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); @@ -978,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); @@ -995,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); @@ -1012,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); @@ -1029,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); @@ -1046,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); @@ -1063,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); @@ -1080,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); @@ -1097,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); @@ -1114,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); @@ -1131,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); @@ -1148,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); @@ -1165,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); @@ -1181,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); @@ -1197,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); @@ -1213,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); @@ -1229,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); @@ -1245,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); @@ -1261,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); @@ -1277,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); @@ -1293,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); @@ -1309,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); @@ -1325,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); @@ -1341,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 5fa1e63c..a707b687 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_COVF.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_COVF.cpp @@ -1,8 +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 d8627354..60ae2432 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_CUDF.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_CUDF.cpp @@ -1,8 +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 49c3e030..ef8b5a02 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_DEC.cpp @@ -1,8 +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; @@ -20,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)); + 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; @@ -34,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)); + 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; @@ -48,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; @@ -62,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; @@ -76,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)); + 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; @@ -90,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)); + 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; @@ -104,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; @@ -118,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; @@ -128,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 42360aa9..3e02fff9 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_DIV.cpp @@ -1,8 +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; @@ -26,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)); + 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; @@ -41,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)); + 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; @@ -56,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; @@ -71,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 d4aafeaa..b9e3eca3 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_HID.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_HID.cpp @@ -1,9 +1,6 @@ -#include -#include -#include - -#include +#include "Emulator/Core/CPU/Version.hpp" +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_HID_0) { cpu.mem_controller->Load16(*cpu.xip, HyperCPU::Opcode::HID); @@ -39,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 251604a5..8bdaaec0 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_INC.cpp @@ -1,8 +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; @@ -20,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)); + 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; @@ -34,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)); + 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; @@ -48,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; @@ -62,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; @@ -76,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)); + 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; @@ -90,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)); + 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; @@ -104,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; @@ -118,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; @@ -128,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 3405dd32..4c1eb166 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_INTR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_INTR.cpp @@ -1,23 +1,22 @@ -#include -#include - -#include +#include +#include +#include "tests/fixtures.hpp" 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); - 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 c8d0fabc..1c344c4f 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_IRET.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_IRET.cpp @@ -1,8 +1,7 @@ -#include -#include - -#include +#include +#include +#include "tests/fixtures.hpp" TEST_F(CPU_TEST, INSTR_IRET_NONE) { *cpu.xbp = 512; @@ -17,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 aaa25822..54eb5459 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_JME.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_JME.cpp @@ -1,19 +1,17 @@ -#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; cpu.zrf = 1; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -21,15 +19,14 @@ 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); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1536; - cpu.Run(); ASSERT_EQ(*cpu.xip, 7); @@ -37,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); @@ -50,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); @@ -60,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 776a15b4..c4429896 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_JMGR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_JMGR.cpp @@ -1,18 +1,16 @@ -#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; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -20,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); @@ -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); @@ -37,12 +34,11 @@ 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); - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -50,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); @@ -58,8 +54,7 @@ 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); -} \ 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 290b8bf2..568255da 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_JML.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_JML.cpp @@ -1,19 +1,14 @@ -#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; cpu.crf = 1; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -21,15 +16,14 @@ 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); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); *cpu.x0 = 1536; - cpu.Run(); ASSERT_EQ(*cpu.xip, 7); @@ -37,13 +31,12 @@ 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); cpu.crf = 1; - cpu.Run(); ASSERT_EQ(*cpu.xip, 1539); @@ -51,15 +44,14 @@ 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); cpu.mem_controller->Load16(1536, HyperCPU::Opcode::HALT); cpu.mem_controller->Load8(1538, HyperCPU::OperandTypes::NONE); - 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 28637e6f..67a25284 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_JMP.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_JMP.cpp @@ -1,13 +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; @@ -19,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 49a45896..0418ea31 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_LOIVT.cpp @@ -1,13 +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)); + 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 d948bf8e..cdda494a 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_MOV.cpp @@ -1,8 +1,4 @@ -#include -#include - -#include - +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA = 0x55; static constexpr std::uint16_t WORD_DATA = 0x5555; @@ -12,8 +8,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; @@ -25,8 +22,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; @@ -38,8 +36,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; @@ -51,9 +50,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; @@ -65,9 +64,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); @@ -80,9 +79,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); @@ -95,9 +94,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); @@ -110,9 +109,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); @@ -125,8 +124,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); @@ -140,8 +139,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); @@ -155,8 +154,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); @@ -170,8 +169,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); @@ -185,8 +184,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); @@ -198,8 +197,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); @@ -211,8 +210,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); @@ -224,8 +223,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); @@ -237,9 +236,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; @@ -252,9 +251,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; @@ -267,9 +266,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; @@ -282,9 +281,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; @@ -297,8 +296,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); @@ -312,8 +311,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); @@ -327,8 +326,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); @@ -342,12 +341,12 @@ 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); - cpu.mem_controller->Load64(1536, QWORD_DATA); + cpu.mem_controller->Load64(1536, QWORD_DATA); *cpu.x0 = 1024; cpu.Run(); @@ -357,9 +356,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; @@ -371,9 +370,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; @@ -385,9 +384,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; @@ -399,9 +398,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 a65bc03a..898372db 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_MUL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_MUL.cpp @@ -1,8 +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; @@ -32,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; @@ -47,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; @@ -62,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; @@ -77,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; @@ -92,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; @@ -108,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; @@ -124,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; @@ -140,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; @@ -156,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); @@ -171,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); @@ -186,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); @@ -201,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); @@ -216,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); @@ -230,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); @@ -244,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); @@ -258,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); @@ -272,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; @@ -288,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; @@ -304,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; @@ -320,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; @@ -336,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; @@ -353,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; @@ -370,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; @@ -387,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; @@ -404,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); @@ -420,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); @@ -436,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); @@ -452,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); @@ -468,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); @@ -483,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); @@ -498,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); @@ -513,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 d0657921..840cd780 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_OR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_OR.cpp @@ -1,8 +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; @@ -19,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; @@ -34,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; @@ -49,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; @@ -64,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; @@ -79,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; @@ -95,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; @@ -111,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; @@ -127,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; @@ -143,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); @@ -158,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); @@ -173,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); @@ -188,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); @@ -203,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); @@ -217,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); @@ -231,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); @@ -245,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 c3f0e279..9934b5cb 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 -#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)); + 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)); + 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; @@ -73,4 +68,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..88230582 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 -#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)); + 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)); + 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); @@ -125,4 +121,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..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 -#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 7b5d500c..40601912 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_SHFL.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_SHFL.cpp @@ -1,8 +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; @@ -19,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; @@ -34,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; @@ -49,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; @@ -64,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; @@ -79,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); @@ -93,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); @@ -107,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); @@ -121,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 a32049aa..774046b3 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_SHFR.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_SHFR.cpp @@ -1,8 +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; @@ -19,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; @@ -34,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; @@ -49,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; @@ -64,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; @@ -79,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); @@ -93,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); @@ -107,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); @@ -121,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 43670814..65180c8d 100644 --- a/tests/Integration/EmulatorCore/CPU/CPU_SUB.cpp +++ b/tests/Integration/EmulatorCore/CPU/CPU_SUB.cpp @@ -1,8 +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; @@ -32,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; @@ -47,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; @@ -62,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; @@ -77,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; @@ -92,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; @@ -108,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; @@ -124,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; @@ -140,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; @@ -156,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); @@ -171,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); @@ -186,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); @@ -201,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); @@ -216,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); @@ -230,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); @@ -244,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); @@ -258,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); @@ -272,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; @@ -288,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; @@ -304,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; @@ -320,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; @@ -336,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; @@ -353,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; @@ -370,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; @@ -387,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; @@ -404,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); @@ -420,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); @@ -436,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); @@ -452,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); @@ -468,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); @@ -483,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); @@ -498,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); @@ -513,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 a22b25d9..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 -#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 8c69565f..f60a7c53 100644 --- a/tests/Integration/EmulatorCore/CPU/OperandsEvaluation.cpp +++ b/tests/Integration/EmulatorCore/CPU/OperandsEvaluation.cpp @@ -1,178 +1,177 @@ -#include -#include - -#include +#include "Emulator/Core/CPU/Decoders/StdDecoder.hpp" +#include +#include "tests/fixtures.hpp" TEST_F(OPERAND_EVAL_TEST, PROPER_REGISTERS_EVALUATION) { HyperCPU::OperandContainer arg = 0; - HyperCPU::Registers reg; - - reg = HyperCPU::Registers::X0; + HyperCPU::Reg reg; + + 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)}; - 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); @@ -180,12 +179,12 @@ 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)}; - 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); @@ -193,12 +192,12 @@ 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)}; - 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); @@ -206,11 +205,11 @@ 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, - 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()); @@ -218,11 +217,11 @@ 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, - 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()); @@ -231,12 +230,12 @@ 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)}; - 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); @@ -246,11 +245,11 @@ 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, - 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); @@ -260,12 +259,12 @@ 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)}; - 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); @@ -275,12 +274,12 @@ 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)}; - 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); @@ -290,12 +289,12 @@ 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)}; - 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); @@ -305,12 +304,12 @@ 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)}; - 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); @@ -320,12 +319,12 @@ 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)}; - 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); @@ -335,12 +334,12 @@ 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)}; - 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); @@ -349,11 +348,11 @@ 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, - 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); @@ -361,11 +360,11 @@ 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, - 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,8 +384,8 @@ 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); -} \ No newline at end of file +} diff --git a/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp b/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp index e791b13e..c3fa62ef 100644 --- a/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp +++ b/tests/Integration/EmulatorCore/Exceptions/Exceptions.cpp @@ -1,8 +1,4 @@ -#include -#include - -#include - +#include "tests/fixtures.hpp" TEST_F(EXCEPTION_TEST, CPU_EXCEPTION_IO) { cpu.mem_controller->Load16(*cpu.xip, 8273); @@ -13,9 +9,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/Modular/AssemblerCore/Parser/Operands.cpp b/tests/Modular/AssemblerCore/Parser/Operands.cpp index 755023a9..53ae4eca 100644 --- a/tests/Modular/AssemblerCore/Parser/Operands.cpp +++ b/tests/Modular/AssemblerCore/Parser/Operands.cpp @@ -1,186 +1,186 @@ -#include +#include "tests/fixtures.hpp" 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::Reg::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::Reg::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::Reg::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::Reg::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::Reg::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::Reg::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::Reg::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::Reg::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::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 3e2f4452..17739916 100644 --- a/tests/Modular/AssemblerCore/Parser/Statements.cpp +++ b/tests/Modular/AssemblerCore/Parser/Statements.cpp @@ -1,6 +1,4 @@ -#include - -#include +#include "tests/fixtures.hpp" TEST_F(ASM_PARSER_STMT_TEST, STMT1) { std::string data = "adc x0, x1;"; @@ -11,12 +9,12 @@ 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); + 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) { @@ -28,9 +26,9 @@ 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); + EXPECT_EQ(instr.op1.reg, HyperCPU::Reg::X0); EXPECT_EQ(instr.op2.type, HCAsm::OperandType::none); } @@ -44,7 +42,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..8d689db9 100644 --- a/tests/Modular/AssemblerCore/Parser/Tokens.cpp +++ b/tests/Modular/AssemblerCore/Parser/Tokens.cpp @@ -1,95 +1,94 @@ -#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\\\\"; - 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 +97,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/BUILD.bazel b/tests/Modular/BUILD.bazel new file mode 100644 index 00000000..04a2b0bd --- /dev/null +++ b/tests/Modular/BUILD.bazel @@ -0,0 +1,19 @@ +load("@rules_cc//cc:defs.bzl", "cc_test") + +cc_test( + name = "modular-test", + # TODO: remove when tests are fixed + srcs = glob( + ["**/*.cpp"] + ), + linkstatic = True, + deps = [ + "//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/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/Modular/EmulatorCore/CPUInit/CPUInit.cpp b/tests/Modular/EmulatorCore/CPUInit/CPUInit.cpp index 57ee3cc3..3ac06a43 100644 --- a/tests/Modular/EmulatorCore/CPUInit/CPUInit.cpp +++ b/tests/Modular/EmulatorCore/CPUInit/CPUInit.cpp @@ -1,8 +1,4 @@ -#include "Logger/Logger.hpp" -#include - -#define private public -#include +#include "tests/fixtures.hpp" static constexpr std::uint64_t FULL_CONST = 0x0001020304050607; static constexpr std::uint32_t CONSTH = 0x00010203; @@ -12,7 +8,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/ADCInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/ADCInstr/R_IMM.cpp index 93367eef..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 - -#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); -} \ 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..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 - -#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,8 +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); } \ 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 fea4eb62..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 - -#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); -} \ No newline at end of file + 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 2969d0d9..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 - -#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); -} \ No newline at end of file + 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 7842368c..7bcc5c94 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADCInstr/Unsupported.cpp @@ -1,270 +1,266 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..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 - -#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); -} \ 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..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 - -#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,8 +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); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/ADDInstr/R_R.cpp index 1f1be59f..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 - -#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); -} \ No newline at end of file + 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 929f8fee..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 - -#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); -} \ No newline at end of file + 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 0134f74c..6f72dd05 100644 --- a/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ADDInstr/Unsupported.cpp @@ -1,271 +1,267 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..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 - -#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); -} \ 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..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 - -#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); -} \ 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..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 - -#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); -} \ No newline at end of file + 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 1d8668d0..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 - -#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); -} \ No newline at end of file + 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 e700978b..7f37f6ff 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDInstr/Unsupported.cpp @@ -1,271 +1,267 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..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 - -#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); -} \ 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..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 - -#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); -} \ 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..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 - -#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); -} \ No newline at end of file + 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 ca0f266b..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 - -#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); -} \ No newline at end of file + 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 e1abbb8a..e31f6089 100644 --- a/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ANDNInstr/Unsupported.cpp @@ -1,271 +1,267 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..2048a6c0 100644 --- a/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/R.cpp @@ -1,89 +1,85 @@ -#include - -#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); -} \ No newline at end of file + 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 d72adcd8..ccd81fc1 100644 --- a/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/BSWAPInstr/Unsupported.cpp @@ -1,464 +1,460 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..be76fa77 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_imm.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +16,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..12eafd0f 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_r.cpp @@ -1,22 +1,18 @@ -#include - -#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(); 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..81328e8a 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLEInstr/test_decoder_unsupported.cpp @@ -1,490 +1,486 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..254ed4f7 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_imm.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +16,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..9d50ad8f 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_r.cpp @@ -1,22 +1,18 @@ -#include - -#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(); 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..bfd1de82 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLGRInstr/test_decoder_unsupported.cpp @@ -1,490 +1,486 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..e7f67323 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_imm.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +16,4 @@ 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..eb1e7ce5 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_r.cpp @@ -1,22 +1,18 @@ -#include - -#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(); 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..0dda4486 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLInstr/test_decoder_unsupported.cpp @@ -1,490 +1,486 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..a1088c7b 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_imm.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +16,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..8c60ced2 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_r.cpp @@ -1,22 +1,18 @@ -#include - -#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(); 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..6904c94d 100644 --- a/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CALLLInstr/test_decoder_unsupported.cpp @@ -1,490 +1,486 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..e5e38717 100644 --- a/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_none.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_none.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + 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..d2ffdc91 100644 --- a/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CCRFInstr/test_decoder_unsupported.cpp @@ -1,543 +1,538 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); } diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/M_R.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/M_R.cpp index 52982253..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 - -#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); -} \ No newline at end of file + 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 40291f86..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 - -#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); -} \ 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..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 - -#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,8 +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); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_R.cpp b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_R.cpp index 41cf2225..e9eb63f2 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/RM_R.cpp @@ -1,98 +1,93 @@ -#include "Core/CPU/Instructions/Opcodes.hpp" -#include - -#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); -} \ No newline at end of file + 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 05df334d..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 - -#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 ee676fd6..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 - -#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); -} \ 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..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 - -#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); -} \ No newline at end of file + 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 bfac9b4a..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 - -#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); -} \ No newline at end of file + 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 69f76cb6..b64d5791 100644 --- a/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CMPInstr/Unsupported.cpp @@ -1,64 +1,59 @@ -#include "Core/CPU/Instructions/Opcodes.hpp" -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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!"); -} \ 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..bb78faaa 100644 --- a/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_none.cpp +++ b/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_none.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + 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..a24c6919 100644 --- a/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/COVFInstr/test_decoder_unsupported.cpp @@ -1,543 +1,538 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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 617fa98f..4f97cb5f 100644 --- a/tests/Modular/EmulatorCore/Decoding/CUDFInstr/None.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CUDFInstr/None.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + 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..de1efe99 100644 --- a/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/CUDFInstr/Unsupported.cpp @@ -1,543 +1,538 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); } diff --git a/tests/Modular/EmulatorCore/Decoding/DECInstr/R.cpp b/tests/Modular/EmulatorCore/Decoding/DECInstr/R.cpp index a1c5e6d7..99de76c8 100644 --- a/tests/Modular/EmulatorCore/Decoding/DECInstr/R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DECInstr/R.cpp @@ -1,89 +1,85 @@ -#include - -#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); -} \ No newline at end of file + 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 2894ea33..fb2fabf0 100644 --- a/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DECInstr/Unsupported.cpp @@ -1,464 +1,460 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..1a490561 100644 --- a/tests/Modular/EmulatorCore/Decoding/DIVInstr/R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DIVInstr/R.cpp @@ -1,89 +1,85 @@ -#include - -#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 feb0e0ee..b60aa5b9 100644 --- a/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/DIVInstr/Unsupported.cpp @@ -1,41 +1,37 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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,441 +51,441 @@ 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..bc67c27a 100644 --- a/tests/Modular/EmulatorCore/Decoding/Features/AddressAddition.cpp +++ b/tests/Modular/EmulatorCore/Decoding/Features/AddressAddition.cpp @@ -1,20 +1,16 @@ -#include - -#include - -#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); -} \ No newline at end of file + 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 ad3e8cc7..dbd207cd 100644 --- a/tests/Modular/EmulatorCore/Decoding/HALTInstr/None.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HALTInstr/None.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + 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..4896cdea 100644 --- a/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HALTInstr/Unsupported.cpp @@ -1,543 +1,538 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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 fb62a22e..8b1502bb 100644 --- a/tests/Modular/EmulatorCore/Decoding/HIDInstr/None.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HIDInstr/None.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + 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..020d6dac 100644 --- a/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/HIDInstr/Unsupported.cpp @@ -1,543 +1,538 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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 1b3cef74..eb776f9a 100644 --- a/tests/Modular/EmulatorCore/Decoding/INCInstr/R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/INCInstr/R.cpp @@ -1,89 +1,85 @@ -#include - -#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); -} \ No newline at end of file + 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 f526d0ff..11a2a8ae 100644 --- a/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/INCInstr/Unsupported.cpp @@ -1,464 +1,460 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..9de36623 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_imm.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +16,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..aee5c2c2 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_r.cpp @@ -1,22 +1,18 @@ -#include - -#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(); 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..27560a2c 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMEInstr/test_decoder_unsupported.cpp @@ -1,490 +1,486 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..049c36a4 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_imm.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +16,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..74302d30 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_r.cpp @@ -1,22 +1,18 @@ -#include - -#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(); 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..2b35d0a1 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMGRInstr/test_decoder_unsupported.cpp @@ -1,490 +1,486 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..199d0132 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_imm.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +16,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..6453c330 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_r.cpp @@ -1,22 +1,18 @@ -#include - -#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(); 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..b4127c08 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMLInstr/test_decoder_unsupported.cpp @@ -1,490 +1,486 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..5d0b3d26 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_imm.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_imm.cpp @@ -1,17 +1,13 @@ -#include - -#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; - + std::uint64_t mem_ptr; HyperCPU::IInstruction instr = decoder.FetchAndDecode(); @@ -20,4 +16,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..80024964 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_r.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_r.cpp @@ -1,22 +1,18 @@ -#include - -#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(); 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..320340ee 100644 --- a/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/JMPInstr/test_decoder_unsupported.cpp @@ -1,490 +1,486 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..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 - -#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); -} \ No newline at end of file + 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 49bfaba8..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 - -#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); -} \ 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..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 - -#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); -} \ 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..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 - -#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); -} \ No newline at end of file + 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 efa8a810..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 - -#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 9a8e9fb5..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 - -#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); -} \ 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..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 - -#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); -} \ No newline at end of file + 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 27ebe652..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 - -#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); -} \ No newline at end of file + 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 3b52a0ae..a9e9b4a8 100644 --- a/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MOVInstr/Unsupported.cpp @@ -1,63 +1,59 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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!"); -} \ 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..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 - -#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,8 +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); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_M.cpp index fbdda4e8..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 - -#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); -} \ 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..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 - -#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); -} \ No newline at end of file + 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 ace4469a..ae37a57e 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/R_RM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/R_RM.cpp @@ -1,97 +1,93 @@ -#include - -#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); -} \ No newline at end of file + 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 0caab6d3..a3d8e0b5 100644 --- a/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/MULInstr/Unsupported.cpp @@ -1,271 +1,267 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_IMM.cpp index f7e45048..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 - -#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,8 +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); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/ORInstr/R_M.cpp b/tests/Modular/EmulatorCore/Decoding/ORInstr/R_M.cpp index 05f54a34..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 - -#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); -} \ 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..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 - -#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); -} \ No newline at end of file + 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 94d37544..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 - -#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); -} \ No newline at end of file + 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 a15d590f..a7208a1d 100644 --- a/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/ORInstr/Unsupported.cpp @@ -1,271 +1,267 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/READInstr/IMM.cpp b/tests/Modular/EmulatorCore/Decoding/READInstr/IMM.cpp index be1b58cf..4decf89f 100644 --- a/tests/Modular/EmulatorCore/Decoding/READInstr/IMM.cpp +++ b/tests/Modular/EmulatorCore/Decoding/READInstr/IMM.cpp @@ -1,16 +1,13 @@ -#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; - + HyperCPU::IInstruction instr = decoder.FetchAndDecode(); ASSERT_EQ(instr.m_opcode, HyperCPU::Opcode::READ); @@ -21,10 +18,11 @@ 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->Load8(counter, (HyperCPU::Mode::b8 << 4) | HyperCPU::OperandTypes::R); + decoder.mem_controller->Load16(counter, HyperCPU::Opcode::READ); + counter += 2; + 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(); @@ -33,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 b8fe8edc..c3c8bbdf 100644 --- a/tests/Modular/EmulatorCore/Decoding/READInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/READInstr/Unsupported.cpp @@ -1,17 +1,16 @@ -#include - +#include "tests/fixtures.hpp" #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) { - 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,24 +32,24 @@ 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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,389 +58,389 @@ 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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 fc22a6ba..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 - -#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); -} \ 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..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 - -#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); -} \ No newline at end of file + 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 3e467e1d..db0d929f 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFLInstr/Unsupported.cpp @@ -1,323 +1,319 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ 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..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 - -#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); -} \ 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..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 - -#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); -} \ No newline at end of file + 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 4214a15f..aba3f4ca 100644 --- a/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SHFRInstr/Unsupported.cpp @@ -1,323 +1,319 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/SUBInstr/R_IMM.cpp index afd3ff85..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 - -#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); -} \ 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..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 - -#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); -} \ 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..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 - -#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); -} \ No newline at end of file + 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 3d9105f1..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 - -#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); -} \ No newline at end of file + 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 c12c1a57..c2b466eb 100644 --- a/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/SUBInstr/Unsupported.cpp @@ -1,271 +1,267 @@ -#include - -#include - -#include +#include "tests/fixtures.hpp" #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) { - 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); -} \ No newline at end of file +} diff --git a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_IMM.cpp index be89f195..54c46be5 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); + 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(); @@ -18,9 +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/Decoding/WRITEInstr/R_R.cpp b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_R.cpp index 7930565f..d9e5cc33 100644 --- a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_R.cpp +++ b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/R_R.cpp @@ -1,27 +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 57748c82..d0ac7039 100644 --- a/tests/Modular/EmulatorCore/Decoding/WRITEInstr/Unsupported.cpp +++ b/tests/Modular/EmulatorCore/Decoding/WRITEInstr/Unsupported.cpp @@ -1,17 +1,17 @@ -#include +#include "tests/fixtures.hpp" #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) { - 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,24 +20,24 @@ 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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,404 +46,404 @@ 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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; - + HCPU_ASSERT_EXIT(decoder.FetchAndDecode(), ::testing::ExitedWithCode(1), "Invalid opcode!"); } 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!"); } diff --git a/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp b/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp index 1831f660..456e3ff4 100644 --- a/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp +++ b/tests/Modular/EmulatorCore/MemoryControllers/ST.cpp @@ -1,10 +1,9 @@ -#include - -#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; @@ -12,16 +11,16 @@ 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) { @@ -229,4 +228,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/Modular/EmulatorCore/Stack/Stack.cpp b/tests/Modular/EmulatorCore/Stack/Stack.cpp index 1b7fdf04..0f55c190 100644 --- a/tests/Modular/EmulatorCore/Stack/Stack.cpp +++ b/tests/Modular/EmulatorCore/Stack/Stack.cpp @@ -1,5 +1,4 @@ -#include - +#include "tests/fixtures.hpp" static constexpr std::uint8_t BYTE_DATA = 0x55; static constexpr std::uint16_t WORD_DATA = 0x5555; @@ -64,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 +} diff --git a/tests/Pog/Automaton.cpp b/tests/Pog/Automaton.cpp index 02eaca91..09545241 100644 --- a/tests/Pog/Automaton.cpp +++ b/tests/Pog/Automaton.cpp @@ -1,180 +1,164 @@ -#include +#include "Pog/Automaton.hpp" -#include - -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" 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/BUILD.bazel b/tests/Pog/BUILD.bazel new file mode 100644 index 00000000..05d3a74e --- /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 = [ + "//src/PCH:pch_cstd", + "//src/Pog:pog", + "//tests:pch_gtest", + "@fmt", + "@gtest//:gtest-gmock_main", + "@re2", + ], +) 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/Pog/FilterView.cpp b/tests/Pog/FilterView.cpp index 5791d4de..90862179 100644 --- a/tests/Pog/FilterView.cpp +++ b/tests/Pog/FilterView.cpp @@ -1,83 +1,84 @@ -#include +#include "Pog/FilterView.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" 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..7ae97f4a 100644 --- a/tests/Pog/Grammar.cpp +++ b/tests/Pog/Grammar.cpp @@ -1,187 +1,188 @@ -#include +#include "Pog/Grammar.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" 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..7445eba3 100644 --- a/tests/Pog/Item.cpp +++ b/tests/Pog/Item.cpp @@ -1,236 +1,237 @@ -#include +#include "Pog/Item.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" 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..28439dd6 100644 --- a/tests/Pog/Parser.cpp +++ b/tests/Pog/Parser.cpp @@ -1,6 +1,7 @@ -#include +#include "Pog/Parser.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" using namespace pog; using namespace ::testing; @@ -8,912 +9,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..ac7f0033 100644 --- a/tests/Pog/ParsingTable.cpp +++ b/tests/Pog/ParsingTable.cpp @@ -1,12 +1,13 @@ -#include +#include "Pog/ParsingTable.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" 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 deleted file mode 100644 index 5ff23f2f..00000000 --- a/tests/Pog/PogTests.cpp +++ /dev/null @@ -1,7 +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 4bd379d3..d2f81ce4 100644 --- a/tests/Pog/Precedence.cpp +++ b/tests/Pog/Precedence.cpp @@ -1,81 +1,70 @@ -#include +#include "Pog/Precedence.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" 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..5d175b6d 100644 --- a/tests/Pog/Rule.cpp +++ b/tests/Pog/Rule.cpp @@ -1,92 +1,93 @@ -#include +#include "Pog/Rule.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" 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..49ae793c 100644 --- a/tests/Pog/RuleBuilder.cpp +++ b/tests/Pog/RuleBuilder.cpp @@ -1,68 +1,67 @@ -#include +#include "Pog/RuleBuilder.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" 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..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; @@ -8,271 +9,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..a75f9604 100644 --- a/tests/Pog/Symbol.cpp +++ b/tests/Pog/Symbol.cpp @@ -1,57 +1,58 @@ -#include +#include "Pog/Symbol.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" 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..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; @@ -8,74 +9,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..9895d54f 100644 --- a/tests/Pog/TokenBuilder.cpp +++ b/tests/Pog/TokenBuilder.cpp @@ -1,145 +1,146 @@ -#include +#include "Pog/TokenBuilder.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" 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..62e2b865 100644 --- a/tests/Pog/Tokenizer.cpp +++ b/tests/Pog/Tokenizer.cpp @@ -1,295 +1,295 @@ -#include +#include "Pog/Tokenizer.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" 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..0eaae892 100644 --- a/tests/Pog/Utils.cpp +++ b/tests/Pog/Utils.cpp @@ -1,62 +1,45 @@ -#include +#include "Pog/Utils.hpp" -#include +#include "PCH/CStd.hpp" +#include "tests/gtest.hpp" 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/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 diff --git a/tests/fixtures.hpp b/tests/fixtures.hpp index 404be3d1..12c80ce3 100644 --- a/tests/fixtures.hpp +++ b/tests/fixtures.hpp @@ -1,19 +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 "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 static constexpr std::uint64_t MEM_SIZE = 4096; static constexpr std::uint64_t MEM_FIXTURE_MEM_SIZE = 1024; @@ -21,7 +18,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 +29,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 { @@ -86,27 +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_TEST() + : 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) { } + OPERAND_EVAL_TEST() + : 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) { + STACK_TEST() + : cpu(1, 4096) { *cpu.xbp = 1024; *cpu.xsp = 1024; } @@ -114,20 +119,20 @@ 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) { - + IVT_INIT_TEST() + : 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) { } + EXCEPTION_TEST() + : cpu(1, 4096) { + } virtual void SetUp() { *cpu.xsp = 512; @@ -136,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; } }; @@ -148,7 +153,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(), _state(compiler.pool), parser(compiler.parser) { parser.set_compiler_state(&_state); } }; @@ -157,7 +163,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() { + } virtual void TearDown() { HCAsm::current_index = 0; @@ -168,7 +176,9 @@ class ASSEMBLER : public ::testing::Test { protected: HCAsm::HCAsmCompiler compiler; - ASSEMBLER() : compiler(HyperCPU::LogLevel::ERROR) { } + ASSEMBLER() + : compiler() { + } virtual void TearDown() { HCAsm::current_index = 0; @@ -180,7 +190,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(), dir(::testing::UnitTest::GetInstance()->current_test_info()->test_case_name()) { + } virtual void TearDown() { HCAsm::current_index = 0; @@ -191,7 +203,9 @@ class TWO_OPERANDS_SUCCESS : public ::testing::Test { protected: HCAsm::HCAsmCompiler compiler; - TWO_OPERANDS_SUCCESS() : compiler(HyperCPU::LogLevel::ERROR) { } + TWO_OPERANDS_SUCCESS() + : compiler() { + } virtual void TearDown() { HCAsm::current_index = 0; @@ -202,9 +216,15 @@ class TWO_OPERANDS_FAILURE : public ::testing::Test { protected: HCAsm::HCAsmCompiler compiler; - TWO_OPERANDS_FAILURE() : compiler(HyperCPU::LogLevel::ERROR) { } + TWO_OPERANDS_FAILURE() + : compiler() { + } virtual void TearDown() { HCAsm::current_index = 0; } }; + +constexpr inline std::uint8_t EncodeTestFlags(HyperCPU::Mode md, HyperCPU::OperandTypes types) { + return (static_cast(md) << 4) | static_cast(types); +} diff --git a/tests/gtest.hpp b/tests/gtest.hpp new file mode 100644 index 00000000..53a3bfd0 --- /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 836659c0..00000000 --- a/tests/main.cpp +++ /dev/null @@ -1,8 +0,0 @@ -#include -#include - -int main(int argc, char **argv) { - ::testing::InitGoogleTest(&argc, argv); - - return RUN_ALL_TESTS(); -} diff --git a/tools/bazel/BUILD.bazel b/tools/bazel/BUILD.bazel new file mode 100644 index 00000000..69b83cbe --- /dev/null +++ b/tools/bazel/BUILD.bazel @@ -0,0 +1 @@ +"Common macros, rules etc. used by HyperCPU" diff --git a/tools/bazel/pch.bzl b/tools/bazel/pch.bzl new file mode 100644 index 00000000..6f7eb9ae --- /dev/null +++ b/tools/bazel/pch.bzl @@ -0,0 +1,113 @@ +"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("@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( + 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"], +) diff --git a/tools/increment_version.py b/tools/increment_version.py new file mode 100755 index 00000000..d2d43e34 --- /dev/null +++ b/tools/increment_version.py @@ -0,0 +1,158 @@ +#!/usr/bin/env python3 + +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 dispatcher + + 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"(.*)=\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(2) + 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.strip()} = "{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, 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) + 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, flags=re.DOTALL) + 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()