Compare commits
No commits in common. "master" and "0.9.4" have entirely different histories.
|
|
@ -1,18 +0,0 @@
|
|||
# Vendored Dependencies
|
||||
src/frontend/glad/** linguist-vendored
|
||||
src/frontend/qt_sdl/gif-h/** linguist-vendored
|
||||
src/frontend/qt_sdl/toml/** linguist-vendored
|
||||
src/net/libslirp/** linguist-vendored
|
||||
src/net/pcap/** linguist-vendored
|
||||
src/sha1/** linguist-vendored
|
||||
src/teakra/** linguist-vendored
|
||||
src/tiny-AES-c/** linguist-vendored
|
||||
src/xxhash/** linguist-vendored
|
||||
|
||||
# A handful of custom files embedded in the vendored dependencies
|
||||
|
||||
## Ad-hoc CMakeLists.txt for melonDS
|
||||
src/net/libslirp/src/CMakeLists.txt -linguist-vendored
|
||||
|
||||
## glib stub
|
||||
src/net/libslirp/src/glib/** -linguist-vendored
|
||||
|
|
@ -1,2 +1,2 @@
|
|||
patreon: Arisotura
|
||||
patreon: staplebutter
|
||||
custom: ["https://paypal.me/Arisotura", "http://melonds.kuribo64.net/donate.php"]
|
||||
|
|
|
|||
|
|
@ -0,0 +1,26 @@
|
|||
trigger:
|
||||
- master
|
||||
|
||||
pool:
|
||||
name: Default
|
||||
demands:
|
||||
- agent.name -equals MacStadium-ARM64-Mac
|
||||
|
||||
workspace:
|
||||
clean: all
|
||||
|
||||
steps:
|
||||
- script: mkdir $(Pipeline.Workspace)/build
|
||||
displayName: 'Create build environment'
|
||||
|
||||
- script: arch -arm64 cmake $(Build.SourcesDirectory) -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_PREFIX_PATH="$(brew --prefix qt@6);$(brew --prefix libarchive)" -DMACOS_BUNDLE_LIBS=ON -DMACOS_BUILD_DMG=ON -DUSE_QT6=ON
|
||||
displayName: 'Configure'
|
||||
workingDirectory: $(Pipeline.Workspace)/build
|
||||
|
||||
- script: arch -arm64 make -j$(sysctl -n hw.logicalcpu)
|
||||
displayName: 'Make'
|
||||
workingDirectory: $(Pipeline.Workspace)/build
|
||||
|
||||
- publish: $(Pipeline.Workspace)/build/melonDS.dmg
|
||||
artifact: melonDS.dmg
|
||||
|
||||
|
|
@ -0,0 +1,24 @@
|
|||
trigger:
|
||||
- master
|
||||
|
||||
pool:
|
||||
vmImage: macOS-10.15
|
||||
|
||||
steps:
|
||||
- script: brew install llvm sdl2 qt@6 libslirp libarchive libepoxy
|
||||
displayName: 'Install dependencies'
|
||||
|
||||
- script: mkdir $(Pipeline.Workspace)/build
|
||||
displayName: 'Create build environment'
|
||||
|
||||
- script: cmake $(Build.SourcesDirectory) -DCMAKE_BUILD_TYPE=$BUILD_TYPE -DCMAKE_PREFIX_PATH="$(brew --prefix qt@6);$(brew --prefix libarchive)" -DMACOS_BUNDLE_LIBS=ON -DMACOS_BUILD_DMG=ON -DUSE_QT6=ON
|
||||
displayName: 'Configure'
|
||||
workingDirectory: $(Pipeline.Workspace)/build
|
||||
|
||||
- script: make -j$(sysctl -n hw.logicalcpu)
|
||||
displayName: 'Make'
|
||||
workingDirectory: $(Pipeline.Workspace)/build
|
||||
|
||||
- publish: $(Pipeline.Workspace)/build/melonDS.dmg
|
||||
artifact: melonDS.dmg
|
||||
|
||||
|
|
@ -1,94 +0,0 @@
|
|||
name: macOS
|
||||
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- master
|
||||
- ci/*
|
||||
pull_request:
|
||||
branches:
|
||||
- master
|
||||
|
||||
env:
|
||||
VCPKG_COMMIT: 2ad004460f5db4d3b66f62f5799ff66c265c4b5d
|
||||
MELONDS_GIT_BRANCH: ${{ github.ref }}
|
||||
MELONDS_GIT_HASH: ${{ github.sha }}
|
||||
MELONDS_BUILD_PROVIDER: GitHub Actions
|
||||
MELONDS_VERSION_SUFFIX: " RC"
|
||||
|
||||
jobs:
|
||||
build-macos:
|
||||
strategy:
|
||||
matrix:
|
||||
arch: [x86_64, arm64]
|
||||
|
||||
name: ${{ matrix.arch }}
|
||||
runs-on: macos-14
|
||||
steps:
|
||||
- name: Check out sources
|
||||
uses: actions/checkout@v3
|
||||
- name: Install dependencies for package building
|
||||
run: |
|
||||
brew install autoconf automake autoconf-archive libtool python-setuptools
|
||||
- name: Set up CMake
|
||||
uses: lukka/get-cmake@latest
|
||||
- name: Set up vcpkg
|
||||
uses: lukka/run-vcpkg@v11
|
||||
with:
|
||||
vcpkgGitCommitId: ${{ env.VCPKG_COMMIT }}
|
||||
- name: Build
|
||||
uses: lukka/run-cmake@v10
|
||||
with:
|
||||
configurePreset: release-mac-${{ matrix.arch }}
|
||||
buildPreset: release-mac-${{ matrix.arch }}
|
||||
configurePresetAdditionalArgs: "['-DMELONDS_EMBED_BUILD_INFO=ON']"
|
||||
- name: Compress app bundle
|
||||
shell: bash
|
||||
run: |
|
||||
cd build/release-mac-${{ matrix.arch }}
|
||||
zip -r -y ../../macOS-${{ matrix.arch }}.zip melonDS.app
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: macOS-${{ matrix.arch }}
|
||||
path: macOS-${{ matrix.arch }}.zip
|
||||
retention-days: 1
|
||||
|
||||
universal-binary:
|
||||
name: Universal binary
|
||||
needs: [build-macos]
|
||||
runs-on: macos-13
|
||||
continue-on-error: true
|
||||
steps:
|
||||
- name: Download x86_64
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: macOS-x86_64
|
||||
path: x86_64
|
||||
- name: Download arm64
|
||||
uses: actions/download-artifact@v4
|
||||
with:
|
||||
name: macOS-arm64
|
||||
path: arm64
|
||||
- name: Combine app bundles
|
||||
shell: bash
|
||||
run: |
|
||||
unzip x86_64/*.zip -d x86_64
|
||||
unzip arm64/*.zip -d arm64
|
||||
lipo {x86_64,arm64}/melonDS.app/Contents/MacOS/melonDS -create -output melonDS
|
||||
cp -a arm64/melonDS.app melonDS.app
|
||||
cp melonDS melonDS.app/Contents/MacOS/melonDS
|
||||
codesign -s - --deep melonDS.app
|
||||
zip -r -y macOS-universal.zip melonDS.app
|
||||
- name: Upload artifact
|
||||
uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: macOS-universal
|
||||
path: macOS-universal.zip
|
||||
# - name: Clean up architecture-specific artifacts
|
||||
# uses: geekyeggo/delete-artifact@v4
|
||||
# with:
|
||||
# failOnError: false
|
||||
# name: |
|
||||
# macOS-x86_64
|
||||
# macOS-arm64
|
||||
|
|
@ -0,0 +1,50 @@
|
|||
name: CMake Build (Ubuntu aarch64)
|
||||
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- master
|
||||
pull_request:
|
||||
branches:
|
||||
- master
|
||||
|
||||
env:
|
||||
BUILD_TYPE: Release
|
||||
|
||||
jobs:
|
||||
build:
|
||||
runs-on: ubuntu-20.04
|
||||
container: ubuntu:20.04
|
||||
|
||||
steps:
|
||||
- name: Prepare system
|
||||
shell: bash
|
||||
run: |
|
||||
apt update
|
||||
apt -y full-upgrade
|
||||
apt -y install git
|
||||
- name: Check out source
|
||||
uses: actions/checkout@v1
|
||||
- name: Install dependencies
|
||||
shell: bash
|
||||
run: |
|
||||
dpkg --add-architecture arm64
|
||||
sh -c "sed \"s|^deb \([a-z\.:/]*\) \([a-z\-]*\) \(.*\)$|deb [arch=amd64] \1 \2 \3\ndeb [arch=arm64] http://ports.ubuntu.com/ubuntu-ports \2 \3|\" /etc/apt/sources.list > /etc/apt/sources.list.new"
|
||||
rm /etc/apt/sources.list
|
||||
mv /etc/apt/sources.list{.new,}
|
||||
apt update
|
||||
DEBIAN_FRONTEND=noninteractive apt install -y {gcc-10,g++-10,pkg-config}-aarch64-linux-gnu {libsdl2,qtbase5,libslirp,libarchive,libepoxy}-dev:arm64 cmake dpkg-dev
|
||||
- name: Configure
|
||||
shell: bash
|
||||
run: |
|
||||
CC=aarch64-linux-gnu-gcc-10 CXX=aarch64-linux-gnu-g++-10 cmake -DPKG_CONFIG_EXECUTABLE=/usr/bin/aarch64-linux-gnu-pkg-config $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE -B build
|
||||
- name: Make
|
||||
shell: bash
|
||||
run: |
|
||||
cmake --build build -j$(nproc --all)
|
||||
mkdir dist
|
||||
cp build/melonDS dist
|
||||
- uses: actions/upload-artifact@v1
|
||||
with:
|
||||
name: melonDS-ubuntu-aarch64
|
||||
path: dist
|
||||
|
|
@ -1,63 +1,37 @@
|
|||
name: Ubuntu
|
||||
name: CMake Build (Ubuntu x86-64)
|
||||
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- master
|
||||
- ci/*
|
||||
pull_request:
|
||||
branches:
|
||||
- master
|
||||
|
||||
env:
|
||||
MELONDS_GIT_BRANCH: ${{ github.ref }}
|
||||
MELONDS_GIT_HASH: ${{ github.sha }}
|
||||
MELONDS_BUILD_PROVIDER: GitHub Actions
|
||||
MELONDS_VERSION_SUFFIX: " RC"
|
||||
|
||||
jobs:
|
||||
build:
|
||||
continue-on-error: true
|
||||
strategy:
|
||||
matrix:
|
||||
arch:
|
||||
- runner: ubuntu-22.04
|
||||
name: x86_64
|
||||
- runner: ubuntu-22.04-arm
|
||||
name: aarch64
|
||||
|
||||
name: ${{ matrix.arch.name }}
|
||||
runs-on: ${{ matrix.arch.runner }}
|
||||
runs-on: ubuntu-20.04
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
name: Check out sources
|
||||
- uses: actions/checkout@v1
|
||||
- name: Install dependencies
|
||||
run: |
|
||||
sudo rm -f /etc/apt/sources.list.d/dotnetdev.list /etc/apt/sources.list.d/microsoft-prod.list
|
||||
sudo apt update
|
||||
sudo apt install --allow-downgrades cmake ninja-build extra-cmake-modules libpcap0.8-dev libsdl2-dev libenet-dev \
|
||||
qt6-{base,base-private,multimedia}-dev libqt6svg6-dev libarchive-dev libzstd-dev libfuse2
|
||||
sudo apt install cmake libcurl4-gnutls-dev libpcap0.8-dev libsdl2-dev qt5-default libslirp0 libslirp-dev libarchive-dev libepoxy-dev --allow-downgrades
|
||||
- name: Create build environment
|
||||
run: mkdir ${{runner.workspace}}/build
|
||||
- name: Configure
|
||||
run: cmake -B build -G Ninja -DCMAKE_INSTALL_PREFIX=/usr -DMELONDS_EMBED_BUILD_INFO=ON
|
||||
- name: Build
|
||||
working-directory: ${{runner.workspace}}/build
|
||||
run: cmake $GITHUB_WORKSPACE
|
||||
- name: Make
|
||||
working-directory: ${{runner.workspace}}/build
|
||||
run: |
|
||||
cmake --build build
|
||||
DESTDIR=AppDir cmake --install build
|
||||
- uses: actions/upload-artifact@v4
|
||||
make -j$(nproc --all)
|
||||
mkdir dist
|
||||
cp melonDS dist
|
||||
- uses: actions/upload-artifact@v1
|
||||
with:
|
||||
name: melonDS-ubuntu-${{ matrix.arch.name }}
|
||||
path: AppDir/usr/bin/melonDS
|
||||
- name: Fetch AppImage tools
|
||||
run: |
|
||||
wget https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-${{ matrix.arch.name }}.AppImage
|
||||
wget https://github.com/linuxdeploy/linuxdeploy-plugin-qt/releases/download/continuous/linuxdeploy-plugin-qt-${{ matrix.arch.name }}.AppImage
|
||||
chmod a+x linuxdeploy-*.AppImage
|
||||
- name: Build the AppImage
|
||||
env:
|
||||
QMAKE: /usr/lib/qt6/bin/qmake
|
||||
run: |
|
||||
./linuxdeploy-${{ matrix.arch.name }}.AppImage --appdir AppDir --plugin qt --output appimage
|
||||
- uses: actions/upload-artifact@v4
|
||||
with:
|
||||
name: melonDS-appimage-${{ matrix.arch.name }}
|
||||
path: melonDS*.AppImage
|
||||
name: melonDS-ubuntu-x86_64
|
||||
path: ${{runner.workspace}}/build/dist
|
||||
|
|
|
|||
|
|
@ -1,45 +1,47 @@
|
|||
name: Windows
|
||||
name: CMake Build (Windows x86-64)
|
||||
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- master
|
||||
- ci/*
|
||||
pull_request:
|
||||
branches:
|
||||
- master
|
||||
|
||||
env:
|
||||
VCPKG_COMMIT: 2ad004460f5db4d3b66f62f5799ff66c265c4b5d
|
||||
MELONDS_GIT_BRANCH: ${{ github.ref }}
|
||||
MELONDS_GIT_HASH: ${{ github.sha }}
|
||||
MELONDS_BUILD_PROVIDER: GitHub Actions
|
||||
MELONDS_VERSION_SUFFIX: " RC"
|
||||
BUILD_TYPE: Release
|
||||
|
||||
jobs:
|
||||
build:
|
||||
|
||||
runs-on: windows-latest
|
||||
|
||||
defaults:
|
||||
run:
|
||||
shell: msys2 {0}
|
||||
steps:
|
||||
- name: Check out sources
|
||||
uses: actions/checkout@v3
|
||||
- name: Set up MSYS2
|
||||
uses: msys2/setup-msys2@v2
|
||||
- uses: actions/checkout@v1
|
||||
- uses: msys2/setup-msys2@v2
|
||||
with:
|
||||
msystem: ucrt64
|
||||
update: true
|
||||
pacboy: gcc:p cmake:p ninja:p make:p
|
||||
- name: Set up vcpkg
|
||||
uses: lukka/run-vcpkg@v11
|
||||
with:
|
||||
vcpkgGitCommitId: ${{ env.VCPKG_COMMIT }}
|
||||
msystem: MINGW64
|
||||
update: true
|
||||
|
||||
- name: Install dependencies
|
||||
run: pacman -Sq --noconfirm git make mingw-w64-x86_64-{cmake,mesa,SDL2,qt5-static,libslirp,libarchive,libepoxy,toolchain}
|
||||
|
||||
- name: Create build environment
|
||||
working-directory: ${{runner.workspace}}
|
||||
run: mkdir build
|
||||
|
||||
- name: Configure
|
||||
run: cmake --preset=release-mingw-x86_64 -DMELONDS_EMBED_BUILD_INFO=ON
|
||||
- name: Build
|
||||
run: cmake --build --preset=release-mingw-x86_64
|
||||
- uses: actions/upload-artifact@v4
|
||||
working-directory: ${{runner.workspace}}/build
|
||||
run: cmake $GITHUB_WORKSPACE -G 'MSYS Makefiles' -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} -DBUILD_STATIC=ON -DQT5_STATIC_DIR=C:/tools/msys64/mingw64/qt5-static
|
||||
|
||||
- name: Make
|
||||
working-directory: ${{runner.workspace}}/build
|
||||
run: make -j$(nproc --all)
|
||||
|
||||
- uses: actions/upload-artifact@v1
|
||||
with:
|
||||
name: melonDS-windows-x86_64
|
||||
path: .\build\release-mingw-x86_64\melonDS.exe
|
||||
path: ${{runner.workspace}}\build\melonDS.exe
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
build*/
|
||||
build
|
||||
bin
|
||||
obj
|
||||
*.depend
|
||||
|
|
@ -7,7 +7,7 @@ obj
|
|||
melon_grc.c
|
||||
melon_grc.h
|
||||
melon.rc
|
||||
cmake-build*
|
||||
cmake-build
|
||||
cmake-build-debug
|
||||
compile_commands.json
|
||||
.idea
|
||||
|
|
@ -16,8 +16,3 @@ compile_commands.json
|
|||
*.exe
|
||||
|
||||
.DS_Store
|
||||
|
||||
.vs
|
||||
.vscode
|
||||
CMakeFiles
|
||||
CMakeCache.txt
|
||||
|
|
|
|||
81
BUILD.md
81
BUILD.md
|
|
@ -1,81 +0,0 @@
|
|||
# Building melonDS
|
||||
|
||||
* [Linux](#linux)
|
||||
* [Windows](#windows)
|
||||
* [macOS](#macos)
|
||||
|
||||
## Linux
|
||||
1. Install dependencies:
|
||||
* Ubuntu:
|
||||
* All versions: `sudo apt install cmake extra-cmake-modules libcurl4-gnutls-dev libpcap0.8-dev libsdl2-dev libarchive-dev libenet-dev libzstd-dev`
|
||||
* 24.04: `sudo apt install qt6-{base,base-private,multimedia,svg}-dev`
|
||||
* 22.04: `sudo apt install qtbase6-dev qtbase6-private-dev qtmultimedia6-dev libqt6svg6-dev`
|
||||
* Older versions: `sudo apt install qtbase5-dev qtbase5-private-dev qtmultimedia5-dev libqt5svg5-dev`
|
||||
Also add `-DUSE_QT6=OFF` to the first CMake command below.
|
||||
* Fedora: `sudo dnf install gcc-c++ cmake extra-cmake-modules SDL2-devel libarchive-devel enet-devel libzstd-devel qt6-{qtbase,qtbase-private,qtmultimedia,qtsvg}-devel wayland-devel`
|
||||
* Arch Linux: `sudo pacman -S base-devel cmake extra-cmake-modules git libpcap sdl2 qt6-{base,multimedia,svg} libarchive enet zstd`
|
||||
2. Download the melonDS repository and prepare:
|
||||
```bash
|
||||
git clone https://github.com/melonDS-emu/melonDS
|
||||
cd melonDS
|
||||
```
|
||||
3. Compile:
|
||||
```bash
|
||||
cmake -B build
|
||||
cmake --build build -j$(nproc --all)
|
||||
```
|
||||
|
||||
## Windows
|
||||
1. Install [MSYS2](https://www.msys2.org/)
|
||||
2. Open the MSYS2 terminal from the Start menu:
|
||||
* For x64 systems (most common), use **MSYS2 UCRT64**
|
||||
* For ARM64 systems, use **MSYS2 CLANGARM64**
|
||||
3. Update the packages using `pacman -Syu` and reopen the same terminal if it asks you to
|
||||
4. Install git and clone the repository
|
||||
```bash
|
||||
pacman -S git
|
||||
git clone https://github.com/melonDS-emu/melonDS
|
||||
cd melonDS
|
||||
```
|
||||
5. Install dependencies:
|
||||
Replace `<prefix>` below with `mingw-w64-ucrt-x86_64` on x64 systems, or `mingw-w64-clang-aarch64` on ARM64 systems.
|
||||
```bash
|
||||
pacman -S <prefix>-{toolchain,cmake,SDL2,libarchive,enet,zstd}
|
||||
```
|
||||
6. Install Qt and configure the build directory
|
||||
* Dynamic builds (with DLLs)
|
||||
1. Install Qt: `pacman -S <prefix>-{qt6-base,qt6-svg,qt6-multimedia,qt6-svg,qt6-tools}`
|
||||
2. Set up the build directory with `cmake -B build`
|
||||
* Static builds (without DLLs, standalone executable)
|
||||
1. Install Qt: `pacman -S <prefix>-qt5-static`
|
||||
(Note: As of writing, the `qt6-static` package does not work.)
|
||||
2. Set up the build directory with `cmake -B build -DBUILD_STATIC=ON -DUSE_QT6=OFF -DCMAKE_PREFIX_PATH=$MSYSTEM_PREFIX/qt5-static`
|
||||
7. Compile: `cmake --build build`
|
||||
|
||||
If everything went well, melonDS should now be in the `build` folder. For dynamic builds, you may need to run melonDS from the MSYS2 terminal in order for it to find the required DLLs.
|
||||
|
||||
## macOS
|
||||
1. Install the [Homebrew Package Manager](https://brew.sh)
|
||||
2. Install dependencies: `brew install git pkg-config cmake sdl2 qt@6 libarchive enet zstd`
|
||||
3. Download the melonDS repository and prepare:
|
||||
```zsh
|
||||
git clone https://github.com/melonDS-emu/melonDS
|
||||
cd melonDS
|
||||
```
|
||||
4. Compile:
|
||||
```zsh
|
||||
cmake -B build -DCMAKE_PREFIX_PATH="$(brew --prefix qt@6);$(brew --prefix libarchive)"
|
||||
cmake --build build -j$(sysctl -n hw.logicalcpu)
|
||||
```
|
||||
If everything went well, melonDS.app should now be in the `build` directory.
|
||||
|
||||
### Self-contained app bundle
|
||||
If you want an app bundle that can be distributed to other computers without needing to install dependencies through Homebrew, you can additionally run `
|
||||
../tools/mac-libs.rb .` after the build is completed, or add `-DMACOS_BUNDLE_LIBS=ON` to the first CMake command.
|
||||
|
||||
## Nix (macOS/Linux)
|
||||
|
||||
melonDS provides a Nix flake with support for both macOS and Linux. The [Nix package manager](https://nixos.org) needs to be installed to use it.
|
||||
|
||||
* To run melonDS, just type `nix run github:melonDS-emu/melonDS`.
|
||||
* To get a shell for development, clone the melonDS repository and type `nix develop` in its directory.
|
||||
135
CMakeLists.txt
135
CMakeLists.txt
|
|
@ -1,44 +1,43 @@
|
|||
cmake_minimum_required(VERSION 3.16)
|
||||
cmake_minimum_required(VERSION 3.13)
|
||||
|
||||
cmake_policy(VERSION 3.15)
|
||||
include(CheckSymbolExists)
|
||||
include(CheckLibraryExists)
|
||||
|
||||
cmake_policy(VERSION 3.13)
|
||||
if (POLICY CMP0076)
|
||||
cmake_policy(SET CMP0076 NEW)
|
||||
endif()
|
||||
|
||||
set(CMAKE_POLICY_DEFAULT_CMP0069 NEW)
|
||||
|
||||
set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
|
||||
set(CMAKE_USER_MAKE_RULES_OVERRIDE "${CMAKE_CURRENT_SOURCE_DIR}/cmake/DefaultBuildFlags.cmake")
|
||||
set(CMAKE_OSX_DEPLOYMENT_TARGET "10.15" CACHE STRING "Minimum OS X deployment version")
|
||||
|
||||
option(USE_VCPKG "Use vcpkg for dependency packages" OFF)
|
||||
if (USE_VCPKG)
|
||||
include(ConfigureVcpkg)
|
||||
endif()
|
||||
|
||||
project(melonDS
|
||||
VERSION 1.0
|
||||
DESCRIPTION "DS emulator, sorta"
|
||||
HOMEPAGE_URL "https://melonds.kuribo64.net"
|
||||
LANGUAGES C CXX)
|
||||
|
||||
include(CheckSymbolExists)
|
||||
include(CheckLibraryExists)
|
||||
include(CMakeDependentOption)
|
||||
include(CheckIPOSupported)
|
||||
|
||||
include(SetupCCache)
|
||||
include(Sanitizers)
|
||||
project(melonDS CXX)
|
||||
|
||||
set(CMAKE_C_STANDARD 11)
|
||||
set(CMAKE_C_STANDARD_REQUIRED ON)
|
||||
set(CMAKE_CXX_STANDARD 17)
|
||||
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
|
||||
|
||||
if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
|
||||
set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
|
||||
set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
|
||||
set(MELONDS_VERSION "0.9.4")
|
||||
add_compile_definitions(MELONDS_VERSION="${MELONDS_VERSION}")
|
||||
string(REPLACE "." ";" VERSION_LIST ${MELONDS_VERSION})
|
||||
# For the melon.rc file used on Windows
|
||||
list(GET VERSION_LIST 0 MELONDS_VERSION_MAJOR)
|
||||
list(GET VERSION_LIST 1 MELONDS_VERSION_MINOR)
|
||||
# Check if melonDS version is three digits or two digits
|
||||
list(LENGTH VERSION_LIST MELONDS_VER_LEN)
|
||||
if (${MELONDS_VER_LEN} GREATER 2)
|
||||
list(GET VERSION_LIST 2 MELONDS_VERSION_PATCH)
|
||||
else()
|
||||
set(MELONDS_VERSION_PATCH 0)
|
||||
endif()
|
||||
|
||||
|
||||
check_library_exists(m pow "" LIBM)
|
||||
if(LIBM)
|
||||
link_libraries(m)
|
||||
endif()
|
||||
|
||||
if (NOT CMAKE_BUILD_TYPE)
|
||||
set(CMAKE_BUILD_TYPE Release)
|
||||
endif()
|
||||
|
||||
function(detect_architecture symbol arch)
|
||||
|
|
@ -62,40 +61,80 @@ detect_architecture("__i386__" x86)
|
|||
detect_architecture("__arm__" ARM)
|
||||
detect_architecture("__aarch64__" ARM64)
|
||||
|
||||
cmake_dependent_option(ENABLE_JIT "Enable JIT recompiler" ON
|
||||
"ARCHITECTURE STREQUAL x86_64 OR ARCHITECTURE STREQUAL ARM64" OFF)
|
||||
cmake_dependent_option(ENABLE_JIT_PROFILING "Enable JIT profiling with VTune" OFF "ENABLE_JIT" OFF)
|
||||
if (ARCHITECTURE STREQUAL x86_64 OR ARCHITECTURE STREQUAL ARM64)
|
||||
option(ENABLE_JIT "Enable x64 JIT recompiler" ON)
|
||||
endif()
|
||||
|
||||
if (ENABLE_JIT)
|
||||
add_definitions(-DJIT_ENABLED)
|
||||
|
||||
option(ENABLE_JIT_PROFILING "Enable JIT profiling with VTune" OFF)
|
||||
|
||||
if (ENABLE_JIT_PROFILING)
|
||||
include(cmake/FindVTune.cmake)
|
||||
add_definitions(-DJIT_PROFILING_ENABLED)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if (CMAKE_BUILD_TYPE STREQUAL Release)
|
||||
option(ENABLE_LTO "Enable link-time optimization" ON)
|
||||
else()
|
||||
option(ENABLE_LTO "Enable link-time optimization" OFF)
|
||||
endif()
|
||||
|
||||
option(ENABLE_OGLRENDERER "Enable OpenGL renderer" ON)
|
||||
|
||||
check_ipo_supported(RESULT IPO_SUPPORTED)
|
||||
cmake_dependent_option(ENABLE_LTO_RELEASE "Enable link-time optimizations for release builds" ON "IPO_SUPPORTED" OFF)
|
||||
cmake_dependent_option(ENABLE_LTO "Enable link-time optimizations" OFF "IPO_SUPPORTED" OFF)
|
||||
|
||||
if (ENABLE_LTO_RELEASE)
|
||||
set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_RELEASE TRUE)
|
||||
if (ENABLE_OGLRENDERER)
|
||||
add_definitions(-DOGLRENDERER_ENABLED)
|
||||
endif()
|
||||
|
||||
if (ENABLE_LTO)
|
||||
set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
|
||||
if (CMAKE_BUILD_TYPE STREQUAL Debug)
|
||||
add_compile_options(-Og)
|
||||
endif()
|
||||
|
||||
if (NOT APPLE)
|
||||
set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} -s")
|
||||
if (CMAKE_BUILD_TYPE STREQUAL Release)
|
||||
add_compile_options(-O3)
|
||||
if (NOT APPLE)
|
||||
add_link_options(-s)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if (WIN32)
|
||||
option(BUILD_STATIC "Statically link dependencies" OFF)
|
||||
option(BUILD_STATIC "Statically link dependencies" OFF)
|
||||
endif()
|
||||
|
||||
if (BUILD_STATIC AND WIN32)
|
||||
set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
|
||||
endif()
|
||||
|
||||
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
|
||||
if (ENABLE_LTO)
|
||||
if (WIN32 OR APPLE)
|
||||
add_compile_options(-flto)
|
||||
add_link_options(-flto)
|
||||
else()
|
||||
add_compile_options(-flto -fPIC)
|
||||
add_link_options(-flto -fuse-linker-plugin -pie)
|
||||
endif()
|
||||
if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
|
||||
set(CMAKE_AR "gcc-ar")
|
||||
set(CMAKE_RANLIB "gcc-ranlib")
|
||||
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
|
||||
find_program(LLD NAMES ld.lld ld64.lld lld-link)
|
||||
if (NOT LLD STREQUAL "LLD-NOTFOUND")
|
||||
add_link_options(-fuse-ld=lld)
|
||||
endif()
|
||||
if (NOT APPLE)
|
||||
set(CMAKE_AR "llvm-ar")
|
||||
set(CMAKE_RANLIB "llvm-ranlib")
|
||||
endif()
|
||||
endif()
|
||||
endif()
|
||||
|
||||
option(ENABLE_GDBSTUB "Enable GDB stub" ON)
|
||||
if (ENABLE_GDBSTUB)
|
||||
add_definitions(-DGDBSTUB_ENABLED)
|
||||
find_program(CCACHE "ccache")
|
||||
if (CCACHE)
|
||||
message(STATUS "Using CCache to speed up compilation")
|
||||
set(CMAKE_C_COMPILER_LAUNCHER ${CCACHE})
|
||||
set(CMAKE_CXX_COMPILER_LAUNCHER ${CCACHE})
|
||||
endif()
|
||||
|
||||
option(BUILD_QT_SDL "Build Qt/SDL frontend" ON)
|
||||
|
|
@ -103,5 +142,5 @@ option(BUILD_QT_SDL "Build Qt/SDL frontend" ON)
|
|||
add_subdirectory(src)
|
||||
|
||||
if (BUILD_QT_SDL)
|
||||
add_subdirectory(src/frontend/qt_sdl)
|
||||
add_subdirectory(src/frontend/qt_sdl)
|
||||
endif()
|
||||
|
|
|
|||
|
|
@ -1,105 +0,0 @@
|
|||
{
|
||||
"version": 6,
|
||||
"configurePresets": [
|
||||
{
|
||||
"name": "release",
|
||||
"displayName": "Release",
|
||||
"description": "Default release build configuration.",
|
||||
"generator": "Ninja",
|
||||
"binaryDir": "${sourceDir}/build/release"
|
||||
},
|
||||
{
|
||||
"inherits": "release",
|
||||
"name": "release-vcpkg",
|
||||
"displayName": "Release (vcpkg)",
|
||||
"description": "Release build with packages from vcpkg.",
|
||||
"cacheVariables": {
|
||||
"USE_VCPKG": {
|
||||
"type": "BOOL",
|
||||
"value": "ON"
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "release-mingw-x86_64",
|
||||
"inherits": "release-vcpkg",
|
||||
"displayName": "Windows MinGW release (x86_64)",
|
||||
"binaryDir": "${sourceDir}/build/release-mingw-x86_64",
|
||||
"generator": "Ninja",
|
||||
"cacheVariables": {
|
||||
"BUILD_STATIC": {
|
||||
"type": "BOOL",
|
||||
"value": "ON"
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"name": "release-mac-x86_64",
|
||||
"inherits": "release-vcpkg",
|
||||
"displayName": "macOS release (x86_64)",
|
||||
"binaryDir": "${sourceDir}/build/release-mac-x86_64",
|
||||
"cacheVariables": { "CMAKE_OSX_ARCHITECTURES": "x86_64" }
|
||||
},
|
||||
{
|
||||
"name": "release-mac-arm64",
|
||||
"inherits": "release-vcpkg",
|
||||
"displayName": "macOS release (arm64)",
|
||||
"binaryDir": "${sourceDir}/build/release-mac-arm64",
|
||||
"cacheVariables": { "CMAKE_OSX_ARCHITECTURES": "arm64" }
|
||||
}
|
||||
],
|
||||
"buildPresets": [
|
||||
{
|
||||
"name": "release",
|
||||
"configurePreset": "release"
|
||||
},
|
||||
{
|
||||
"name": "release-vcpkg",
|
||||
"configurePreset": "release-vcpkg"
|
||||
},
|
||||
{
|
||||
"name": "release-mingw-x86_64",
|
||||
"configurePreset": "release-mingw-x86_64"
|
||||
},
|
||||
{
|
||||
"name": "release-mac-x86_64",
|
||||
"configurePreset": "release-mac-x86_64"
|
||||
},
|
||||
{
|
||||
"name": "release-mac-arm64",
|
||||
"configurePreset": "release-mac-arm64"
|
||||
}
|
||||
],
|
||||
"workflowPresets": [
|
||||
{
|
||||
"name": "release",
|
||||
"displayName": "Release",
|
||||
"steps": [
|
||||
{ "type": "configure", "name": "release" },
|
||||
{ "type": "build", "name": "release" }
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "release-vcpkg",
|
||||
"displayName": "Release (vcpkg)",
|
||||
"steps": [
|
||||
{ "type": "configure", "name": "release-vcpkg" },
|
||||
{ "type": "build", "name": "release-vcpkg" }
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "release-mac-x86_64",
|
||||
"steps": [
|
||||
{ "type": "configure", "name": "release-mac-x86_64" },
|
||||
{ "type": "build", "name": "release-mac-x86_64" }
|
||||
]
|
||||
},
|
||||
{
|
||||
"name": "release-mac-arm64",
|
||||
"steps": [
|
||||
{ "type": "configure", "name": "release-mac-arm64" },
|
||||
{ "type": "build", "name": "release-mac-arm64" }
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
79
README.md
79
README.md
|
|
@ -1,15 +1,16 @@
|
|||
<p align="center"><img src="https://raw.githubusercontent.com/melonDS-emu/melonDS/master/res/icon/melon_128x128.png"></p>
|
||||
<p align="center"><img src="https://raw.githubusercontent.com/Arisotura/melonDS/master/res/icon/melon_128x128.png"></p>
|
||||
<h2 align="center"><b>melonDS</b></h2>
|
||||
<p align="center">
|
||||
<a href="http://melonds.kuribo64.net/" alt="melonDS website"><img src="https://img.shields.io/badge/website-melonds.kuribo64.net-%2331352e.svg"></a>
|
||||
<a href="http://melonds.kuribo64.net/downloads.php" alt="Release: 0.9.5"><img src="https://img.shields.io/badge/release-0.9.5-%235c913b.svg"></a>
|
||||
<a href="http://melonds.kuribo64.net/downloads.php" alt="Release: 0.9.4"><img src="https://img.shields.io/badge/release-0.9.4-%235c913b.svg"></a>
|
||||
<a href="https://www.gnu.org/licenses/gpl-3.0" alt="License: GPLv3"><img src="https://img.shields.io/badge/License-GPL%20v3-%23ff554d.svg"></a>
|
||||
<a href="https://kiwiirc.com/client/irc.badnik.net/?nick=IRC-Source_?#melonds" alt="IRC channel: #melonds"><img src="https://img.shields.io/badge/IRC%20chat-%23melonds-%23dd2e44.svg"></a>
|
||||
<a href="https://discord.gg/pAMAtExcqV" alt="Discord"><img src="https://img.shields.io/badge/Discord-Kuribo64-7289da?logo=discord&logoColor=white"></a>
|
||||
<br>
|
||||
<a href="https://github.com/melonDS-emu/melonDS/actions/workflows/build-windows.yml?query=event%3Apush"><img src="https://github.com/melonDS-emu/melonDS/actions/workflows/build-windows.yml/badge.svg" /></a>
|
||||
<a href="https://github.com/melonDS-emu/melonDS/actions/workflows/build-ubuntu.yml?query=event%3Apush"><img src="https://github.com/melonDS-emu/melonDS/actions/workflows/build-ubuntu.yml/badge.svg" /></a>
|
||||
<a href="https://github.com/melonDS-emu/melonDS/actions/workflows/build-macos.yml?query=event%3Apush"><img src="https://github.com/melonDS-emu/melonDS/actions/workflows/build-macos.yml/badge.svg" /></a>
|
||||
<a href="https://github.com/Arisotura/melonDS/actions?query=workflow%3A%22CMake+Build+%28Windows+x86-64%29%22+event%3Apush"><img src="https://img.shields.io/github/workflow/status/Arisotura/melonDS/CMake%20Build%20(Windows%20x86-64)?label=Windows%20x86-64&logo=GitHub"></img></a>
|
||||
<a href="https://github.com/Arisotura/melonDS/actions?query=workflow%3A%22CMake+Build+%28Ubuntu+x86-64%29%22+event%3Apush"><img src="https://img.shields.io/github/workflow/status/Arisotura/melonDS/CMake%20Build%20(Ubuntu%20x86-64)?label=Linux%20x86-64&logo=GitHub"></img></a>
|
||||
<a href="https://github.com/Arisotura/melonDS/actions?query=workflow%3A%22CMake+Build+%28Ubuntu+aarch64%29%22+event%3Apush"><img src="https://img.shields.io/github/workflow/status/Arisotura/melonDS/CMake%20Build%20(Ubuntu%20aarch64)?label=Linux%20ARM64&logo=GitHub"></img></a>
|
||||
<a href="https://dev.azure.com/melonDS/melonDS/_build?definitionId=1&repositoryFilter=1&branchFilter=2%2C2%2C2%2C2%2C2%2C2%2C2%2C2%2C2%2C2%2C2%2C2%2C2"><img src="https://img.shields.io/azure-devops/build/melonDS/7c9c08a1-669f-42a4-bef4-a6c74eadf723/1/master?label=macOS%20x86-64&logo=Azure%20Pipelines"></img></a>
|
||||
<a href="https://dev.azure.com/melonDS/melonDS/_build?definitionId=2&_a=summary&repositoryFilter=1&branchFilter=2%2C2%2C2%2C2%2C2"><img src="https://img.shields.io/azure-devops/build/melonDS/7c9c08a1-669f-42a4-bef4-a6c74eadf723/2/master?label=macOS%20ARM64&logo=Azure%20Pipelines"></img></a>
|
||||
</p>
|
||||
DS emulator, sorta
|
||||
|
||||
|
|
@ -32,13 +33,75 @@ DS BIOS dumps from a DSi or 3DS can be used with no compatibility issues. DSi BI
|
|||
As for the rest, the interface should be pretty straightforward. If you have a question, don't hesitate to ask, though!
|
||||
|
||||
## How to build
|
||||
See [BUILD.md](./BUILD.md) for build instructions.
|
||||
|
||||
### Linux:
|
||||
|
||||
1. Install dependencies: `sudo apt install cmake libcurl4-gnutls-dev libpcap0.8-dev libsdl2-dev qt5-default libslirp-dev libarchive-dev libepoxy-dev`
|
||||
2. Download the melonDS repository and prepare:
|
||||
```bash
|
||||
git clone https://github.com/Arisotura/melonDS
|
||||
cd melonDS
|
||||
mkdir build && cd build
|
||||
```
|
||||
3. Compile:
|
||||
```bash
|
||||
cmake ..
|
||||
make -j$(nproc --all)
|
||||
```
|
||||
|
||||
### Windows:
|
||||
|
||||
1. Install [MSYS2](https://www.msys2.org/)
|
||||
2. Open the **MSYS2 MinGW 64-bit** terminal
|
||||
3. Update the packages using `pacman -Syu` and reopen the terminal if it asks you to
|
||||
4. Download the melonDS repository and prepare:
|
||||
```bash
|
||||
git clone https://github.com/Arisotura/melonDS
|
||||
cd melonDS
|
||||
mkdir build && cd build
|
||||
```
|
||||
#### Dynamic builds (with DLLs)
|
||||
5. Install dependencies: `pacman -S git make mingw-w64-x86_64-{cmake,mesa,SDL2,toolchain,qt5,libslirp,libarchive,libepoxy}`
|
||||
6. Compile:
|
||||
```bash
|
||||
cmake .. -G "MSYS Makefiles"
|
||||
make -j$(nproc --all)
|
||||
../tools/msys-dist.sh
|
||||
```
|
||||
If everything went well, melonDS and the libraries it needs should now be in the `dist` folder.
|
||||
|
||||
#### Static builds (without DLLs, standalone executable)
|
||||
5. Install dependencies: `pacman -S git make mingw-w64-x86_64-{cmake,mesa,SDL2,toolchain,qt5-static,libslirp,libarchive,libepoxy}`
|
||||
6. Compile:
|
||||
```bash
|
||||
cmake .. -G 'MSYS Makefiles' -DBUILD_STATIC=ON -DQT5_STATIC_DIR=/mingw64/qt5-static
|
||||
make -j$(nproc --all)
|
||||
mkdir dist && cp melonDS.exe dist
|
||||
```
|
||||
If everything went well, melonDS should now be in the `dist` folder.
|
||||
|
||||
### macOS:
|
||||
1. Install the [Homebrew Package Manager](https://brew.sh)
|
||||
2. Install dependencies: `brew install git pkg-config cmake sdl2 qt@6 libslirp libarchive libepoxy`
|
||||
3. Download the melonDS repository and prepare:
|
||||
```zsh
|
||||
git clone https://github.com/Arisotura/melonDS
|
||||
cd melonDS
|
||||
mkdir build && cd build
|
||||
```
|
||||
4. Compile:
|
||||
```zsh
|
||||
cmake .. -DCMAKE_PREFIX_PATH="$(brew --prefix qt@6);$(brew --prefix libarchive)" -DUSE_QT6=ON -DMACOS_BUNDLE_LIBS=ON
|
||||
make -j$(sysctl -n hw.logicalcpu)
|
||||
```
|
||||
If everything went well, melonDS.app should now be in the current directory.
|
||||
|
||||
|
||||
## TODO LIST
|
||||
|
||||
* better DSi emulation
|
||||
* better OpenGL rendering
|
||||
* netplay
|
||||
* better wifi
|
||||
* the impossible quest of pixel-perfect 3D graphics
|
||||
* support for rendering screens to separate windows
|
||||
* emulating some fancy addons
|
||||
|
|
|
|||
|
|
@ -1,115 +0,0 @@
|
|||
include(FetchContent)
|
||||
|
||||
set(_DEFAULT_VCPKG_ROOT "${CMAKE_SOURCE_DIR}/vcpkg")
|
||||
set(VCPKG_ROOT "${_DEFAULT_VCPKG_ROOT}" CACHE STRING "The path to the vcpkg repository")
|
||||
|
||||
if (VCPKG_ROOT STREQUAL "${_DEFAULT_VCPKG_ROOT}")
|
||||
if (APPLE) # this doesn't work on non-macOS
|
||||
file(LOCK "${_DEFAULT_VCPKG_ROOT}" DIRECTORY GUARD FILE)
|
||||
endif()
|
||||
FetchContent_Declare(vcpkg
|
||||
GIT_REPOSITORY "https://github.com/Microsoft/vcpkg.git"
|
||||
GIT_TAG 2ad004460f5db4d3b66f62f5799ff66c265c4b5d
|
||||
EXCLUDE_FROM_ALL
|
||||
SOURCE_DIR "${CMAKE_SOURCE_DIR}/vcpkg")
|
||||
FetchContent_MakeAvailable(vcpkg)
|
||||
endif()
|
||||
|
||||
set(VCPKG_OVERLAY_TRIPLETS "${CMAKE_SOURCE_DIR}/cmake/overlay-triplets")
|
||||
|
||||
option(USE_RECOMMENDED_TRIPLETS "Use the recommended triplets that are used for official builds" ON)
|
||||
|
||||
# Duplicated here because it needs to be set before project()
|
||||
option(USE_QT6 "Use Qt 6 instead of Qt 5" ON)
|
||||
|
||||
# Since the Linux build pulls in glib anyway, we can just use upstream libslirp
|
||||
if (UNIX AND NOT APPLE)
|
||||
option(USE_SYSTEM_LIBSLIRP "Use system libslirp instead of the bundled version" ON)
|
||||
endif()
|
||||
|
||||
if (NOT USE_QT6)
|
||||
list(APPEND VCPKG_MANIFEST_FEATURES qt5)
|
||||
set(VCPKG_MANIFEST_NO_DEFAULT_FEATURES ON)
|
||||
endif()
|
||||
|
||||
if (CMAKE_OSX_ARCHITECTURES MATCHES ";")
|
||||
message(FATAL_ERROR "macOS universal builds are not supported. Build them individually and combine afterwards instead.")
|
||||
endif()
|
||||
|
||||
if (USE_RECOMMENDED_TRIPLETS)
|
||||
execute_process(
|
||||
COMMAND uname -m
|
||||
OUTPUT_VARIABLE _HOST_PROCESSOR
|
||||
OUTPUT_STRIP_TRAILING_WHITESPACE)
|
||||
|
||||
set(_CAN_TARGET_AS_HOST OFF)
|
||||
|
||||
if (APPLE)
|
||||
if (NOT CMAKE_OSX_ARCHITECTURES)
|
||||
if (_HOST_PROCESSOR STREQUAL arm64)
|
||||
set(CMAKE_OSX_ARCHITECTURES arm64)
|
||||
else()
|
||||
set(CMAKE_OSX_ARCHITECTURES x86_64)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if (CMAKE_OSX_ARCHITECTURES STREQUAL arm64)
|
||||
set(_WANTED_TRIPLET arm64-osx-11-release)
|
||||
set(CMAKE_OSX_DEPLOYMENT_TARGET 11.0)
|
||||
else()
|
||||
set(_WANTED_TRIPLET x64-osx-1015-release)
|
||||
set(CMAKE_OSX_DEPLOYMENT_TARGET 10.15)
|
||||
endif()
|
||||
elseif(WIN32)
|
||||
# TODO Windows arm64 if possible
|
||||
set(_CAN_TARGET_AS_HOST ON)
|
||||
set(_WANTED_TRIPLET x64-mingw-static-release)
|
||||
elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL Linux)
|
||||
# Can't really detect cross compiling here.
|
||||
set(_CAN_TARGET_AS_HOST ON)
|
||||
if (_HOST_PROCESSOR STREQUAL x86_64)
|
||||
set(_WANTED_TRIPLET x64-linux-release)
|
||||
elseif(_HOST_PROCESSOR STREQUAL "aarch64")
|
||||
set(_WANTED_TRIPLET arm64-linux-release)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# Don't override it if the user set something else
|
||||
if (NOT VCPKG_TARGET_TRIPLET)
|
||||
set(VCPKG_TARGET_TRIPLET "${_WANTED_TRIPLET}")
|
||||
else()
|
||||
set(_WANTED_TRIPLET "${VCPKG_TARGET_TRIPLET}")
|
||||
endif()
|
||||
|
||||
if (APPLE)
|
||||
if (_HOST_PROCESSOR MATCHES arm64)
|
||||
if (_WANTED_TRIPLET MATCHES "^arm64-osx-")
|
||||
set(_CAN_TARGET_AS_HOST ON)
|
||||
elseif (_WANTED_TRIPLET STREQUAL "x64-osx-1015-release")
|
||||
# Use the default triplet for when building for arm64
|
||||
# because we're probably making a universal build
|
||||
set(VCPKG_HOST_TRIPLET arm64-osx-11-release)
|
||||
endif()
|
||||
else()
|
||||
if (_WANTED_TRIPLET MATCHES "^x64-osx-")
|
||||
set(_CAN_TARGET_AS_HOST ON)
|
||||
elseif (_WANTED_TRIPLET STREQUAL "arm64-osx-11-release")
|
||||
set(VCPKG_HOST_TRIPLET x64-osx-1015-release)
|
||||
endif()
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# If host and target triplet differ, vcpkg seems to always assume that the host can't run the target's binaries.
|
||||
# In cases like cross compiling from ARM -> Intel macOS, or target being an older version of the host OS, we *can* do that so the packages built targeting the host are redundant.
|
||||
if (_CAN_TARGET_AS_HOST AND NOT VCPKG_HOST_TRIPLET)
|
||||
option(VCPKG_TARGET_AS_HOST "Use the target as host triplet to speed up builds" ON)
|
||||
else()
|
||||
option(VCPKG_TARGET_AS_HOST "Use the target as host triplet to speed up builds" OFF)
|
||||
endif()
|
||||
|
||||
if (VCPKG_TARGET_AS_HOST)
|
||||
set(VCPKG_HOST_TRIPLET "${VCPKG_TARGET_TRIPLET}" CACHE STRING "Host triplet to use for vcpkg")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
set(CMAKE_TOOLCHAIN_FILE "${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake")
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
if (CMAKE_C_COMPILER_ID STREQUAL GNU)
|
||||
set(CMAKE_C_FLAGS_DEBUG_INIT "-g -Og")
|
||||
endif()
|
||||
if (CMAKE_CXX_COMPILER_ID STREQUAL GNU)
|
||||
set(CMAKE_CXX_FLAGS_DEBUG_INIT "-g -Og")
|
||||
endif()
|
||||
|
||||
string(REPLACE "-O2" "-O3" CMAKE_C_FLAGS_RELEASE_INIT "${CMAKE_C_FLAGS_RELEASE_INIT}")
|
||||
string(REPLACE "-O2" "-O3" CMAKE_CXX_FLAGS_RELEASE_INIT "${CMAKE_CXX_FLAGS_RELEASE_INIT}")
|
||||
|
|
@ -1,297 +0,0 @@
|
|||
#.rst:
|
||||
# ECMFindModuleHelpers
|
||||
# --------------------
|
||||
#
|
||||
# Helper macros for find modules: ecm_find_package_version_check(),
|
||||
# ecm_find_package_parse_components() and
|
||||
# ecm_find_package_handle_library_components().
|
||||
#
|
||||
# ::
|
||||
#
|
||||
# ecm_find_package_version_check(<name>)
|
||||
#
|
||||
# Prints warnings if the CMake version or the project's required CMake version
|
||||
# is older than that required by extra-cmake-modules.
|
||||
#
|
||||
# ::
|
||||
#
|
||||
# ecm_find_package_parse_components(<name>
|
||||
# RESULT_VAR <variable>
|
||||
# KNOWN_COMPONENTS <component1> [<component2> [...]]
|
||||
# [SKIP_DEPENDENCY_HANDLING])
|
||||
#
|
||||
# This macro will populate <variable> with a list of components found in
|
||||
# <name>_FIND_COMPONENTS, after checking that all those components are in the
|
||||
# list of KNOWN_COMPONENTS; if there are any unknown components, it will print
|
||||
# an error or warning (depending on the value of <name>_FIND_REQUIRED) and call
|
||||
# return().
|
||||
#
|
||||
# The order of components in <variable> is guaranteed to match the order they
|
||||
# are listed in the KNOWN_COMPONENTS argument.
|
||||
#
|
||||
# If SKIP_DEPENDENCY_HANDLING is not set, for each component the variable
|
||||
# <name>_<component>_component_deps will be checked for dependent components.
|
||||
# If <component> is listed in <name>_FIND_COMPONENTS, then all its (transitive)
|
||||
# dependencies will also be added to <variable>.
|
||||
#
|
||||
# ::
|
||||
#
|
||||
# ecm_find_package_handle_library_components(<name>
|
||||
# COMPONENTS <component> [<component> [...]]
|
||||
# [SKIP_DEPENDENCY_HANDLING])
|
||||
# [SKIP_PKG_CONFIG])
|
||||
#
|
||||
# Creates an imported library target for each component. The operation of this
|
||||
# macro depends on the presence of a number of CMake variables.
|
||||
#
|
||||
# The <name>_<component>_lib variable should contain the name of this library,
|
||||
# and <name>_<component>_header variable should contain the name of a header
|
||||
# file associated with it (whatever relative path is normally passed to
|
||||
# '#include'). <name>_<component>_header_subdir variable can be used to specify
|
||||
# which subdirectory of the include path the headers will be found in.
|
||||
# ecm_find_package_components() will then search for the library
|
||||
# and include directory (creating appropriate cache variables) and create an
|
||||
# imported library target named <name>::<component>.
|
||||
#
|
||||
# Additional variables can be used to provide additional information:
|
||||
#
|
||||
# If SKIP_PKG_CONFIG, the <name>_<component>_pkg_config variable is set, and
|
||||
# pkg-config is found, the pkg-config module given by
|
||||
# <name>_<component>_pkg_config will be searched for and used to help locate the
|
||||
# library and header file. It will also be used to set
|
||||
# <name>_<component>_VERSION.
|
||||
#
|
||||
# Note that if version information is found via pkg-config,
|
||||
# <name>_<component>_FIND_VERSION can be set to require a particular version
|
||||
# for each component.
|
||||
#
|
||||
# If SKIP_DEPENDENCY_HANDLING is not set, the INTERFACE_LINK_LIBRARIES property
|
||||
# of the imported target for <component> will be set to contain the imported
|
||||
# targets for the components listed in <name>_<component>_component_deps.
|
||||
# <component>_FOUND will also be set to false if any of the compoments in
|
||||
# <name>_<component>_component_deps are not found. This requires the components
|
||||
# in <name>_<component>_component_deps to be listed before <component> in the
|
||||
# COMPONENTS argument.
|
||||
#
|
||||
# The following variables will be set:
|
||||
#
|
||||
# ``<name>_TARGETS``
|
||||
# the imported targets
|
||||
# ``<name>_LIBRARIES``
|
||||
# the found libraries
|
||||
# ``<name>_INCLUDE_DIRS``
|
||||
# the combined required include directories for the components
|
||||
# ``<name>_DEFINITIONS``
|
||||
# the "other" CFLAGS provided by pkg-config, if any
|
||||
# ``<name>_VERSION``
|
||||
# the value of ``<name>_<component>_VERSION`` for the first component that
|
||||
# has this variable set (note that components are searched for in the order
|
||||
# they are passed to the macro), although if it is already set, it will not
|
||||
# be altered
|
||||
#
|
||||
# Note that these variables are never cleared, so if
|
||||
# ecm_find_package_handle_library_components() is called multiple times with
|
||||
# different components (typically because of multiple find_package() calls) then
|
||||
# ``<name>_TARGETS``, for example, will contain all the targets found in any
|
||||
# call (although no duplicates).
|
||||
#
|
||||
# Since pre-1.0.0.
|
||||
|
||||
#=============================================================================
|
||||
# Copyright 2014 Alex Merry <alex.merry@kde.org>
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the copyright
|
||||
# notice, this list of conditions and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
# 3. The name of the author may not be used to endorse or promote products
|
||||
# derived from this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
include(CMakeParseArguments)
|
||||
|
||||
macro(ecm_find_package_version_check module_name)
|
||||
if(CMAKE_VERSION VERSION_LESS 2.8.12)
|
||||
message(FATAL_ERROR "CMake 2.8.12 is required by Find${module_name}.cmake")
|
||||
endif()
|
||||
if(CMAKE_MINIMUM_REQUIRED_VERSION VERSION_LESS 2.8.12)
|
||||
message(AUTHOR_WARNING "Your project should require at least CMake 2.8.12 to use Find${module_name}.cmake")
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
macro(ecm_find_package_parse_components module_name)
|
||||
set(ecm_fppc_options SKIP_DEPENDENCY_HANDLING)
|
||||
set(ecm_fppc_oneValueArgs RESULT_VAR)
|
||||
set(ecm_fppc_multiValueArgs KNOWN_COMPONENTS DEFAULT_COMPONENTS)
|
||||
cmake_parse_arguments(ECM_FPPC "${ecm_fppc_options}" "${ecm_fppc_oneValueArgs}" "${ecm_fppc_multiValueArgs}" ${ARGN})
|
||||
|
||||
if(ECM_FPPC_UNPARSED_ARGUMENTS)
|
||||
message(FATAL_ERROR "Unexpected arguments to ecm_find_package_parse_components: ${ECM_FPPC_UNPARSED_ARGUMENTS}")
|
||||
endif()
|
||||
if(NOT ECM_FPPC_RESULT_VAR)
|
||||
message(FATAL_ERROR "Missing RESULT_VAR argument to ecm_find_package_parse_components")
|
||||
endif()
|
||||
if(NOT ECM_FPPC_KNOWN_COMPONENTS)
|
||||
message(FATAL_ERROR "Missing KNOWN_COMPONENTS argument to ecm_find_package_parse_components")
|
||||
endif()
|
||||
if(NOT ECM_FPPC_DEFAULT_COMPONENTS)
|
||||
set(ECM_FPPC_DEFAULT_COMPONENTS ${ECM_FPPC_KNOWN_COMPONENTS})
|
||||
endif()
|
||||
|
||||
if(${module_name}_FIND_COMPONENTS)
|
||||
set(ecm_fppc_requestedComps ${${module_name}_FIND_COMPONENTS})
|
||||
|
||||
if(NOT ECM_FPPC_SKIP_DEPENDENCY_HANDLING)
|
||||
# Make sure deps are included
|
||||
foreach(ecm_fppc_comp ${ecm_fppc_requestedComps})
|
||||
foreach(ecm_fppc_dep_comp ${${module_name}_${ecm_fppc_comp}_component_deps})
|
||||
list(FIND ecm_fppc_requestedComps "${ecm_fppc_dep_comp}" ecm_fppc_index)
|
||||
if("${ecm_fppc_index}" STREQUAL "-1")
|
||||
if(NOT ${module_name}_FIND_QUIETLY)
|
||||
message(STATUS "${module_name}: ${ecm_fppc_comp} requires ${${module_name}_${ecm_fppc_comp}_component_deps}")
|
||||
endif()
|
||||
list(APPEND ecm_fppc_requestedComps "${ecm_fppc_dep_comp}")
|
||||
endif()
|
||||
endforeach()
|
||||
endforeach()
|
||||
else()
|
||||
message(STATUS "Skipping dependency handling for ${module_name}")
|
||||
endif()
|
||||
list(REMOVE_DUPLICATES ecm_fppc_requestedComps)
|
||||
|
||||
# This makes sure components are listed in the same order as
|
||||
# KNOWN_COMPONENTS (potentially important for inter-dependencies)
|
||||
set(${ECM_FPPC_RESULT_VAR})
|
||||
foreach(ecm_fppc_comp ${ECM_FPPC_KNOWN_COMPONENTS})
|
||||
list(FIND ecm_fppc_requestedComps "${ecm_fppc_comp}" ecm_fppc_index)
|
||||
if(NOT "${ecm_fppc_index}" STREQUAL "-1")
|
||||
list(APPEND ${ECM_FPPC_RESULT_VAR} "${ecm_fppc_comp}")
|
||||
list(REMOVE_AT ecm_fppc_requestedComps ${ecm_fppc_index})
|
||||
endif()
|
||||
endforeach()
|
||||
# if there are any left, they are unknown components
|
||||
if(ecm_fppc_requestedComps)
|
||||
set(ecm_fppc_msgType STATUS)
|
||||
if(${module_name}_FIND_REQUIRED)
|
||||
set(ecm_fppc_msgType FATAL_ERROR)
|
||||
endif()
|
||||
if(NOT ${module_name}_FIND_QUIETLY)
|
||||
message(${ecm_fppc_msgType} "${module_name}: requested unknown components ${ecm_fppc_requestedComps}")
|
||||
endif()
|
||||
return()
|
||||
endif()
|
||||
else()
|
||||
set(${ECM_FPPC_RESULT_VAR} ${ECM_FPPC_DEFAULT_COMPONENTS})
|
||||
endif()
|
||||
endmacro()
|
||||
|
||||
macro(ecm_find_package_handle_library_components module_name)
|
||||
set(ecm_fpwc_options SKIP_PKG_CONFIG SKIP_DEPENDENCY_HANDLING)
|
||||
set(ecm_fpwc_oneValueArgs)
|
||||
set(ecm_fpwc_multiValueArgs COMPONENTS)
|
||||
cmake_parse_arguments(ECM_FPWC "${ecm_fpwc_options}" "${ecm_fpwc_oneValueArgs}" "${ecm_fpwc_multiValueArgs}" ${ARGN})
|
||||
|
||||
if(ECM_FPWC_UNPARSED_ARGUMENTS)
|
||||
message(FATAL_ERROR "Unexpected arguments to ecm_find_package_handle_components: ${ECM_FPWC_UNPARSED_ARGUMENTS}")
|
||||
endif()
|
||||
if(NOT ECM_FPWC_COMPONENTS)
|
||||
message(FATAL_ERROR "Missing COMPONENTS argument to ecm_find_package_handle_components")
|
||||
endif()
|
||||
|
||||
include(FindPackageHandleStandardArgs)
|
||||
find_package(PkgConfig)
|
||||
foreach(ecm_fpwc_comp ${ECM_FPWC_COMPONENTS})
|
||||
set(ecm_fpwc_dep_vars)
|
||||
set(ecm_fpwc_dep_targets)
|
||||
if(NOT SKIP_DEPENDENCY_HANDLING)
|
||||
foreach(ecm_fpwc_dep ${${module_name}_${ecm_fpwc_comp}_component_deps})
|
||||
list(APPEND ecm_fpwc_dep_vars "${module_name}_${ecm_fpwc_dep}_FOUND")
|
||||
list(APPEND ecm_fpwc_dep_targets "${module_name}::${ecm_fpwc_dep}")
|
||||
endforeach()
|
||||
endif()
|
||||
|
||||
if(NOT ECM_FPWC_SKIP_PKG_CONFIG AND ${module_name}_${ecm_fpwc_comp}_pkg_config)
|
||||
pkg_check_modules(PKG_${module_name}_${ecm_fpwc_comp} QUIET
|
||||
${${module_name}_${ecm_fpwc_comp}_pkg_config})
|
||||
endif()
|
||||
|
||||
find_path(${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR
|
||||
NAMES ${${module_name}_${ecm_fpwc_comp}_header}
|
||||
HINTS ${PKG_${module_name}_${ecm_fpwc_comp}_INCLUDE_DIRS}
|
||||
PATH_SUFFIXES ${${module_name}_${ecm_fpwc_comp}_header_subdir}
|
||||
)
|
||||
find_library(${module_name}_${ecm_fpwc_comp}_LIBRARY
|
||||
NAMES ${${module_name}_${ecm_fpwc_comp}_lib}
|
||||
HINTS ${PKG_${module_name}_${ecm_fpwc_comp}_LIBRARY_DIRS}
|
||||
)
|
||||
|
||||
set(${module_name}_${ecm_fpwc_comp}_VERSION "${PKG_${module_name}_${ecm_fpwc_comp}_VERSION}")
|
||||
if(NOT ${module_name}_VERSION)
|
||||
set(${module_name}_VERSION ${${module_name}_${ecm_fpwc_comp}_VERSION})
|
||||
endif()
|
||||
|
||||
find_package_handle_standard_args(${module_name}_${ecm_fpwc_comp}
|
||||
FOUND_VAR
|
||||
${module_name}_${ecm_fpwc_comp}_FOUND
|
||||
REQUIRED_VARS
|
||||
${module_name}_${ecm_fpwc_comp}_LIBRARY
|
||||
${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR
|
||||
${ecm_fpwc_dep_vars}
|
||||
VERSION_VAR
|
||||
${module_name}_${ecm_fpwc_comp}_VERSION
|
||||
)
|
||||
|
||||
mark_as_advanced(
|
||||
${module_name}_${ecm_fpwc_comp}_LIBRARY
|
||||
${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR
|
||||
)
|
||||
|
||||
if(${module_name}_${ecm_fpwc_comp}_FOUND)
|
||||
list(APPEND ${module_name}_LIBRARIES
|
||||
"${${module_name}_${ecm_fpwc_comp}_LIBRARY}")
|
||||
list(APPEND ${module_name}_INCLUDE_DIRS
|
||||
"${${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR}")
|
||||
set(${module_name}_DEFINITIONS
|
||||
${${module_name}_DEFINITIONS}
|
||||
${PKG_${module_name}_${ecm_fpwc_comp}_DEFINITIONS})
|
||||
if(NOT TARGET ${module_name}::${ecm_fpwc_comp})
|
||||
add_library(${module_name}::${ecm_fpwc_comp} UNKNOWN IMPORTED)
|
||||
set_target_properties(${module_name}::${ecm_fpwc_comp} PROPERTIES
|
||||
IMPORTED_LOCATION "${${module_name}_${ecm_fpwc_comp}_LIBRARY}"
|
||||
INTERFACE_COMPILE_OPTIONS "${PKG_${module_name}_${ecm_fpwc_comp}_DEFINITIONS}"
|
||||
INTERFACE_INCLUDE_DIRECTORIES "${${module_name}_${ecm_fpwc_comp}_INCLUDE_DIR}"
|
||||
INTERFACE_LINK_LIBRARIES "${ecm_fpwc_dep_targets}"
|
||||
)
|
||||
endif()
|
||||
list(APPEND ${module_name}_TARGETS
|
||||
"${module_name}::${ecm_fpwc_comp}")
|
||||
endif()
|
||||
endforeach()
|
||||
if(${module_name}_LIBRARIES)
|
||||
list(REMOVE_DUPLICATES ${module_name}_LIBRARIES)
|
||||
endif()
|
||||
if(${module_name}_INCLUDE_DIRS)
|
||||
list(REMOVE_DUPLICATES ${module_name}_INCLUDE_DIRS)
|
||||
endif()
|
||||
if(${module_name}_DEFINITIONS)
|
||||
list(REMOVE_DUPLICATES ${module_name}_DEFINITIONS)
|
||||
endif()
|
||||
if(${module_name}_TARGETS)
|
||||
list(REMOVE_DUPLICATES ${module_name}_TARGETS)
|
||||
endif()
|
||||
endmacro()
|
||||
|
|
@ -1 +0,0 @@
|
|||
include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpers.cmake)
|
||||
|
|
@ -1,172 +0,0 @@
|
|||
#.rst:
|
||||
# FindEGL
|
||||
# -------
|
||||
#
|
||||
# Try to find EGL.
|
||||
#
|
||||
# This will define the following variables:
|
||||
#
|
||||
# ``EGL_FOUND``
|
||||
# True if (the requested version of) EGL is available
|
||||
# ``EGL_VERSION``
|
||||
# The version of EGL; note that this is the API version defined in the
|
||||
# headers, rather than the version of the implementation (eg: Mesa)
|
||||
# ``EGL_LIBRARIES``
|
||||
# This can be passed to target_link_libraries() instead of the ``EGL::EGL``
|
||||
# target
|
||||
# ``EGL_INCLUDE_DIRS``
|
||||
# This should be passed to target_include_directories() if the target is not
|
||||
# used for linking
|
||||
# ``EGL_DEFINITIONS``
|
||||
# This should be passed to target_compile_options() if the target is not
|
||||
# used for linking
|
||||
#
|
||||
# If ``EGL_FOUND`` is TRUE, it will also define the following imported target:
|
||||
#
|
||||
# ``EGL::EGL``
|
||||
# The EGL library
|
||||
#
|
||||
# In general we recommend using the imported target, as it is easier to use.
|
||||
# Bear in mind, however, that if the target is in the link interface of an
|
||||
# exported library, it must be made available by the package config file.
|
||||
#
|
||||
# Since pre-1.0.0.
|
||||
|
||||
#=============================================================================
|
||||
# Copyright 2014 Alex Merry <alex.merry@kde.org>
|
||||
# Copyright 2014 Martin Gräßlin <mgraesslin@kde.org>
|
||||
#
|
||||
# Redistribution and use in source and binary forms, with or without
|
||||
# modification, are permitted provided that the following conditions
|
||||
# are met:
|
||||
#
|
||||
# 1. Redistributions of source code must retain the copyright
|
||||
# notice, this list of conditions and the following disclaimer.
|
||||
# 2. Redistributions in binary form must reproduce the copyright
|
||||
# notice, this list of conditions and the following disclaimer in the
|
||||
# documentation and/or other materials provided with the distribution.
|
||||
# 3. The name of the author may not be used to endorse or promote products
|
||||
# derived from this software without specific prior written permission.
|
||||
#
|
||||
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
||||
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
||||
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
||||
# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||||
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
||||
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
||||
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
#=============================================================================
|
||||
|
||||
include(${CMAKE_CURRENT_LIST_DIR}/ECMFindModuleHelpersStub.cmake)
|
||||
include(CheckCXXSourceCompiles)
|
||||
include(CMakePushCheckState)
|
||||
|
||||
ecm_find_package_version_check(EGL)
|
||||
|
||||
# Use pkg-config to get the directories and then use these values
|
||||
# in the FIND_PATH() and FIND_LIBRARY() calls
|
||||
find_package(PkgConfig)
|
||||
pkg_check_modules(PKG_EGL QUIET egl)
|
||||
|
||||
set(EGL_DEFINITIONS ${PKG_EGL_CFLAGS_OTHER})
|
||||
|
||||
find_path(EGL_INCLUDE_DIR
|
||||
NAMES
|
||||
EGL/egl.h
|
||||
HINTS
|
||||
${PKG_EGL_INCLUDE_DIRS}
|
||||
)
|
||||
find_library(EGL_LIBRARY
|
||||
NAMES
|
||||
EGL
|
||||
HINTS
|
||||
${PKG_EGL_LIBRARY_DIRS}
|
||||
)
|
||||
|
||||
# NB: We do *not* use the version information from pkg-config, as that
|
||||
# is the implementation version (eg: the Mesa version)
|
||||
if(EGL_INCLUDE_DIR)
|
||||
# egl.h has defines of the form EGL_VERSION_x_y for each supported
|
||||
# version; so the header for EGL 1.1 will define EGL_VERSION_1_0 and
|
||||
# EGL_VERSION_1_1. Finding the highest supported version involves
|
||||
# finding all these defines and selecting the highest numbered.
|
||||
file(READ "${EGL_INCLUDE_DIR}/EGL/egl.h" _EGL_header_contents)
|
||||
string(REGEX MATCHALL
|
||||
"[ \t]EGL_VERSION_[0-9_]+"
|
||||
_EGL_version_lines
|
||||
"${_EGL_header_contents}"
|
||||
)
|
||||
unset(_EGL_header_contents)
|
||||
foreach(_EGL_version_line ${_EGL_version_lines})
|
||||
string(REGEX REPLACE
|
||||
"[ \t]EGL_VERSION_([0-9_]+)"
|
||||
"\\1"
|
||||
_version_candidate
|
||||
"${_EGL_version_line}"
|
||||
)
|
||||
string(REPLACE "_" "." _version_candidate "${_version_candidate}")
|
||||
if(NOT DEFINED EGL_VERSION OR EGL_VERSION VERSION_LESS _version_candidate)
|
||||
set(EGL_VERSION "${_version_candidate}")
|
||||
endif()
|
||||
endforeach()
|
||||
unset(_EGL_version_lines)
|
||||
endif()
|
||||
|
||||
cmake_push_check_state(RESET)
|
||||
list(APPEND CMAKE_REQUIRED_LIBRARIES "${EGL_LIBRARY}")
|
||||
list(APPEND CMAKE_REQUIRED_INCLUDES "${EGL_INCLUDE_DIR}")
|
||||
|
||||
check_cxx_source_compiles("
|
||||
#include <EGL/egl.h>
|
||||
|
||||
int main(int argc, char *argv[]) {
|
||||
EGLint x = 0; EGLDisplay dpy = 0; EGLContext ctx = 0;
|
||||
eglDestroyContext(dpy, ctx);
|
||||
}" HAVE_EGL)
|
||||
|
||||
cmake_pop_check_state()
|
||||
|
||||
set(required_vars EGL_INCLUDE_DIR HAVE_EGL)
|
||||
if(NOT EMSCRIPTEN)
|
||||
list(APPEND required_vars EGL_LIBRARY)
|
||||
endif()
|
||||
|
||||
include(FindPackageHandleStandardArgs)
|
||||
find_package_handle_standard_args(EGL
|
||||
FOUND_VAR
|
||||
EGL_FOUND
|
||||
REQUIRED_VARS
|
||||
${required_vars}
|
||||
VERSION_VAR
|
||||
EGL_VERSION
|
||||
)
|
||||
|
||||
if(EGL_FOUND AND NOT TARGET EGL::EGL)
|
||||
if (EMSCRIPTEN)
|
||||
add_library(EGL::EGL INTERFACE IMPORTED)
|
||||
# Nothing further to be done, system include paths have headers and linkage is implicit.
|
||||
else()
|
||||
add_library(EGL::EGL UNKNOWN IMPORTED)
|
||||
set_target_properties(EGL::EGL PROPERTIES
|
||||
IMPORTED_LOCATION "${EGL_LIBRARY}"
|
||||
INTERFACE_COMPILE_OPTIONS "${EGL_DEFINITIONS}"
|
||||
INTERFACE_INCLUDE_DIRECTORIES "${EGL_INCLUDE_DIR}"
|
||||
)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
mark_as_advanced(EGL_LIBRARY EGL_INCLUDE_DIR HAVE_EGL)
|
||||
|
||||
# compatibility variables
|
||||
set(EGL_LIBRARIES ${EGL_LIBRARY})
|
||||
set(EGL_INCLUDE_DIRS ${EGL_INCLUDE_DIR})
|
||||
set(EGL_VERSION_STRING ${EGL_VERSION})
|
||||
|
||||
include(FeatureSummary)
|
||||
set_package_properties(EGL PROPERTIES
|
||||
URL "https://www.khronos.org/egl/"
|
||||
DESCRIPTION "A platform-agnostic mechanism for creating rendering surfaces for use with other graphics libraries, such as OpenGL|ES and OpenVG."
|
||||
)
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
# - Try to find enet
|
||||
# Once done this will define
|
||||
#
|
||||
# ENET_FOUND - system has enet
|
||||
# ENET_INCLUDE_DIRS - the enet include directory
|
||||
# ENET_LIBRARIES - the libraries needed to use enet
|
||||
#
|
||||
# $ENETDIR is an environment variable used for finding enet.
|
||||
#
|
||||
# Borrowed from The Mana World
|
||||
# http://themanaworld.org/
|
||||
#
|
||||
# Several changes and additions by Fabian 'x3n' Landau
|
||||
# Lots of simplifications by Adrian Friedli
|
||||
# > www.orxonox.net <
|
||||
|
||||
FIND_PATH(ENET_INCLUDE_DIRS enet/enet.h
|
||||
PATHS
|
||||
$ENV{ENETDIR}
|
||||
/usr/local
|
||||
/usr
|
||||
PATH_SUFFIXES include
|
||||
)
|
||||
|
||||
FIND_LIBRARY(ENET_LIBRARY
|
||||
NAMES enet
|
||||
PATHS
|
||||
$ENV{ENETDIR}
|
||||
/usr/local
|
||||
/usr
|
||||
PATH_SUFFIXES lib
|
||||
)
|
||||
|
||||
# handle the QUIETLY and REQUIRED arguments and set ENET_FOUND to TRUE if
|
||||
# all listed variables are TRUE
|
||||
INCLUDE(FindPackageHandleStandardArgs)
|
||||
FIND_PACKAGE_HANDLE_STANDARD_ARGS(ENet DEFAULT_MSG ENET_LIBRARY ENET_INCLUDE_DIRS)
|
||||
|
||||
IF (ENET_FOUND)
|
||||
IF(WIN32)
|
||||
SET(WINDOWS_ENET_DEPENDENCIES "ws2_32;winmm")
|
||||
SET(ENET_LIBRARIES ${ENET_LIBRARY} ${WINDOWS_ENET_DEPENDENCIES})
|
||||
ELSE(WIN32)
|
||||
SET(ENET_LIBRARIES ${ENET_LIBRARY})
|
||||
ENDIF(WIN32)
|
||||
ENDIF (ENET_FOUND)
|
||||
|
||||
MARK_AS_ADVANCED(ENET_LIBRARY ENET_LIBRARIES ENET_INCLUDE_DIRS)
|
||||
|
|
@ -1,10 +1,5 @@
|
|||
|
||||
find_path(VTUNE_PATH "")
|
||||
|
||||
set(VTUNE_INCLUDE_DIR "${VTUNE_PATH}/include")
|
||||
|
||||
if (WIN32)
|
||||
set(VTUNE_LIBRARY "${VTUNE_PATH}/lib64/jitprofiling.lib")
|
||||
else()
|
||||
set(VTUNE_LIBRARY "${VTUNE_PATH}/lib64/jitprofiling.a")
|
||||
endif()
|
||||
include_directories("${VTUNE_PATH}/include")
|
||||
link_directories("${VTUNE_PATH}/lib64")
|
||||
|
|
|
|||
|
|
@ -1,35 +0,0 @@
|
|||
# The entire codebase quite reasonably does things like #include <SDL2/SDL.h> or <epoxy/gl.h>
|
||||
# CMake apparently doesn't think you should be doing this, so just includes $PREFIX/include/packagename for a given
|
||||
# package as include directories when using `target_link_libraries` with an imported target, this hacky function fixes
|
||||
# that up so includes can keep working as they always did but we can still use fancy imported targets.
|
||||
# This is stupid.
|
||||
|
||||
function(fix_interface_includes)
|
||||
foreach (target ${ARGN})
|
||||
set(NEW_DIRS)
|
||||
get_target_property(DIRS "${target}" INTERFACE_INCLUDE_DIRECTORIES)
|
||||
|
||||
if (NOT DIRS)
|
||||
continue()
|
||||
endif()
|
||||
|
||||
foreach (DIR ${DIRS})
|
||||
get_filename_component(PARENT_DIR "${DIR}" DIRECTORY)
|
||||
|
||||
if (PARENT_DIR MATCHES "include$")
|
||||
list(APPEND NEW_DIRS "${PARENT_DIR}")
|
||||
endif()
|
||||
|
||||
# HACK
|
||||
# The libarchive pkg-config file in MSYS2 seems to include a UNIX-style path for its
|
||||
# include directory and CMake doesn't like that.
|
||||
if (WIN32 AND MINGW AND target STREQUAL PkgConfig::LibArchive)
|
||||
list(FILTER DIRS EXCLUDE REGEX "^/[^.]+64/.*")
|
||||
endif()
|
||||
endforeach()
|
||||
|
||||
list(APPEND DIRS ${NEW_DIRS})
|
||||
set_target_properties("${target}" PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${DIRS}")
|
||||
endforeach()
|
||||
endfunction()
|
||||
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
set(SANITIZE "" CACHE STRING "Sanitizers to enable.")
|
||||
|
||||
string(REGEX MATCHALL "[^,]+" ENABLED_SANITIZERS "${SANITIZE}")
|
||||
|
||||
foreach(SANITIZER ${ENABLED_SANITIZERS})
|
||||
add_compile_options("-fsanitize=${SANITIZER}")
|
||||
add_link_options("-fsanitize=${SANITIZER}")
|
||||
endforeach()
|
||||
|
|
@ -1,19 +0,0 @@
|
|||
include(FindPackageMessage)
|
||||
|
||||
find_program(CCACHE "ccache")
|
||||
|
||||
cmake_dependent_option(USE_CCACHE "Use CCache to speed up repeated builds." ON CCACHE OFF)
|
||||
|
||||
if (NOT CCACHE OR NOT USE_CCACHE)
|
||||
return()
|
||||
endif()
|
||||
|
||||
# Fedora, and probably also Red Hat-based distros in general, use CCache by default if it's installed on the system.
|
||||
# We'll try to detect this here, and exit if that's the case.
|
||||
# Trying to launch ccache with ccache as we'd otherwise do seems to cause build issues.
|
||||
if (CMAKE_C_COMPILER MATCHES "ccache" OR CMAKE_CXX_COMPILER MATCHES "ccache")
|
||||
return()
|
||||
endif()
|
||||
|
||||
find_package_message(CCache "Using CCache to speed up compilation" "${USE_CCACHE}")
|
||||
set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CCACHE}")
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
set(VCPKG_TARGET_ARCHITECTURE arm64)
|
||||
set(VCPKG_CRT_LINKAGE dynamic)
|
||||
set(VCPKG_LIBRARY_LINKAGE static)
|
||||
|
||||
set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
|
||||
set(VCPKG_CMAKE_SYSTEM_VERSION 11.0)
|
||||
set(VCPKG_OSX_ARCHITECTURES arm64)
|
||||
set(VCPKG_BUILD_TYPE release)
|
||||
set(VCPKG_OSX_DEPLOYMENT_TARGET 11.0)
|
||||
|
||||
set(VCPKG_C_FLAGS -mmacosx-version-min=11.0)
|
||||
set(VCPKG_CXX_FLAGS -mmacosx-version-min=11.0)
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
set(VCPKG_TARGET_ARCHITECTURE x64)
|
||||
set(VCPKG_CRT_LINKAGE dynamic)
|
||||
set(VCPKG_LIBRARY_LINKAGE static)
|
||||
set(VCPKG_ENV_PASSTHROUGH PATH)
|
||||
set(VCPKG_BUILD_TYPE release)
|
||||
|
||||
set(VCPKG_CMAKE_SYSTEM_NAME MinGW)
|
||||
|
|
@ -1,12 +0,0 @@
|
|||
set(VCPKG_TARGET_ARCHITECTURE x64)
|
||||
set(VCPKG_CRT_LINKAGE dynamic)
|
||||
set(VCPKG_LIBRARY_LINKAGE static)
|
||||
|
||||
set(VCPKG_CMAKE_SYSTEM_NAME Darwin)
|
||||
set(VCPKG_CMAKE_SYSTEM_VERSION 10.15)
|
||||
set(VCPKG_OSX_ARCHITECTURES x86_64)
|
||||
set(VCPKG_BUILD_TYPE release)
|
||||
set(VCPKG_OSX_DEPLOYMENT_TARGET 10.15)
|
||||
|
||||
set(VCPKG_C_FLAGS -mmacosx-version-min=10.15)
|
||||
set(VCPKG_CXX_FLAGS -mmacosx-version-min=10.15)
|
||||
61
flake.lock
61
flake.lock
|
|
@ -1,61 +0,0 @@
|
|||
{
|
||||
"nodes": {
|
||||
"flake-utils": {
|
||||
"inputs": {
|
||||
"systems": "systems"
|
||||
},
|
||||
"locked": {
|
||||
"lastModified": 1731533236,
|
||||
"narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
|
||||
"owner": "numtide",
|
||||
"repo": "flake-utils",
|
||||
"rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "numtide",
|
||||
"repo": "flake-utils",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"nixpkgs": {
|
||||
"locked": {
|
||||
"lastModified": 1739020877,
|
||||
"narHash": "sha256-mIvECo/NNdJJ/bXjNqIh8yeoSjVLAuDuTUzAo7dzs8Y=",
|
||||
"owner": "NixOS",
|
||||
"repo": "nixpkgs",
|
||||
"rev": "a79cfe0ebd24952b580b1cf08cd906354996d547",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "NixOS",
|
||||
"ref": "nixos-unstable",
|
||||
"repo": "nixpkgs",
|
||||
"type": "github"
|
||||
}
|
||||
},
|
||||
"root": {
|
||||
"inputs": {
|
||||
"flake-utils": "flake-utils",
|
||||
"nixpkgs": "nixpkgs"
|
||||
}
|
||||
},
|
||||
"systems": {
|
||||
"locked": {
|
||||
"lastModified": 1681028828,
|
||||
"narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
|
||||
"owner": "nix-systems",
|
||||
"repo": "default",
|
||||
"rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
|
||||
"type": "github"
|
||||
},
|
||||
"original": {
|
||||
"owner": "nix-systems",
|
||||
"repo": "default",
|
||||
"type": "github"
|
||||
}
|
||||
}
|
||||
},
|
||||
"root": "root",
|
||||
"version": 7
|
||||
}
|
||||
109
flake.nix
109
flake.nix
|
|
@ -1,109 +0,0 @@
|
|||
{
|
||||
description = "Nintendo DS emulator";
|
||||
|
||||
inputs = {
|
||||
nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
|
||||
flake-utils.url = "github:numtide/flake-utils";
|
||||
};
|
||||
|
||||
outputs = { self, nixpkgs, flake-utils }: flake-utils.lib.eachDefaultSystem (system:
|
||||
let
|
||||
pkgs = import nixpkgs { inherit system; };
|
||||
inherit (pkgs.lib) cmakeBool optionals makeLibraryPath;
|
||||
inherit (pkgs.stdenv) isLinux isDarwin;
|
||||
|
||||
revision = with self; if sourceInfo?dirtyRev
|
||||
then sourceInfo.dirtyRev
|
||||
else sourceInfo.rev;
|
||||
shortRevision = with self; if sourceInfo?dirtyShortRev
|
||||
then sourceInfo.dirtyShortRev
|
||||
else sourceInfo.shortRev;
|
||||
|
||||
melonDS = pkgs.stdenv.mkDerivation {
|
||||
pname = "melonDS";
|
||||
version = "1.0-${shortRevision}";
|
||||
src = ./.;
|
||||
|
||||
nativeBuildInputs = with pkgs; [
|
||||
cmake
|
||||
ninja
|
||||
pkg-config
|
||||
qt6.wrapQtAppsHook
|
||||
];
|
||||
|
||||
buildInputs = (with pkgs; [
|
||||
qt6.qtbase
|
||||
qt6.qtmultimedia
|
||||
SDL2
|
||||
zstd
|
||||
libarchive
|
||||
libGL
|
||||
libslirp
|
||||
enet
|
||||
]) ++ optionals (!isDarwin) (with pkgs; [
|
||||
kdePackages.extra-cmake-modules
|
||||
qt6.qtwayland
|
||||
wayland
|
||||
]);
|
||||
|
||||
cmakeFlags = [
|
||||
(cmakeBool "USE_QT6" true)
|
||||
(cmakeBool "USE_SYSTEM_LIBSLIRP" true)
|
||||
(cmakeBool "MELONDS_EMBED_BUILD_INFO" true)
|
||||
];
|
||||
|
||||
env.MELONDS_GIT_HASH = revision;
|
||||
env.MELONDS_GIT_BRANCH = "(unknown)";
|
||||
env.MELONDS_BUILD_PROVIDER = "Nix";
|
||||
|
||||
qtWrapperArgs = optionals isLinux [
|
||||
"--prefix LD_LIBRARY_PATH : ${makeLibraryPath [ pkgs.libpcap pkgs.wayland ]}"
|
||||
] ++ optionals isDarwin [
|
||||
"--prefix DYLD_LIBRARY_PATH : ${makeLibraryPath [ pkgs.libpcap ]}"
|
||||
];
|
||||
|
||||
passthru = {
|
||||
exePath = if isDarwin then
|
||||
"/Applications/melonDS.app/Contents/MacOS/melonDS"
|
||||
else "/bin/melonDS";
|
||||
};
|
||||
};
|
||||
in {
|
||||
packages.default = melonDS;
|
||||
apps.default = flake-utils.lib.mkApp {
|
||||
drv = self.packages.${system}.default;
|
||||
};
|
||||
devShells = {
|
||||
default = pkgs.mkShell {
|
||||
inputsFrom = [ self.packages.${system}.default ];
|
||||
packages = with pkgs; [
|
||||
qt6.qttools
|
||||
];
|
||||
};
|
||||
|
||||
# Shell for building static melonDS release builds with vcpkg
|
||||
# Use mkShellNoCC to ensure Nix's gcc/clang and stdlib isn't used
|
||||
vcpkg = pkgs.mkShellNoCC {
|
||||
packages = with pkgs; [
|
||||
autoconf
|
||||
autoconf-archive
|
||||
automake
|
||||
cmake
|
||||
cups.dev # Needed by qtbase despite not enabling print support
|
||||
git
|
||||
iconv.dev
|
||||
libtool
|
||||
ninja
|
||||
pkg-config
|
||||
python3
|
||||
];
|
||||
|
||||
# Undo the SDK setup done by nixpkgs so we can use AppleClang
|
||||
shellHook = ''
|
||||
unset DEVELOPER_DIR SDKROOT MACOSX_DEPLOYMENT_TARGET
|
||||
'';
|
||||
};
|
||||
};
|
||||
}
|
||||
);
|
||||
}
|
||||
|
|
@ -517,9 +517,6 @@ swi_get_crc16:
|
|||
mov const_0x1E, #0x1E
|
||||
adr crc_table_ptr, crc_table
|
||||
|
||||
bic crc_value, crc_value, #0xFF000000
|
||||
bic crc_value, crc_value, #0x00FF0000
|
||||
|
||||
movs crc_length, crc_length, lsr #1
|
||||
beq 1f
|
||||
|
||||
|
|
@ -630,12 +627,13 @@ swi_bit_unpack:
|
|||
|
||||
#define lz77_control r3
|
||||
#define lz77_value r4
|
||||
#define lz77_vram_tmp r5
|
||||
#define lz77_value_b r14
|
||||
#define window_length r14
|
||||
#define window_offset r12
|
||||
#define window_ptr r12
|
||||
|
||||
// TODO: Do a separate version for VRAM
|
||||
swi_lz77_decompress_vram:
|
||||
swi_lz77_decompress_wram:
|
||||
ldr header, [ source ], #4
|
||||
movs length, header, lsr #8
|
||||
|
|
@ -688,75 +686,6 @@ swi_lz77_decompress_wram:
|
|||
movs lz77_control, lz77_control, lsl #1
|
||||
bpl 1b
|
||||
b 0b
|
||||
|
||||
|
||||
swi_lz77_decompress_vram:
|
||||
ldr header, [ source ], #4
|
||||
movs length, header, lsr #8
|
||||
beq swi_complete
|
||||
|
||||
stmdb sp!, { r5 }
|
||||
mov r5, #0
|
||||
|
||||
0:
|
||||
ldrb lz77_control, [ source ], #1
|
||||
// This will hit the MSB after 8 iterations
|
||||
orr lz77_control, lz77_control, #(1 << 23)
|
||||
|
||||
1:
|
||||
tst lz77_control, #0x80
|
||||
beq 2f
|
||||
|
||||
// Load a window of data that was loaded before
|
||||
|
||||
// Read 16-bit unaligned value
|
||||
ldrb lz77_value, [ source ], #1
|
||||
ldrb lz77_value_b, [ source ], #1
|
||||
orr lz77_value, lz77_value_b, lz77_value, lsl #8
|
||||
|
||||
// Get length and offset from lz77 value
|
||||
mov window_length, lz77_value, lsr #12
|
||||
bic window_offset, lz77_value, #0xF000
|
||||
|
||||
add window_length, window_length, #3
|
||||
sub window_ptr, dest, window_offset
|
||||
sub window_ptr, window_ptr, #1
|
||||
|
||||
3:
|
||||
tst dest, #1
|
||||
ldreqb lz77_vram_tmp, [ window_ptr ], #1
|
||||
ldrneb lz77_value, [ window_ptr ], #1
|
||||
orrne lz77_value, lz77_vram_tmp, lz77_value, lsl #8
|
||||
strneh lz77_value, [ dest, #-1 ]
|
||||
add dest, dest, #1
|
||||
|
||||
subs length, length, #1
|
||||
ldmeqia sp!, { r5 }
|
||||
beq swi_complete
|
||||
|
||||
subs window_length, window_length, #1
|
||||
bne 3b
|
||||
|
||||
movs lz77_control, lz77_control, lsl #1
|
||||
bpl 1b
|
||||
b 0b
|
||||
|
||||
// Load a single value
|
||||
2:
|
||||
tst dest, #1
|
||||
ldreqb lz77_vram_tmp, [ source ], #1
|
||||
ldrneb lz77_value, [ source ], #1
|
||||
orrne lz77_value, lz77_vram_tmp, lz77_value, lsl #8
|
||||
strneh lz77_value, [ dest, #-1 ]
|
||||
add dest, dest, #1
|
||||
|
||||
subs length, length, #1
|
||||
ldmeqia sp!, { r5 }
|
||||
beq swi_complete
|
||||
|
||||
movs lz77_control, lz77_control, lsl #1
|
||||
bpl 1b
|
||||
b 0b
|
||||
|
||||
|
||||
// TODO: Needs to be implemented
|
||||
|
|
|
|||
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 42 KiB After Width: | Height: | Size: 58 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 983 B After Width: | Height: | Size: 730 B |
Binary file not shown.
|
Before Width: | Height: | Size: 98 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 132 KiB After Width: | Height: | Size: 146 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 2.3 KiB After Width: | Height: | Size: 1.6 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 4.2 KiB After Width: | Height: | Size: 3.3 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB After Width: | Height: | Size: 32 KiB |
BIN
res/melon.icns
BIN
res/melon.icns
Binary file not shown.
|
|
@ -13,89 +13,26 @@
|
|||
<key>CFBundlePackageType</key>
|
||||
<string>APPL</string>
|
||||
<key>CFBundleVersion</key>
|
||||
<string>${melonDS_VERSION}</string>
|
||||
<string>${MELONDS_VERSION}</string>
|
||||
<key>CFBundleShortVersionString</key>
|
||||
<string>${melonDS_VERSION}</string>
|
||||
<key>LSApplicationCategoryType</key>
|
||||
<string>public.app-category.games</string>
|
||||
<string>${MELONDS_VERSION}</string>
|
||||
<key>NSHumanReadableCopyright</key>
|
||||
<string>Licensed under GPLv3</string>
|
||||
<key>NSPrincipalClass</key>
|
||||
<string>NSApplication</string>
|
||||
<key>NSHighResolutionCapable</key>
|
||||
<true/>
|
||||
<key>NSMicrophoneUsageDescription</key>
|
||||
<string>We need microphone access so you can use the emulated DS microphone</string>
|
||||
<key>NSCameraUsageDescription</key>
|
||||
<string>Camera access is needed for emulation of the DSi's cameras</string>
|
||||
<key>CFBundleDocumentTypes</key>
|
||||
<array>
|
||||
<dict>
|
||||
<key>CFBundleTypeName</key>
|
||||
<string>Nintendo DS ROM</string>
|
||||
<key>CFBundleTypeExtensions</key>
|
||||
<array>
|
||||
<string>nds</string>
|
||||
<string>srl</string>
|
||||
<string>dsi</string>
|
||||
<string>ids</string>
|
||||
<string>nds.zst</string>
|
||||
<string>srl.zst</string>
|
||||
<string>dsi.zst</string>
|
||||
<string>ids.zst</string>
|
||||
</array>
|
||||
<key>CFBundleTypeRole</key>
|
||||
<string>Viewer</string>
|
||||
</dict>
|
||||
<dict>
|
||||
<key>CFBundleTypeName</key>
|
||||
<string>Game Boy Advance ROM</string>
|
||||
<key>CFBundleTypeExtensions</key>
|
||||
<array>
|
||||
<string>gba</string>
|
||||
<string>agb</string>
|
||||
<string>gba.zst</string>
|
||||
<string>agb.zst</string>
|
||||
</array>
|
||||
<key>CFBundleTypeRole</key>
|
||||
<string>Viewer</string>
|
||||
<key>LSHandlerRank</key>
|
||||
<string>Alternate</string>
|
||||
</dict>
|
||||
<dict>
|
||||
<key>CFBundleTypeName</key>
|
||||
<string>Archive containing ROM</string>
|
||||
<key>CFBundleTypeExtensions</key>
|
||||
<array>
|
||||
<key>zip</key>
|
||||
<key>7z</key>
|
||||
<key>rar</key>
|
||||
<key>tar</key>
|
||||
<key>tar.gz</key>
|
||||
<key>tgz</key>
|
||||
<key>tar.xz</key>
|
||||
<key>txz</key>
|
||||
<key>tar.bz2</key>
|
||||
<key>tbz2</key>
|
||||
<key>tar.lz4</key>
|
||||
<key>tlz4</key>
|
||||
<key>tar.zst</key>
|
||||
<key>tzst</key>
|
||||
<key>tar.Z</key>
|
||||
<key>taz</key>
|
||||
<key>tar.lz</key>
|
||||
<key>tar.lzma</key>
|
||||
<key>tlz</key>
|
||||
<key>tar.lrz</key>
|
||||
<key>tlrz</key>
|
||||
<key>tar.lzo</key>
|
||||
<key>tzo</key>
|
||||
</array>
|
||||
<key>CFBundleTypeRole</key>
|
||||
<string>Viewer</string>
|
||||
<key>LSHandlerRank</key>
|
||||
<string>Alternate</string>
|
||||
</dict>
|
||||
</array>
|
||||
</dict>
|
||||
</plist>
|
||||
|
|
|
|||
|
|
@ -2,6 +2,5 @@
|
|||
<RCC version="1.0">
|
||||
<qresource>
|
||||
<file alias="melon-icon">icon/melon_256x256.png</file>
|
||||
<file alias="melon-logo">melon384.png</file>
|
||||
</qresource>
|
||||
</RCC>
|
||||
|
|
|
|||
|
|
@ -2,12 +2,12 @@
|
|||
#define VFT_APP 0x00000001L
|
||||
|
||||
//this will set your .exe icon
|
||||
100 ICON MOVEABLE PURE LOADONCALL DISCARDABLE "${CMAKE_SOURCE_DIR}/res/melon.ico"
|
||||
100 ICON MOVEABLE PURE LOADONCALL DISCARDABLE "res/melon.ico"
|
||||
|
||||
//include version information in .exe, modify these values to match your needs
|
||||
1 VERSIONINFO
|
||||
FILEVERSION ${MELON_RC_VERSION}
|
||||
PRODUCTVERSION ${MELON_RC_VERSION}
|
||||
FILEVERSION ${MELONDS_VERSION_MAJOR},${MELONDS_VERSION_MINOR},${MELONDS_VERSION_PATCH},0
|
||||
PRODUCTVERSION ${MELONDS_VERSION_MAJOR},${MELONDS_VERSION_MINOR},${MELONDS_VERSION_PATCH},0
|
||||
FILETYPE VFT_APP
|
||||
{
|
||||
BLOCK "StringFileInfo"
|
||||
|
|
@ -15,14 +15,14 @@ FILETYPE VFT_APP
|
|||
BLOCK "040904E4"
|
||||
{
|
||||
VALUE "CompanyName", "Melon Factory of Kuribo64"
|
||||
VALUE "FileVersion", "${melonDS_VERSION}"
|
||||
VALUE "FileVersion", "${MELONDS_VERSION}"
|
||||
VALUE "FileDescription", "melonDS emulator"
|
||||
VALUE "InternalName", "SDnolem"
|
||||
VALUE "LegalCopyright", "2016-2023 melonDS team"
|
||||
VALUE "LegalCopyright", "2016-2022 melonDS team"
|
||||
VALUE "LegalTrademarks", ""
|
||||
VALUE "OriginalFilename", "melonDS.exe"
|
||||
VALUE "OriginalFilename", "zafkflzdasd.exe"
|
||||
VALUE "ProductName", "melonDS"
|
||||
VALUE "ProductVersion", "${melonDS_VERSION}"
|
||||
VALUE "ProductVersion", "${MELONDS_VERSION}"
|
||||
}
|
||||
}
|
||||
BLOCK "VarFileInfo"
|
||||
|
|
@ -31,4 +31,4 @@ FILETYPE VFT_APP
|
|||
}
|
||||
}
|
||||
|
||||
1 24 "xp.manifest"
|
||||
1 24 "res/xp.manifest"
|
||||
|
|
|
|||
|
|
@ -1,80 +0,0 @@
|
|||
<svg width="1024" height="1024" xmlns="http://www.w3.org/2000/svg">
|
||||
<path fill="#5c913b" fill-rule="evenodd" d="M357.62 154.38c56.821-56.821 85.232-85.232 118.463-94.604a132.32 132.32 0 0 1 71.834 0c33.231 9.372 61.642 37.783 118.463 94.604l203.24 203.24c56.821 56.821 85.232 85.232 94.604 118.463a132.32 132.32 0 0 1 0 71.834c-9.372 33.231-37.783 61.642-94.604 118.463L666.38 869.62c-56.821 56.821-85.232 85.232-118.463 94.604a132.319 132.319 0 0 1-71.834 0c-33.231-9.372-61.642-37.783-118.463-94.604L154.38 666.38c-56.821-56.821-85.232-85.232-94.604-118.463a132.318 132.318 0 0 1 0-71.834c9.372-33.231 37.783-61.642 94.604-118.463Z"/>
|
||||
<filter id="a" x="0" y="0" width="1024" height="1024" filterUnits="userSpaceOnUse" primitiveUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
|
||||
<feGaussianBlur stdDeviation="18.378"/>
|
||||
<feOffset dy="7.351" result="offsetblur"/>
|
||||
<feFlood flood-color="#000" flood-opacity=".4"/>
|
||||
<feComposite in2="offsetblur" operator="in"/>
|
||||
<feMerge>
|
||||
<feMergeNode/>
|
||||
<feMergeNode in="SourceGraphic"/>
|
||||
</feMerge>
|
||||
</filter>
|
||||
<path fill="#ffe8b6" fill-rule="evenodd" filter="url(#a)" d="M383.23 209.478c47.35-47.35 71.026-71.026 98.72-78.836a110.266 110.266 0 0 1 59.86 0c27.694 7.81 51.369 31.486 98.72 78.836L814.66 383.61c47.351 47.351 71.027 71.026 78.837 98.72a110.265 110.265 0 0 1 0 59.86c-7.81 27.694-31.486 51.37-78.837 98.72L640.53 815.042c-47.351 47.35-71.027 71.026-98.72 78.836a110.265 110.265 0 0 1-59.86 0c-27.694-7.81-51.37-31.485-98.72-78.836L209.098 640.91c-47.35-47.35-71.026-71.026-78.836-98.72a110.266 110.266 0 0 1 0-59.86c7.81-27.694 31.485-51.369 78.836-98.72Z"/>
|
||||
<filter id="b" x="0" y="0" width="1024" height="1024" filterUnits="userSpaceOnUse" primitiveUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
|
||||
<feGaussianBlur stdDeviation="18.378"/>
|
||||
<feOffset dy="7.351" result="offsetblur"/>
|
||||
<feFlood flood-color="#000" flood-opacity=".4"/>
|
||||
<feComposite in2="offsetblur" operator="in"/>
|
||||
<feMerge>
|
||||
<feMergeNode/>
|
||||
<feMergeNode in="SourceGraphic"/>
|
||||
</feMerge>
|
||||
</filter>
|
||||
<path fill="#dd2e44" fill-rule="evenodd" filter="url(#b)" d="M404.822 239.527c39.46-39.46 59.189-59.189 82.266-65.697a91.889 91.889 0 0 1 49.885 0c23.077 6.508 42.807 26.238 82.266 65.697l165.295 165.295c39.459 39.46 59.188 59.189 65.697 82.266a91.888 91.888 0 0 1 0 49.884c-6.509 23.078-26.238 42.808-65.697 82.266L619.239 784.534c-39.46 39.459-59.189 59.188-82.266 65.697a91.888 91.888 0 0 1-49.885 0c-23.077-6.509-42.807-26.238-82.266-65.697L239.527 619.239c-39.46-39.46-59.189-59.189-65.697-82.267a91.888 91.888 0 0 1 0-49.884c6.508-23.077 26.238-42.807 65.697-82.266Z"/>
|
||||
<filter id="c" x="0" y="0" width="1024" height="1024" filterUnits="userSpaceOnUse" primitiveUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
|
||||
<feGaussianBlur stdDeviation="3.676"/>
|
||||
<feOffset dx="5.198" dy="5.198" result="offsetblur"/>
|
||||
<feFlood flood-color="#000" flood-opacity=".104"/>
|
||||
<feComposite in2="offsetblur" operator="in"/>
|
||||
<feMerge>
|
||||
<feMergeNode/>
|
||||
<feMergeNode in="SourceGraphic"/>
|
||||
</feMerge>
|
||||
</filter>
|
||||
<path fill="#ff554d" fill-rule="evenodd" filter="url(#c)" d="M405.568 606.767s-14.487 11.68-31.187 15.594c-9.553 2.238-24.422 1.568-31.188-5.198l-103.96-103.96c-6.766-6.766-7.436-21.635-5.198-31.187 3.914-16.7 15.594-31.188 15.594-31.188l197.523-197.523s14.488-11.68 31.188-15.594c9.553-2.239 24.422-1.568 31.188 5.198l103.96 103.96c6.765 6.765 7.436 21.634 5.197 31.187-3.913 16.7-15.594 31.188-15.594 31.188Z"/>
|
||||
<filter id="d" x="0" y="0" width="1024" height="1024" filterUnits="userSpaceOnUse" primitiveUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
|
||||
<feGaussianBlur stdDeviation="3.676"/>
|
||||
<feOffset dx="5.198" dy="5.198" result="offsetblur"/>
|
||||
<feFlood flood-color="#000" flood-opacity=".104"/>
|
||||
<feComposite in2="offsetblur" operator="in"/>
|
||||
<feMerge>
|
||||
<feMergeNode/>
|
||||
<feMergeNode in="SourceGraphic"/>
|
||||
</feMerge>
|
||||
</filter>
|
||||
<path fill="#ff554d" fill-rule="evenodd" filter="url(#d)" d="M574.579 779.453s-14.488 11.68-31.188 15.594c-9.553 2.238-24.422 1.568-31.188-5.198l-103.96-103.96c-6.765-6.766-7.436-21.635-5.197-31.187 3.914-16.7 15.594-31.188 15.594-31.188L616.163 425.99s14.488-11.68 31.187-15.594c9.553-2.239 24.422-1.568 31.188 5.198l103.96 103.96c6.766 6.765 7.436 21.634 5.198 31.187-3.914 16.7-15.594 31.188-15.594 31.188Z"/>
|
||||
<filter id="e" x="0" y="0" width="1024" height="1024" filterUnits="userSpaceOnUse" primitiveUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
|
||||
<feGaussianBlur stdDeviation="3.676"/>
|
||||
<feOffset dx="5.198" dy="5.198" result="offsetblur"/>
|
||||
<feFlood flood-color="#000" flood-opacity=".35"/>
|
||||
<feComposite in2="offsetblur" operator="in"/>
|
||||
<feMerge>
|
||||
<feMergeNode/>
|
||||
<feMergeNode in="SourceGraphic"/>
|
||||
</feMerge>
|
||||
</filter>
|
||||
<path fill="#31352e" fill-rule="evenodd" filter="url(#e)" d="M414.022 532.978s-8.315 6.704-17.9 8.95c-5.483 1.285-14.016.9-17.9-2.983l-59.667-59.667c-3.883-3.884-4.268-12.417-2.983-17.9 2.246-9.585 8.95-17.9 8.95-17.9L437.89 330.11s8.315-6.704 17.9-8.95c5.482-1.285 14.016-.9 17.9 2.984l59.666 59.666c3.884 3.884 4.269 12.418 2.984 17.9-2.246 9.585-8.95 17.9-8.95 17.9Z"/>
|
||||
<filter id="f" x="0" y="0" width="1024" height="1024" filterUnits="userSpaceOnUse" primitiveUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
|
||||
<feGaussianBlur stdDeviation="3.676"/>
|
||||
<feOffset dx="5.198" dy="5.198" result="offsetblur"/>
|
||||
<feFlood flood-color="#000" flood-opacity=".35"/>
|
||||
<feComposite in2="offsetblur" operator="in"/>
|
||||
<feMerge>
|
||||
<feMergeNode/>
|
||||
<feMergeNode in="SourceGraphic"/>
|
||||
</feMerge>
|
||||
</filter>
|
||||
<path fill="#31352e" fill-rule="evenodd" filter="url(#f)" d="M677.203 544.885c7.177 7.176 18.813 7.176 25.99 0l19.954-19.955c7.177-7.176 7.177-18.813 0-25.99l-19.954-19.954c-7.177-7.176-18.813-7.176-25.99 0l-19.954 19.955c-7.177 7.176-7.177 18.813 0 25.99Z"/>
|
||||
<filter id="g" x="0" y="0" width="1024" height="1024" filterUnits="userSpaceOnUse" primitiveUnits="userSpaceOnUse" color-interpolation-filters="sRGB">
|
||||
<feGaussianBlur stdDeviation="3.676"/>
|
||||
<feOffset dx="5.198" dy="5.198" result="offsetblur"/>
|
||||
<feFlood flood-color="#000" flood-opacity=".35"/>
|
||||
<feComposite in2="offsetblur" operator="in"/>
|
||||
<feMerge>
|
||||
<feMergeNode/>
|
||||
<feMergeNode in="SourceGraphic"/>
|
||||
</feMerge>
|
||||
</filter>
|
||||
<path fill="#31352e" fill-rule="evenodd" filter="url(#g)" d="M489.752 728.66c7.177 7.177 18.813 7.177 25.99 0l19.954-19.954c7.177-7.177 7.177-18.813 0-25.99l-19.954-19.954c-7.177-7.176-18.813-7.176-25.99 0l-19.954 19.955c-7.177 7.176-7.177 18.812 0 25.99Z"/>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 6.8 KiB |
BIN
res/melon384.png
BIN
res/melon384.png
Binary file not shown.
|
Before Width: | Height: | Size: 27 KiB |
BIN
res/melon512.png
BIN
res/melon512.png
Binary file not shown.
|
Before Width: | Height: | Size: 38 KiB |
|
|
@ -4,7 +4,7 @@
|
|||
manifestVersion="1.0">
|
||||
<assemblyIdentity
|
||||
name="Exe.Apps.Project"
|
||||
processorArchitecture="${WIN32_ARCHITECTURE}"
|
||||
processorArchitecture="amd64"
|
||||
version="1.0.0.0"
|
||||
type="win32"/>
|
||||
<description>Project</description>
|
||||
|
|
@ -14,7 +14,7 @@
|
|||
type="win32"
|
||||
name="Microsoft.Windows.Common-Controls"
|
||||
version="6.0.0.0"
|
||||
processorArchitecture="${WIN32_ARCHITECTURE}"
|
||||
processorArchitecture="amd64"
|
||||
publicKeyToken="6595b64144ccf1df"
|
||||
language="*"
|
||||
/>
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -21,43 +21,31 @@
|
|||
#include "ARCodeFile.h"
|
||||
#include "Platform.h"
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
using namespace Platform;
|
||||
|
||||
// TODO: import codes from other sources (usrcheat.dat, ...)
|
||||
// TODO: more user-friendly error reporting
|
||||
|
||||
|
||||
ARCodeFile::ARCodeFile(const std::string& filename)
|
||||
ARCodeFile::ARCodeFile(std::string filename)
|
||||
{
|
||||
Filename = filename;
|
||||
|
||||
Error = false;
|
||||
|
||||
Categories.clear();
|
||||
|
||||
if (!Load())
|
||||
Error = true;
|
||||
}
|
||||
|
||||
std::vector<ARCode> ARCodeFile::GetCodes() const noexcept
|
||||
ARCodeFile::~ARCodeFile()
|
||||
{
|
||||
if (Error)
|
||||
return {};
|
||||
|
||||
std::vector<ARCode> codes;
|
||||
|
||||
for (const ARCodeCat& cat : Categories)
|
||||
{
|
||||
for (const ARCode& code : cat.Codes)
|
||||
{
|
||||
codes.push_back(code);
|
||||
}
|
||||
}
|
||||
|
||||
return codes;
|
||||
Categories.clear();
|
||||
}
|
||||
|
||||
bool ARCodeFile::Load()
|
||||
{
|
||||
FileHandle* f = OpenFile(Filename, FileMode::ReadText);
|
||||
FILE* f = Platform::OpenFile(Filename, "r");
|
||||
if (!f) return true;
|
||||
|
||||
Categories.clear();
|
||||
|
|
@ -69,9 +57,9 @@ bool ARCodeFile::Load()
|
|||
ARCode curcode;
|
||||
|
||||
char linebuf[1024];
|
||||
while (!IsEndOfFile(f))
|
||||
while (!feof(f))
|
||||
{
|
||||
if (!FileReadLine(linebuf, 1024, f))
|
||||
if (fgets(linebuf, 1024, f) == nullptr)
|
||||
break;
|
||||
|
||||
linebuf[1023] = '\0';
|
||||
|
|
@ -91,8 +79,8 @@ bool ARCodeFile::Load()
|
|||
|
||||
if (ret < 1)
|
||||
{
|
||||
Log(LogLevel::Error, "AR: malformed CAT line: %s\n", start);
|
||||
CloseFile(f);
|
||||
printf("AR: malformed CAT line: %s\n", start);
|
||||
fclose(f);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -114,15 +102,15 @@ bool ARCodeFile::Load()
|
|||
|
||||
if (ret < 2)
|
||||
{
|
||||
Log(LogLevel::Error, "AR: malformed CODE line: %s\n", start);
|
||||
CloseFile(f);
|
||||
printf("AR: malformed CODE line: %s\n", start);
|
||||
fclose(f);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!isincat)
|
||||
{
|
||||
Log(LogLevel::Error, "AR: encountered CODE line with no category started\n");
|
||||
CloseFile(f);
|
||||
printf("AR: encountered CODE line with no category started\n");
|
||||
fclose(f);
|
||||
return false;
|
||||
}
|
||||
|
||||
|
|
@ -131,7 +119,7 @@ bool ARCodeFile::Load()
|
|||
|
||||
curcode.Name = codename;
|
||||
curcode.Enabled = enable!=0;
|
||||
curcode.Code.clear();
|
||||
curcode.CodeLen = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -140,58 +128,65 @@ bool ARCodeFile::Load()
|
|||
|
||||
if (ret < 2)
|
||||
{
|
||||
Log(LogLevel::Error, "AR: malformed data line: %s\n", start);
|
||||
CloseFile(f);
|
||||
printf("AR: malformed data line: %s\n", start);
|
||||
fclose(f);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!isincode)
|
||||
{
|
||||
Log(LogLevel::Error, "AR: encountered data line with no code started\n");
|
||||
CloseFile(f);
|
||||
printf("AR: encountered data line with no code started\n");
|
||||
fclose(f);
|
||||
return false;
|
||||
}
|
||||
|
||||
curcode.Code.push_back(c0);
|
||||
curcode.Code.push_back(c1);
|
||||
if (curcode.CodeLen >= 2*64)
|
||||
{
|
||||
printf("AR: code too long!\n");
|
||||
fclose(f);
|
||||
return false;
|
||||
}
|
||||
|
||||
u32 idx = curcode.CodeLen;
|
||||
curcode.Code[idx+0] = c0;
|
||||
curcode.Code[idx+1] = c1;
|
||||
curcode.CodeLen += 2;
|
||||
}
|
||||
}
|
||||
|
||||
if (isincode) curcat.Codes.push_back(curcode);
|
||||
if (isincat) Categories.push_back(curcat);
|
||||
|
||||
CloseFile(f);
|
||||
fclose(f);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ARCodeFile::Save()
|
||||
{
|
||||
FileHandle* f = Platform::OpenFile(Filename, FileMode::WriteText);
|
||||
FILE* f = Platform::OpenFile(Filename, "w");
|
||||
if (!f) return false;
|
||||
|
||||
for (ARCodeCatList::iterator it = Categories.begin(); it != Categories.end(); it++)
|
||||
{
|
||||
ARCodeCat& cat = *it;
|
||||
|
||||
if (it != Categories.begin()) FileWriteFormatted(f, "\n");
|
||||
FileWriteFormatted(f, "CAT %s\n\n", cat.Name.c_str());
|
||||
if (it != Categories.begin()) fprintf(f, "\r\n");
|
||||
fprintf(f, "CAT %s\r\n\r\n", cat.Name.c_str());
|
||||
|
||||
for (ARCodeList::iterator jt = cat.Codes.begin(); jt != cat.Codes.end(); jt++)
|
||||
{
|
||||
ARCode& code = *jt;
|
||||
FileWriteFormatted(f, "CODE %d %s\n", code.Enabled, code.Name.c_str());
|
||||
fprintf(f, "CODE %d %s\r\n", code.Enabled, code.Name.c_str());
|
||||
|
||||
for (size_t i = 0; i < code.Code.size(); i+=2)
|
||||
for (u32 i = 0; i < code.CodeLen; i+=2)
|
||||
{
|
||||
FileWriteFormatted(f, "%08X %08X\n", code.Code[i], code.Code[i + 1]);
|
||||
fprintf(f, "%08X %08X\r\n", code.Code[i], code.Code[i+1]);
|
||||
}
|
||||
|
||||
FileWriteFormatted(f, "\n");
|
||||
fprintf(f, "\r\n");
|
||||
}
|
||||
}
|
||||
|
||||
CloseFile(f);
|
||||
fclose(f);
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -21,16 +21,15 @@
|
|||
|
||||
#include <string>
|
||||
#include <list>
|
||||
#include <vector>
|
||||
|
||||
#include "types.h"
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
struct ARCode
|
||||
{
|
||||
std::string Name;
|
||||
bool Enabled;
|
||||
std::vector<u32> Code;
|
||||
u32 CodeLen;
|
||||
u32 Code[2*64];
|
||||
};
|
||||
|
||||
typedef std::list<ARCode> ARCodeList;
|
||||
|
|
@ -47,21 +46,18 @@ typedef std::list<ARCodeCat> ARCodeCatList;
|
|||
class ARCodeFile
|
||||
{
|
||||
public:
|
||||
ARCodeFile(const std::string& filename);
|
||||
~ARCodeFile() noexcept = default;
|
||||
ARCodeFile(std::string filename);
|
||||
~ARCodeFile();
|
||||
|
||||
[[nodiscard]] std::vector<ARCode> GetCodes() const noexcept;
|
||||
|
||||
bool Error = false;
|
||||
bool Error;
|
||||
|
||||
bool Load();
|
||||
bool Save();
|
||||
|
||||
ARCodeCatList Categories {};
|
||||
ARCodeCatList Categories;
|
||||
|
||||
private:
|
||||
std::string Filename;
|
||||
};
|
||||
|
||||
}
|
||||
#endif // ARCODEFILE_H
|
||||
|
|
|
|||
141
src/AREngine.cpp
141
src/AREngine.cpp
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -21,34 +21,83 @@
|
|||
#include "NDS.h"
|
||||
#include "DSi.h"
|
||||
#include "AREngine.h"
|
||||
#include "Platform.h"
|
||||
|
||||
namespace melonDS
|
||||
|
||||
namespace AREngine
|
||||
{
|
||||
|
||||
using Platform::Log;
|
||||
using Platform::LogLevel;
|
||||
// AR code file - frontend is responsible for managing this
|
||||
ARCodeFile* CodeFile;
|
||||
|
||||
AREngine::AREngine(melonDS::NDS& nds) : NDS(nds)
|
||||
u8 (*BusRead8)(u32 addr);
|
||||
u16 (*BusRead16)(u32 addr);
|
||||
u32 (*BusRead32)(u32 addr);
|
||||
void (*BusWrite8)(u32 addr, u8 val);
|
||||
void (*BusWrite16)(u32 addr, u16 val);
|
||||
void (*BusWrite32)(u32 addr, u32 val);
|
||||
|
||||
|
||||
bool Init()
|
||||
{
|
||||
CodeFile = nullptr;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void DeInit()
|
||||
{
|
||||
}
|
||||
|
||||
void Reset()
|
||||
{
|
||||
if (NDS::ConsoleType == 1)
|
||||
{
|
||||
BusRead8 = DSi::ARM7Read8;
|
||||
BusRead16 = DSi::ARM7Read16;
|
||||
BusRead32 = DSi::ARM7Read32;
|
||||
BusWrite8 = DSi::ARM7Write8;
|
||||
BusWrite16 = DSi::ARM7Write16;
|
||||
BusWrite32 = DSi::ARM7Write32;
|
||||
}
|
||||
else
|
||||
{
|
||||
BusRead8 = NDS::ARM7Read8;
|
||||
BusRead16 = NDS::ARM7Read16;
|
||||
BusRead32 = NDS::ARM7Read32;
|
||||
BusWrite8 = NDS::ARM7Write8;
|
||||
BusWrite16 = NDS::ARM7Write16;
|
||||
BusWrite32 = NDS::ARM7Write32;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
ARCodeFile* GetCodeFile()
|
||||
{
|
||||
return CodeFile;
|
||||
}
|
||||
|
||||
void SetCodeFile(ARCodeFile* file)
|
||||
{
|
||||
CodeFile = file;
|
||||
}
|
||||
|
||||
|
||||
#define case16(x) \
|
||||
case ((x)+0x00): case ((x)+0x01): case ((x)+0x02): case ((x)+0x03): \
|
||||
case ((x)+0x04): case ((x)+0x05): case ((x)+0x06): case ((x)+0x07): \
|
||||
case ((x)+0x08): case ((x)+0x09): case ((x)+0x0A): case ((x)+0x0B): \
|
||||
case ((x)+0x0C): case ((x)+0x0D): case ((x)+0x0E): case ((x)+0x0F)
|
||||
|
||||
void AREngine::RunCheat(const ARCode& arcode)
|
||||
void RunCheat(ARCode& arcode)
|
||||
{
|
||||
const u32* code = &arcode.Code[0];
|
||||
u32* code = &arcode.Code[0];
|
||||
|
||||
u32 offset = 0;
|
||||
u32 datareg = 0;
|
||||
u32 cond = 1;
|
||||
u32 condstack = 0;
|
||||
|
||||
const u32* loopstart = code;
|
||||
u32* loopstart = code;
|
||||
u32 loopcount = 0;
|
||||
u32 loopcond = 1;
|
||||
u32 loopcondstack = 0;
|
||||
|
|
@ -58,7 +107,7 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
|
||||
for (;;)
|
||||
{
|
||||
if (code >= &arcode.Code[arcode.Code.size()])
|
||||
if (code >= &arcode.Code[arcode.CodeLen])
|
||||
break;
|
||||
|
||||
u32 a = *code++;
|
||||
|
|
@ -83,15 +132,15 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
switch (op)
|
||||
{
|
||||
case16(0x00): // 32-bit write
|
||||
NDS.ARM7Write32((a & 0x0FFFFFFF) + offset, b);
|
||||
BusWrite32((a & 0x0FFFFFFF) + offset, b);
|
||||
break;
|
||||
|
||||
case16(0x10): // 16-bit write
|
||||
NDS.ARM7Write16((a & 0x0FFFFFFF) + offset, b & 0xFFFF);
|
||||
BusWrite16((a & 0x0FFFFFFF) + offset, b & 0xFFFF);
|
||||
break;
|
||||
|
||||
case16(0x20): // 8-bit write
|
||||
NDS.ARM7Write8((a & 0x0FFFFFFF) + offset, b & 0xFF);
|
||||
BusWrite8((a & 0x0FFFFFFF) + offset, b & 0xFF);
|
||||
break;
|
||||
|
||||
case16(0x30): // IF b > u32[a]
|
||||
|
|
@ -101,7 +150,7 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
|
||||
u32 addr = a & 0x0FFFFFFF;
|
||||
if (!addr) addr = offset;
|
||||
u32 chk = NDS.ARM7Read32(addr);
|
||||
u32 chk = BusRead32(addr);
|
||||
|
||||
cond = (b > chk) ? 1:0;
|
||||
}
|
||||
|
|
@ -114,7 +163,7 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
|
||||
u32 addr = a & 0x0FFFFFFF;
|
||||
if (!addr) addr = offset;
|
||||
u32 chk = NDS.ARM7Read32(addr);
|
||||
u32 chk = BusRead32(addr);
|
||||
|
||||
cond = (b < chk) ? 1:0;
|
||||
}
|
||||
|
|
@ -127,7 +176,7 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
|
||||
u32 addr = a & 0x0FFFFFFF;
|
||||
if (!addr) addr = offset;
|
||||
u32 chk = NDS.ARM7Read32(addr);
|
||||
u32 chk = BusRead32(addr);
|
||||
|
||||
cond = (b == chk) ? 1:0;
|
||||
}
|
||||
|
|
@ -140,7 +189,7 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
|
||||
u32 addr = a & 0x0FFFFFFF;
|
||||
if (!addr) addr = offset;
|
||||
u32 chk = NDS.ARM7Read32(addr);
|
||||
u32 chk = BusRead32(addr);
|
||||
|
||||
cond = (b != chk) ? 1:0;
|
||||
}
|
||||
|
|
@ -153,7 +202,7 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
|
||||
u32 addr = a & 0x0FFFFFFF;
|
||||
if (!addr) addr = offset;
|
||||
u16 val = NDS.ARM7Read16(addr);
|
||||
u16 val = BusRead16(addr);
|
||||
u16 chk = ~(b >> 16);
|
||||
chk &= val;
|
||||
|
||||
|
|
@ -168,7 +217,7 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
|
||||
u32 addr = a & 0x0FFFFFFF;
|
||||
if (!addr) addr = offset;
|
||||
u16 val = NDS.ARM7Read16(addr);
|
||||
u16 val = BusRead16(addr);
|
||||
u16 chk = ~(b >> 16);
|
||||
chk &= val;
|
||||
|
||||
|
|
@ -183,7 +232,7 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
|
||||
u32 addr = a & 0x0FFFFFFF;
|
||||
if (!addr) addr = offset;
|
||||
u16 val = NDS.ARM7Read16(addr);
|
||||
u16 val = BusRead16(addr);
|
||||
u16 chk = ~(b >> 16);
|
||||
chk &= val;
|
||||
|
||||
|
|
@ -198,7 +247,7 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
|
||||
u32 addr = a & 0x0FFFFFFF;
|
||||
if (!addr) addr = offset;
|
||||
u16 val = NDS.ARM7Read16(addr);
|
||||
u16 val = BusRead16(addr);
|
||||
u16 chk = ~(b >> 16);
|
||||
chk &= val;
|
||||
|
||||
|
|
@ -207,7 +256,7 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
break;
|
||||
|
||||
case16(0xB0): // offset = u32[a + offset]
|
||||
offset = NDS.ARM7Read32((a & 0x0FFFFFFF) + offset);
|
||||
offset = BusRead32((a & 0x0FFFFFFF) + offset);
|
||||
break;
|
||||
|
||||
case 0xC0: // FOR 0..b
|
||||
|
|
@ -222,7 +271,7 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
// in practice could be used for a self-modifying AR code
|
||||
// could be implemented with some hackery, but, does anything even
|
||||
// use it??
|
||||
Log(LogLevel::Error, "AR: !! THE FUCKING C4000000 OPCODE. TELL ARISOTURA.\n");
|
||||
printf("AR: !! THE FUCKING C4000000 OPCODE. TELL ARISOTURA.\n");
|
||||
return;
|
||||
|
||||
case 0xC5: // count++ / IF (count & b.l) == b.h
|
||||
|
|
@ -244,7 +293,7 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
break;
|
||||
|
||||
case 0xC6: // u32[b] = offset
|
||||
NDS.ARM7Write32(b, offset);
|
||||
BusWrite32(b, offset);
|
||||
break;
|
||||
|
||||
case 0xD0: // ENDIF
|
||||
|
|
@ -293,30 +342,30 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
break;
|
||||
|
||||
case 0xD6: // u32[b+offset] = datareg / offset += 4
|
||||
NDS.ARM7Write32(b + offset, datareg);
|
||||
BusWrite32(b + offset, datareg);
|
||||
offset += 4;
|
||||
break;
|
||||
|
||||
case 0xD7: // u16[b+offset] = datareg / offset += 2
|
||||
NDS.ARM7Write16(b + offset, datareg & 0xFFFF);
|
||||
BusWrite16(b + offset, datareg & 0xFFFF);
|
||||
offset += 2;
|
||||
break;
|
||||
|
||||
case 0xD8: // u8[b+offset] = datareg / offset += 1
|
||||
NDS.ARM7Write8(b + offset, datareg & 0xFF);
|
||||
BusWrite8(b + offset, datareg & 0xFF);
|
||||
offset += 1;
|
||||
break;
|
||||
|
||||
case 0xD9: // datareg = u32[b+offset]
|
||||
datareg = NDS.ARM7Read32(b + offset);
|
||||
datareg = BusRead32(b + offset);
|
||||
break;
|
||||
|
||||
case 0xDA: // datareg = u16[b+offset]
|
||||
datareg = NDS.ARM7Read16(b + offset);
|
||||
datareg = BusRead16(b + offset);
|
||||
break;
|
||||
|
||||
case 0xDB: // datareg = u8[b+offset]
|
||||
datareg = NDS.ARM7Read8(b + offset);
|
||||
datareg = BusRead8(b + offset);
|
||||
break;
|
||||
|
||||
case 0xDC: // offset += b
|
||||
|
|
@ -331,8 +380,8 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
u32 bytesleft = b;
|
||||
while (bytesleft >= 8)
|
||||
{
|
||||
NDS.ARM7Write32(dstaddr, *code++); dstaddr += 4;
|
||||
NDS.ARM7Write32(dstaddr, *code++); dstaddr += 4;
|
||||
BusWrite32(dstaddr, *code++); dstaddr += 4;
|
||||
BusWrite32(dstaddr, *code++); dstaddr += 4;
|
||||
bytesleft -= 8;
|
||||
}
|
||||
if (bytesleft > 0)
|
||||
|
|
@ -341,13 +390,13 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
code += 2;
|
||||
if (bytesleft >= 4)
|
||||
{
|
||||
NDS.ARM7Write32(dstaddr, *(u32*)leftover); dstaddr += 4;
|
||||
BusWrite32(dstaddr, *(u32*)leftover); dstaddr += 4;
|
||||
leftover += 4;
|
||||
bytesleft -= 4;
|
||||
}
|
||||
while (bytesleft > 0)
|
||||
{
|
||||
NDS.ARM7Write8(dstaddr, *leftover++); dstaddr++;
|
||||
BusWrite8(dstaddr, *leftover++); dstaddr++;
|
||||
bytesleft--;
|
||||
}
|
||||
}
|
||||
|
|
@ -363,14 +412,14 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
u32 bytesleft = b;
|
||||
while (bytesleft >= 4)
|
||||
{
|
||||
NDS.ARM7Write32(dstaddr, NDS.ARM7Read32(srcaddr));
|
||||
BusWrite32(dstaddr, BusRead32(srcaddr));
|
||||
srcaddr += 4;
|
||||
dstaddr += 4;
|
||||
bytesleft -= 4;
|
||||
}
|
||||
while (bytesleft > 0)
|
||||
{
|
||||
NDS.ARM7Write8(dstaddr, NDS.ARM7Read8(srcaddr));
|
||||
BusWrite8(dstaddr, BusRead8(srcaddr));
|
||||
srcaddr++;
|
||||
dstaddr++;
|
||||
bytesleft--;
|
||||
|
|
@ -379,20 +428,28 @@ void AREngine::RunCheat(const ARCode& arcode)
|
|||
break;
|
||||
|
||||
default:
|
||||
Log(LogLevel::Warn, "!! bad AR opcode %08X %08X\n", a, b);
|
||||
printf("!! bad AR opcode %08X %08X\n", a, b);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void AREngine::RunCheats()
|
||||
void RunCheats()
|
||||
{
|
||||
if (Cheats.empty()) return;
|
||||
if (!CodeFile) return;
|
||||
|
||||
for (const ARCode& code : Cheats)
|
||||
for (ARCodeCatList::iterator i = CodeFile->Categories.begin(); i != CodeFile->Categories.end(); i++)
|
||||
{
|
||||
if (code.Enabled)
|
||||
RunCheat(code);
|
||||
ARCodeCat& cat = *i;
|
||||
|
||||
for (ARCodeList::iterator j = cat.Codes.begin(); j != cat.Codes.end(); j++)
|
||||
{
|
||||
ARCode& code = *j;
|
||||
|
||||
if (code.Enabled)
|
||||
RunCheat(code);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,25 +19,20 @@
|
|||
#ifndef ARENGINE_H
|
||||
#define ARENGINE_H
|
||||
|
||||
#include <vector>
|
||||
#include "ARCodeFile.h"
|
||||
|
||||
namespace melonDS
|
||||
namespace AREngine
|
||||
{
|
||||
class NDS;
|
||||
class AREngine
|
||||
{
|
||||
public:
|
||||
AREngine(melonDS::NDS& nds);
|
||||
|
||||
std::vector<ARCode> Cheats {};
|
||||
private:
|
||||
friend class ARM;
|
||||
void RunCheats();
|
||||
void RunCheat(const ARCode& arcode);
|
||||
bool Init();
|
||||
void DeInit();
|
||||
void Reset();
|
||||
|
||||
melonDS::NDS& NDS;
|
||||
};
|
||||
ARCodeFile* GetCodeFile();
|
||||
void SetCodeFile(ARCodeFile* file);
|
||||
|
||||
void RunCheats();
|
||||
|
||||
}
|
||||
|
||||
#endif // ARENGINE_H
|
||||
|
|
|
|||
993
src/ARM.cpp
993
src/ARM.cpp
File diff suppressed because it is too large
Load Diff
325
src/ARM.h
325
src/ARM.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -20,18 +20,10 @@
|
|||
#define ARM_H
|
||||
|
||||
#include <algorithm>
|
||||
#include <optional>
|
||||
|
||||
#include "types.h"
|
||||
#include "MemRegion.h"
|
||||
#include "MemConstants.h"
|
||||
#include "NDS.h"
|
||||
|
||||
#ifdef GDBSTUB_ENABLED
|
||||
#include "debug/GdbStub.h"
|
||||
#endif
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
inline u32 ROR(u32 x, u32 n)
|
||||
{
|
||||
return (x >> (n&0x1F)) | (x << ((32-n)&0x1F));
|
||||
|
|
@ -43,33 +35,15 @@ enum
|
|||
RWFlags_ForceUser = (1<<21),
|
||||
};
|
||||
|
||||
enum class CPUExecuteMode : u32
|
||||
{
|
||||
Interpreter,
|
||||
InterpreterGDB,
|
||||
#ifdef JIT_ENABLED
|
||||
JIT
|
||||
#endif
|
||||
};
|
||||
|
||||
struct GDBArgs;
|
||||
class ARMJIT;
|
||||
class GPU;
|
||||
class ARMJIT_Memory;
|
||||
class NDS;
|
||||
class Savestate;
|
||||
const u32 ITCMPhysicalSize = 0x8000;
|
||||
const u32 DTCMPhysicalSize = 0x4000;
|
||||
|
||||
class ARM
|
||||
#ifdef GDBSTUB_ENABLED
|
||||
: public Gdb::StubCallbacks
|
||||
#endif
|
||||
{
|
||||
public:
|
||||
ARM(u32 num, bool jit, std::optional<GDBArgs> gdb, NDS& nds);
|
||||
ARM(u32 num);
|
||||
virtual ~ARM(); // destroy shit
|
||||
|
||||
void SetGdbArgs(std::optional<GDBArgs> gdb);
|
||||
|
||||
virtual void Reset();
|
||||
|
||||
virtual void DoSavestate(Savestate* file);
|
||||
|
|
@ -85,9 +59,12 @@ public:
|
|||
Halted = halt;
|
||||
}
|
||||
|
||||
void NocashPrint(u32 addr) noexcept;
|
||||
virtual void Execute() = 0;
|
||||
#ifdef JIT_ENABLED
|
||||
virtual void ExecuteJIT() = 0;
|
||||
#endif
|
||||
|
||||
bool CheckCondition(u32 code) const
|
||||
bool CheckCondition(u32 code)
|
||||
{
|
||||
if (code == 0xE) return true;
|
||||
if (ConditionTable[code] & (1 << (CPSR>>28))) return true;
|
||||
|
|
@ -116,18 +93,6 @@ public:
|
|||
if (v) CPSR |= 0x10000000;
|
||||
}
|
||||
|
||||
inline bool ModeIs(u32 mode) const
|
||||
{
|
||||
u32 cm = CPSR & 0x1f;
|
||||
mode &= 0x1f;
|
||||
|
||||
if (mode == cm) return true;
|
||||
if (mode == 0x17) return cm >= 0x14 && cm <= 0x17; // abt
|
||||
if (mode == 0x1b) return cm >= 0x18 && cm <= 0x1b; // und
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
void UpdateMode(u32 oldmode, u32 newmode, bool phony = false);
|
||||
|
||||
void TriggerIRQ();
|
||||
|
|
@ -149,7 +114,6 @@ public:
|
|||
virtual void AddCycles_CDI() = 0;
|
||||
virtual void AddCycles_CD() = 0;
|
||||
|
||||
void CheckGdbIncoming();
|
||||
|
||||
u32 Num;
|
||||
|
||||
|
|
@ -183,101 +147,75 @@ public:
|
|||
|
||||
u32 ExceptionBase;
|
||||
|
||||
MemRegion CodeMem;
|
||||
NDS::MemRegion CodeMem;
|
||||
|
||||
#ifdef JIT_ENABLED
|
||||
u32 FastBlockLookupStart, FastBlockLookupSize;
|
||||
u64* FastBlockLookup;
|
||||
#endif
|
||||
|
||||
static const u32 ConditionTable[16];
|
||||
#ifdef GDBSTUB_ENABLED
|
||||
Gdb::GdbStub GdbStub;
|
||||
#endif
|
||||
|
||||
melonDS::NDS& NDS;
|
||||
protected:
|
||||
virtual u8 BusRead8(u32 addr) = 0;
|
||||
virtual u16 BusRead16(u32 addr) = 0;
|
||||
virtual u32 BusRead32(u32 addr) = 0;
|
||||
virtual void BusWrite8(u32 addr, u8 val) = 0;
|
||||
virtual void BusWrite16(u32 addr, u16 val) = 0;
|
||||
virtual void BusWrite32(u32 addr, u32 val) = 0;
|
||||
|
||||
#ifdef GDBSTUB_ENABLED
|
||||
bool IsSingleStep;
|
||||
bool BreakReq;
|
||||
bool BreakOnStartup;
|
||||
u16 Port;
|
||||
|
||||
public:
|
||||
int GetCPU() const override { return Num ? 7 : 9; }
|
||||
|
||||
u32 ReadReg(Gdb::Register reg) override;
|
||||
void WriteReg(Gdb::Register reg, u32 v) override;
|
||||
u32 ReadMem(u32 addr, int size) override;
|
||||
void WriteMem(u32 addr, int size, u32 v) override;
|
||||
|
||||
void ResetGdb() override;
|
||||
int RemoteCmd(const u8* cmd, size_t len) override;
|
||||
static u32 ConditionTable[16];
|
||||
|
||||
protected:
|
||||
#endif
|
||||
|
||||
void GdbCheckA();
|
||||
void GdbCheckB();
|
||||
void GdbCheckC();
|
||||
u8 (*BusRead8)(u32 addr);
|
||||
u16 (*BusRead16)(u32 addr);
|
||||
u32 (*BusRead32)(u32 addr);
|
||||
void (*BusWrite8)(u32 addr, u8 val);
|
||||
void (*BusWrite16)(u32 addr, u16 val);
|
||||
void (*BusWrite32)(u32 addr, u32 val);
|
||||
};
|
||||
|
||||
class ARMv5 : public ARM
|
||||
{
|
||||
public:
|
||||
ARMv5(melonDS::NDS& nds, std::optional<GDBArgs> gdb, bool jit);
|
||||
ARMv5();
|
||||
~ARMv5();
|
||||
|
||||
void Reset() override;
|
||||
void Reset();
|
||||
|
||||
void DoSavestate(Savestate* file) override;
|
||||
void DoSavestate(Savestate* file);
|
||||
|
||||
void UpdateRegionTimings(u32 addrstart, u32 addrend);
|
||||
|
||||
void FillPipeline() override;
|
||||
void FillPipeline();
|
||||
|
||||
void JumpTo(u32 addr, bool restorecpsr = false) override;
|
||||
void JumpTo(u32 addr, bool restorecpsr = false);
|
||||
|
||||
void PrefetchAbort();
|
||||
void DataAbort();
|
||||
|
||||
template <CPUExecuteMode mode>
|
||||
void Execute();
|
||||
#ifdef JIT_ENABLED
|
||||
void ExecuteJIT();
|
||||
#endif
|
||||
|
||||
// all code accesses are forced nonseq 32bit
|
||||
u32 CodeRead32(u32 addr, bool branch);
|
||||
|
||||
void DataRead8(u32 addr, u32* val) override;
|
||||
void DataRead16(u32 addr, u32* val) override;
|
||||
void DataRead32(u32 addr, u32* val) override;
|
||||
void DataRead32S(u32 addr, u32* val) override;
|
||||
void DataWrite8(u32 addr, u8 val) override;
|
||||
void DataWrite16(u32 addr, u16 val) override;
|
||||
void DataWrite32(u32 addr, u32 val) override;
|
||||
void DataWrite32S(u32 addr, u32 val) override;
|
||||
void DataRead8(u32 addr, u32* val);
|
||||
void DataRead16(u32 addr, u32* val);
|
||||
void DataRead32(u32 addr, u32* val);
|
||||
void DataRead32S(u32 addr, u32* val);
|
||||
void DataWrite8(u32 addr, u8 val);
|
||||
void DataWrite16(u32 addr, u16 val);
|
||||
void DataWrite32(u32 addr, u32 val);
|
||||
void DataWrite32S(u32 addr, u32 val);
|
||||
|
||||
void AddCycles_C() override
|
||||
void AddCycles_C()
|
||||
{
|
||||
// code only. always nonseq 32-bit for ARM9.
|
||||
s32 numC = (R[15] & 0x2) ? 0 : CodeCycles;
|
||||
Cycles += numC;
|
||||
}
|
||||
|
||||
void AddCycles_CI(s32 numI) override
|
||||
void AddCycles_CI(s32 numI)
|
||||
{
|
||||
// code+internal
|
||||
s32 numC = (R[15] & 0x2) ? 0 : CodeCycles;
|
||||
Cycles += numC + numI;
|
||||
}
|
||||
|
||||
void AddCycles_CDI() override
|
||||
void AddCycles_CDI()
|
||||
{
|
||||
// LDR/LDM cycles. ARM9 seems to skip the internal cycle there.
|
||||
// TODO: ITCM data fetches shouldn't be parallelized, they say
|
||||
|
|
@ -290,7 +228,7 @@ public:
|
|||
// Cycles += numC + numD;
|
||||
}
|
||||
|
||||
void AddCycles_CD() override
|
||||
void AddCycles_CD()
|
||||
{
|
||||
// TODO: ITCM data fetches shouldn't be parallelized, they say
|
||||
s32 numC = (R[15] & 0x2) ? 0 : CodeCycles;
|
||||
|
|
@ -302,7 +240,7 @@ public:
|
|||
// Cycles += numC + numD;
|
||||
}
|
||||
|
||||
void GetCodeMemRegion(u32 addr, MemRegion* region);
|
||||
void GetCodeMemRegion(u32 addr, NDS::MemRegion* region);
|
||||
|
||||
void CP15Reset();
|
||||
void CP15DoSavestate(Savestate* file);
|
||||
|
|
@ -320,12 +258,11 @@ public:
|
|||
void ICacheInvalidateAll();
|
||||
|
||||
void CP15Write(u32 id, u32 val);
|
||||
u32 CP15Read(u32 id) const;
|
||||
u32 CP15Read(u32 id);
|
||||
|
||||
u32 CP15Control;
|
||||
|
||||
u32 RNGSeed;
|
||||
u32 TraceProcessID;
|
||||
|
||||
u32 DTCMSetting, ITCMSetting;
|
||||
|
||||
|
|
@ -364,33 +301,24 @@ public:
|
|||
|
||||
u8* CurICacheLine;
|
||||
|
||||
bool (*GetMemRegion)(u32 addr, bool write, MemRegion* region);
|
||||
|
||||
#ifdef GDBSTUB_ENABLED
|
||||
u32 ReadMem(u32 addr, int size) override;
|
||||
void WriteMem(u32 addr, int size, u32 v) override;
|
||||
#endif
|
||||
|
||||
protected:
|
||||
u8 BusRead8(u32 addr) override;
|
||||
u16 BusRead16(u32 addr) override;
|
||||
u32 BusRead32(u32 addr) override;
|
||||
void BusWrite8(u32 addr, u8 val) override;
|
||||
void BusWrite16(u32 addr, u16 val) override;
|
||||
void BusWrite32(u32 addr, u32 val) override;
|
||||
bool (*GetMemRegion)(u32 addr, bool write, NDS::MemRegion* region);
|
||||
};
|
||||
|
||||
class ARMv4 : public ARM
|
||||
{
|
||||
public:
|
||||
ARMv4(melonDS::NDS& nds, std::optional<GDBArgs> gdb, bool jit);
|
||||
ARMv4();
|
||||
|
||||
void FillPipeline() override;
|
||||
void Reset();
|
||||
|
||||
void JumpTo(u32 addr, bool restorecpsr = false) override;
|
||||
void FillPipeline();
|
||||
|
||||
void JumpTo(u32 addr, bool restorecpsr = false);
|
||||
|
||||
template <CPUExecuteMode mode>
|
||||
void Execute();
|
||||
#ifdef JIT_ENABLED
|
||||
void ExecuteJIT();
|
||||
#endif
|
||||
|
||||
u16 CodeRead16(u32 addr)
|
||||
{
|
||||
|
|
@ -402,25 +330,134 @@ public:
|
|||
return BusRead32(addr);
|
||||
}
|
||||
|
||||
void DataRead8(u32 addr, u32* val) override;
|
||||
void DataRead16(u32 addr, u32* val) override;
|
||||
void DataRead32(u32 addr, u32* val) override;
|
||||
void DataRead32S(u32 addr, u32* val) override;
|
||||
void DataWrite8(u32 addr, u8 val) override;
|
||||
void DataWrite16(u32 addr, u16 val) override;
|
||||
void DataWrite32(u32 addr, u32 val) override;
|
||||
void DataWrite32S(u32 addr, u32 val) override;
|
||||
void AddCycles_C() override;
|
||||
void AddCycles_CI(s32 num) override;
|
||||
void AddCycles_CDI() override;
|
||||
void AddCycles_CD() override;
|
||||
protected:
|
||||
u8 BusRead8(u32 addr) override;
|
||||
u16 BusRead16(u32 addr) override;
|
||||
u32 BusRead32(u32 addr) override;
|
||||
void BusWrite8(u32 addr, u8 val) override;
|
||||
void BusWrite16(u32 addr, u16 val) override;
|
||||
void BusWrite32(u32 addr, u32 val) override;
|
||||
void DataRead8(u32 addr, u32* val)
|
||||
{
|
||||
*val = BusRead8(addr);
|
||||
DataRegion = addr;
|
||||
DataCycles = NDS::ARM7MemTimings[addr >> 15][0];
|
||||
}
|
||||
|
||||
void DataRead16(u32 addr, u32* val)
|
||||
{
|
||||
addr &= ~1;
|
||||
|
||||
*val = BusRead16(addr);
|
||||
DataRegion = addr;
|
||||
DataCycles = NDS::ARM7MemTimings[addr >> 15][0];
|
||||
}
|
||||
|
||||
void DataRead32(u32 addr, u32* val)
|
||||
{
|
||||
addr &= ~3;
|
||||
|
||||
*val = BusRead32(addr);
|
||||
DataRegion = addr;
|
||||
DataCycles = NDS::ARM7MemTimings[addr >> 15][2];
|
||||
}
|
||||
|
||||
void DataRead32S(u32 addr, u32* val)
|
||||
{
|
||||
addr &= ~3;
|
||||
|
||||
*val = BusRead32(addr);
|
||||
DataCycles += NDS::ARM7MemTimings[addr >> 15][3];
|
||||
}
|
||||
|
||||
void DataWrite8(u32 addr, u8 val)
|
||||
{
|
||||
BusWrite8(addr, val);
|
||||
DataRegion = addr;
|
||||
DataCycles = NDS::ARM7MemTimings[addr >> 15][0];
|
||||
}
|
||||
|
||||
void DataWrite16(u32 addr, u16 val)
|
||||
{
|
||||
addr &= ~1;
|
||||
|
||||
BusWrite16(addr, val);
|
||||
DataRegion = addr;
|
||||
DataCycles = NDS::ARM7MemTimings[addr >> 15][0];
|
||||
}
|
||||
|
||||
void DataWrite32(u32 addr, u32 val)
|
||||
{
|
||||
addr &= ~3;
|
||||
|
||||
BusWrite32(addr, val);
|
||||
DataRegion = addr;
|
||||
DataCycles = NDS::ARM7MemTimings[addr >> 15][2];
|
||||
}
|
||||
|
||||
void DataWrite32S(u32 addr, u32 val)
|
||||
{
|
||||
addr &= ~3;
|
||||
|
||||
BusWrite32(addr, val);
|
||||
DataCycles += NDS::ARM7MemTimings[addr >> 15][3];
|
||||
}
|
||||
|
||||
|
||||
void AddCycles_C()
|
||||
{
|
||||
// code only. this code fetch is sequential.
|
||||
Cycles += NDS::ARM7MemTimings[CodeCycles][(CPSR&0x20)?1:3];
|
||||
}
|
||||
|
||||
void AddCycles_CI(s32 num)
|
||||
{
|
||||
// code+internal. results in a nonseq code fetch.
|
||||
Cycles += NDS::ARM7MemTimings[CodeCycles][(CPSR&0x20)?0:2] + num;
|
||||
}
|
||||
|
||||
void AddCycles_CDI()
|
||||
{
|
||||
// LDR/LDM cycles.
|
||||
s32 numC = NDS::ARM7MemTimings[CodeCycles][(CPSR&0x20)?0:2];
|
||||
s32 numD = DataCycles;
|
||||
|
||||
if ((DataRegion >> 24) == 0x02) // mainRAM
|
||||
{
|
||||
if (CodeRegion == 0x02)
|
||||
Cycles += numC + numD;
|
||||
else
|
||||
{
|
||||
numC++;
|
||||
Cycles += std::max(numC + numD - 3, std::max(numC, numD));
|
||||
}
|
||||
}
|
||||
else if (CodeRegion == 0x02)
|
||||
{
|
||||
numD++;
|
||||
Cycles += std::max(numC + numD - 3, std::max(numC, numD));
|
||||
}
|
||||
else
|
||||
{
|
||||
Cycles += numC + numD + 1;
|
||||
}
|
||||
}
|
||||
|
||||
void AddCycles_CD()
|
||||
{
|
||||
// TODO: max gain should be 5c when writing to mainRAM
|
||||
s32 numC = NDS::ARM7MemTimings[CodeCycles][(CPSR&0x20)?0:2];
|
||||
s32 numD = DataCycles;
|
||||
|
||||
if ((DataRegion >> 24) == 0x02)
|
||||
{
|
||||
if (CodeRegion == 0x02)
|
||||
Cycles += numC + numD;
|
||||
else
|
||||
Cycles += std::max(numC + numD - 3, std::max(numC, numD));
|
||||
}
|
||||
else if (CodeRegion == 0x02)
|
||||
{
|
||||
Cycles += std::max(numC + numD - 3, std::max(numC, numD));
|
||||
}
|
||||
else
|
||||
{
|
||||
Cycles += numC + numD;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
namespace ARMInterpreter
|
||||
|
|
@ -430,5 +467,13 @@ void A_UNK(ARM* cpu);
|
|||
void T_UNK(ARM* cpu);
|
||||
|
||||
}
|
||||
|
||||
namespace NDS
|
||||
{
|
||||
|
||||
extern ARMv5* ARM9;
|
||||
extern ARMv4* ARM7;
|
||||
|
||||
}
|
||||
|
||||
#endif // ARM_H
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -22,24 +22,15 @@
|
|||
#include "ARMInterpreter_ALU.h"
|
||||
#include "ARMInterpreter_Branch.h"
|
||||
#include "ARMInterpreter_LoadStore.h"
|
||||
#include "Platform.h"
|
||||
|
||||
#ifdef GDBSTUB_ENABLED
|
||||
#include "debug/GdbStub.h"
|
||||
#endif
|
||||
|
||||
namespace melonDS::ARMInterpreter
|
||||
namespace ARMInterpreter
|
||||
{
|
||||
using Platform::Log;
|
||||
using Platform::LogLevel;
|
||||
|
||||
|
||||
void A_UNK(ARM* cpu)
|
||||
{
|
||||
Log(LogLevel::Warn, "undefined ARM%d instruction %08X @ %08X\n", cpu->Num?7:9, cpu->CurInstr, cpu->R[15]-8);
|
||||
#ifdef GDBSTUB_ENABLED
|
||||
cpu->GdbStub.Enter(cpu->GdbStub.IsConnected(), Gdb::TgtStatus::FaultInsn, cpu->R[15]-8);
|
||||
#endif
|
||||
printf("undefined ARM%d instruction %08X @ %08X\n", cpu->Num?7:9, cpu->CurInstr, cpu->R[15]-8);
|
||||
//for (int i = 0; i < 16; i++) printf("R%d: %08X\n", i, cpu->R[i]);
|
||||
//NDS::Halt();
|
||||
u32 oldcpsr = cpu->CPSR;
|
||||
|
|
@ -54,10 +45,7 @@ void A_UNK(ARM* cpu)
|
|||
|
||||
void T_UNK(ARM* cpu)
|
||||
{
|
||||
Log(LogLevel::Warn, "undefined THUMB%d instruction %04X @ %08X\n", cpu->Num?7:9, cpu->CurInstr, cpu->R[15]-4);
|
||||
#ifdef GDBSTUB_ENABLED
|
||||
cpu->GdbStub.Enter(cpu->GdbStub.IsConnected(), Gdb::TgtStatus::FaultInsn, cpu->R[15]-4);
|
||||
#endif
|
||||
printf("undefined THUMB%d instruction %04X @ %08X\n", cpu->Num?7:9, cpu->CurInstr, cpu->R[15]-4);
|
||||
//NDS::Halt();
|
||||
u32 oldcpsr = cpu->CPSR;
|
||||
cpu->CPSR &= ~0xBF;
|
||||
|
|
@ -223,11 +211,11 @@ void A_MCR(ARM* cpu)
|
|||
}
|
||||
else if (cpu->Num==1 && cp==14)
|
||||
{
|
||||
Log(LogLevel::Debug, "MCR p14,%d,%d,%d on ARM7\n", cn, cm, cpinfo);
|
||||
printf("MCR p14,%d,%d,%d on ARM7\n", cn, cm, cpinfo);
|
||||
}
|
||||
else
|
||||
{
|
||||
Log(LogLevel::Warn, "bad MCR opcode p%d,%d,%d,%d on ARM%d\n", cp, cn, cm, cpinfo, cpu->Num?7:9);
|
||||
printf("bad MCR opcode p%d,%d,%d,%d on ARM%d\n", cp, cn, cm, cpinfo, cpu->Num?7:9);
|
||||
return A_UNK(cpu); // TODO: check what kind of exception it really is
|
||||
}
|
||||
|
||||
|
|
@ -251,11 +239,11 @@ void A_MRC(ARM* cpu)
|
|||
}
|
||||
else if (cpu->Num==1 && cp==14)
|
||||
{
|
||||
Log(LogLevel::Debug, "MRC p14,%d,%d,%d on ARM7\n", cn, cm, cpinfo);
|
||||
printf("MRC p14,%d,%d,%d on ARM7\n", cn, cm, cpinfo);
|
||||
}
|
||||
else
|
||||
{
|
||||
Log(LogLevel::Warn, "bad MRC opcode p%d,%d,%d,%d on ARM%d\n", cp, cn, cm, cpinfo, cpu->Num?7:9);
|
||||
printf("bad MRC opcode p%d,%d,%d,%d on ARM%d\n", cp, cn, cm, cpinfo, cpu->Num?7:9);
|
||||
return A_UNK(cpu); // TODO: check what kind of exception it really is
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -22,8 +22,6 @@
|
|||
#include "types.h"
|
||||
#include "ARM.h"
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
namespace ARMInterpreter
|
||||
{
|
||||
|
||||
|
|
@ -43,5 +41,4 @@ void A_BLX_IMM(ARM* cpu); // I'm a special one look at me
|
|||
|
||||
}
|
||||
|
||||
}
|
||||
#endif // ARMINTERPRETER_H
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -18,46 +18,18 @@
|
|||
|
||||
#include <stdio.h>
|
||||
#include "ARM.h"
|
||||
#include "NDS.h"
|
||||
|
||||
namespace melonDS::ARMInterpreter
|
||||
|
||||
#define CARRY_ADD(a, b) ((0xFFFFFFFF-a) < b)
|
||||
#define CARRY_SUB(a, b) (a >= b)
|
||||
|
||||
#define OVERFLOW_ADD(a, b, res) ((!(((a) ^ (b)) & 0x80000000)) && (((a) ^ (res)) & 0x80000000))
|
||||
#define OVERFLOW_SUB(a, b, res) ((((a) ^ (b)) & 0x80000000) && (((a) ^ (res)) & 0x80000000))
|
||||
|
||||
|
||||
namespace ARMInterpreter
|
||||
{
|
||||
|
||||
inline bool CarryAdd(u32 a, u32 b)
|
||||
{
|
||||
return (0xFFFFFFFF-a) < b;
|
||||
}
|
||||
|
||||
inline bool CarrySub(u32 a, u32 b)
|
||||
{
|
||||
return a >= b;
|
||||
}
|
||||
|
||||
inline bool OverflowAdd(u32 a, u32 b)
|
||||
{
|
||||
u32 res = a + b;
|
||||
return (!((a ^ b) & 0x80000000)) && ((a ^ res) & 0x80000000);
|
||||
}
|
||||
|
||||
inline bool OverflowSub(u32 a, u32 b)
|
||||
{
|
||||
u32 res = a - b;
|
||||
return ((a ^ b) & 0x80000000) && ((a ^ res) & 0x80000000);
|
||||
}
|
||||
|
||||
inline bool OverflowAdc(u32 a, u32 b, u32 carry)
|
||||
{
|
||||
s64 fullResult = (s64)(s32)a + (s32)b + carry;
|
||||
u32 res = a + b + carry;
|
||||
return (s32)res != fullResult;
|
||||
}
|
||||
|
||||
inline bool OverflowSbc(u32 a, u32 b, u32 carry)
|
||||
{
|
||||
s64 fullResult = (s64)(s32)a - (s32)b - carry;
|
||||
u32 res = a - b - carry;
|
||||
return (s32)res != fullResult;
|
||||
}
|
||||
|
||||
#define LSL_IMM(x, s) \
|
||||
x <<= s;
|
||||
|
|
@ -392,8 +364,8 @@ A_IMPLEMENT_ALU_OP(EOR,_S)
|
|||
u32 res = a - b; \
|
||||
cpu->SetNZCV(res & 0x80000000, \
|
||||
!res, \
|
||||
CarrySub(a, b), \
|
||||
OverflowSub(a, b)); \
|
||||
CARRY_SUB(a, b), \
|
||||
OVERFLOW_SUB(a, b, res)); \
|
||||
if (c) cpu->AddCycles_CI(c); else cpu->AddCycles_C(); \
|
||||
if (((cpu->CurInstr>>12) & 0xF) == 15) \
|
||||
{ \
|
||||
|
|
@ -425,8 +397,8 @@ A_IMPLEMENT_ALU_OP(SUB,)
|
|||
u32 res = b - a; \
|
||||
cpu->SetNZCV(res & 0x80000000, \
|
||||
!res, \
|
||||
CarrySub(b, a), \
|
||||
OverflowSub(b, a)); \
|
||||
CARRY_SUB(b, a), \
|
||||
OVERFLOW_SUB(b, a, res)); \
|
||||
if (c) cpu->AddCycles_CI(c); else cpu->AddCycles_C(); \
|
||||
if (((cpu->CurInstr>>12) & 0xF) == 15) \
|
||||
{ \
|
||||
|
|
@ -458,8 +430,8 @@ A_IMPLEMENT_ALU_OP(RSB,)
|
|||
u32 res = a + b; \
|
||||
cpu->SetNZCV(res & 0x80000000, \
|
||||
!res, \
|
||||
CarryAdd(a, b), \
|
||||
OverflowAdd(a, b)); \
|
||||
CARRY_ADD(a, b), \
|
||||
OVERFLOW_ADD(a, b, res)); \
|
||||
if (c) cpu->AddCycles_CI(c); else cpu->AddCycles_C(); \
|
||||
if (((cpu->CurInstr>>12) & 0xF) == 15) \
|
||||
{ \
|
||||
|
|
@ -493,8 +465,8 @@ A_IMPLEMENT_ALU_OP(ADD,)
|
|||
u32 res = res_tmp + carry; \
|
||||
cpu->SetNZCV(res & 0x80000000, \
|
||||
!res, \
|
||||
CarryAdd(a, b) | CarryAdd(res_tmp, carry), \
|
||||
OverflowAdc(a, b, carry)); \
|
||||
CARRY_ADD(a, b) | CARRY_ADD(res_tmp, carry), \
|
||||
OVERFLOW_ADD(a, b, res_tmp) | OVERFLOW_ADD(res_tmp, carry, res)); \
|
||||
if (c) cpu->AddCycles_CI(c); else cpu->AddCycles_C(); \
|
||||
if (((cpu->CurInstr>>12) & 0xF) == 15) \
|
||||
{ \
|
||||
|
|
@ -528,8 +500,8 @@ A_IMPLEMENT_ALU_OP(ADC,)
|
|||
u32 res = res_tmp - carry; \
|
||||
cpu->SetNZCV(res & 0x80000000, \
|
||||
!res, \
|
||||
CarrySub(a, b) & CarrySub(res_tmp, carry), \
|
||||
OverflowSbc(a, b, carry)); \
|
||||
CARRY_SUB(a, b) & CARRY_SUB(res_tmp, carry), \
|
||||
OVERFLOW_SUB(a, b, res_tmp) | OVERFLOW_SUB(res_tmp, carry, res)); \
|
||||
if (c) cpu->AddCycles_CI(c); else cpu->AddCycles_C(); \
|
||||
if (((cpu->CurInstr>>12) & 0xF) == 15) \
|
||||
{ \
|
||||
|
|
@ -563,8 +535,8 @@ A_IMPLEMENT_ALU_OP(SBC,)
|
|||
u32 res = res_tmp - carry; \
|
||||
cpu->SetNZCV(res & 0x80000000, \
|
||||
!res, \
|
||||
CarrySub(b, a) & CarrySub(res_tmp, carry), \
|
||||
OverflowSbc(b, a, carry)); \
|
||||
CARRY_SUB(b, a) & CARRY_SUB(res_tmp, carry), \
|
||||
OVERFLOW_SUB(b, a, res_tmp) | OVERFLOW_SUB(res_tmp, carry, res)); \
|
||||
if (c) cpu->AddCycles_CI(c); else cpu->AddCycles_C(); \
|
||||
if (((cpu->CurInstr>>12) & 0xF) == 15) \
|
||||
{ \
|
||||
|
|
@ -603,8 +575,8 @@ A_IMPLEMENT_ALU_TEST(TEQ,_S)
|
|||
u32 res = a - b; \
|
||||
cpu->SetNZCV(res & 0x80000000, \
|
||||
!res, \
|
||||
CarrySub(a, b), \
|
||||
OverflowSub(a, b)); \
|
||||
CARRY_SUB(a, b), \
|
||||
OVERFLOW_SUB(a, b, res)); \
|
||||
if (c) cpu->AddCycles_CI(c); else cpu->AddCycles_C();
|
||||
|
||||
A_IMPLEMENT_ALU_TEST(CMP,)
|
||||
|
|
@ -615,8 +587,8 @@ A_IMPLEMENT_ALU_TEST(CMP,)
|
|||
u32 res = a + b; \
|
||||
cpu->SetNZCV(res & 0x80000000, \
|
||||
!res, \
|
||||
CarryAdd(a, b), \
|
||||
OverflowAdd(a, b)); \
|
||||
CARRY_ADD(a, b), \
|
||||
OVERFLOW_ADD(a, b, res)); \
|
||||
if (c) cpu->AddCycles_CI(c); else cpu->AddCycles_C();
|
||||
|
||||
A_IMPLEMENT_ALU_TEST(CMN,)
|
||||
|
|
@ -693,7 +665,7 @@ void A_MOV_REG_LSL_IMM_DBG(ARM* cpu)
|
|||
// but since they serve no purpose ATTOW, we can skip them
|
||||
u32 addr = cpu->R[15] + 4; // Skip 2nd ID and flags
|
||||
// TODO: Pass flags to NocashPrint
|
||||
cpu->NDS.NocashPrint(cpu->Num, addr);
|
||||
NDS::NocashPrint(cpu->Num, addr);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -961,7 +933,7 @@ void A_SMLAxy(ARM* cpu)
|
|||
u32 res = res_mul + rn;
|
||||
|
||||
cpu->R[(cpu->CurInstr >> 16) & 0xF] = res;
|
||||
if (OverflowAdd(res_mul, rn))
|
||||
if (OVERFLOW_ADD(res_mul, rn, res))
|
||||
cpu->CPSR |= 0x08000000;
|
||||
|
||||
cpu->AddCycles_C(); // TODO: interlock??
|
||||
|
|
@ -982,7 +954,7 @@ void A_SMLAWy(ARM* cpu)
|
|||
u32 res = res_mul + rn;
|
||||
|
||||
cpu->R[(cpu->CurInstr >> 16) & 0xF] = res;
|
||||
if (OverflowAdd(res_mul, rn))
|
||||
if (OVERFLOW_ADD(res_mul, rn, res))
|
||||
cpu->CPSR |= 0x08000000;
|
||||
|
||||
cpu->AddCycles_C(); // TODO: interlock??
|
||||
|
|
@ -1079,7 +1051,7 @@ void A_QADD(ARM* cpu)
|
|||
u32 rn = cpu->R[(cpu->CurInstr >> 16) & 0xF];
|
||||
|
||||
u32 res = rm + rn;
|
||||
if (OverflowAdd(rm, rn))
|
||||
if (OVERFLOW_ADD(rm, rn, res))
|
||||
{
|
||||
res = (res & 0x80000000) ? 0x7FFFFFFF : 0x80000000;
|
||||
cpu->CPSR |= 0x08000000;
|
||||
|
|
@ -1097,7 +1069,7 @@ void A_QSUB(ARM* cpu)
|
|||
u32 rn = cpu->R[(cpu->CurInstr >> 16) & 0xF];
|
||||
|
||||
u32 res = rm - rn;
|
||||
if (OverflowSub(rm, rn))
|
||||
if (OVERFLOW_SUB(rm, rn, res))
|
||||
{
|
||||
res = (res & 0x80000000) ? 0x7FFFFFFF : 0x80000000;
|
||||
cpu->CPSR |= 0x08000000;
|
||||
|
|
@ -1114,7 +1086,7 @@ void A_QDADD(ARM* cpu)
|
|||
u32 rm = cpu->R[cpu->CurInstr & 0xF];
|
||||
u32 rn = cpu->R[(cpu->CurInstr >> 16) & 0xF];
|
||||
|
||||
if (OverflowAdd(rn, rn))
|
||||
if (OVERFLOW_ADD(rn, rn, rn<<1))
|
||||
{
|
||||
rn = (rn & 0x80000000) ? 0x80000000 : 0x7FFFFFFF;
|
||||
cpu->CPSR |= 0x08000000; // CHECKME
|
||||
|
|
@ -1123,7 +1095,7 @@ void A_QDADD(ARM* cpu)
|
|||
rn <<= 1;
|
||||
|
||||
u32 res = rm + rn;
|
||||
if (OverflowAdd(rm, rn))
|
||||
if (OVERFLOW_ADD(rm, rn, res))
|
||||
{
|
||||
res = (res & 0x80000000) ? 0x7FFFFFFF : 0x80000000;
|
||||
cpu->CPSR |= 0x08000000;
|
||||
|
|
@ -1140,7 +1112,7 @@ void A_QDSUB(ARM* cpu)
|
|||
u32 rm = cpu->R[cpu->CurInstr & 0xF];
|
||||
u32 rn = cpu->R[(cpu->CurInstr >> 16) & 0xF];
|
||||
|
||||
if (OverflowAdd(rn, rn))
|
||||
if (OVERFLOW_ADD(rn, rn, rn<<1))
|
||||
{
|
||||
rn = (rn & 0x80000000) ? 0x80000000 : 0x7FFFFFFF;
|
||||
cpu->CPSR |= 0x08000000; // CHECKME
|
||||
|
|
@ -1149,7 +1121,7 @@ void A_QDSUB(ARM* cpu)
|
|||
rn <<= 1;
|
||||
|
||||
u32 res = rm - rn;
|
||||
if (OverflowSub(rm, rn))
|
||||
if (OVERFLOW_SUB(rm, rn, res))
|
||||
{
|
||||
res = (res & 0x80000000) ? 0x7FFFFFFF : 0x80000000;
|
||||
cpu->CPSR |= 0x08000000;
|
||||
|
|
@ -1206,8 +1178,8 @@ void T_ADD_REG_(ARM* cpu)
|
|||
cpu->R[cpu->CurInstr & 0x7] = res;
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarryAdd(a, b),
|
||||
OverflowAdd(a, b));
|
||||
CARRY_ADD(a, b),
|
||||
OVERFLOW_ADD(a, b, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1219,8 +1191,8 @@ void T_SUB_REG_(ARM* cpu)
|
|||
cpu->R[cpu->CurInstr & 0x7] = res;
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarrySub(a, b),
|
||||
OverflowSub(a, b));
|
||||
CARRY_SUB(a, b),
|
||||
OVERFLOW_SUB(a, b, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1232,8 +1204,8 @@ void T_ADD_IMM_(ARM* cpu)
|
|||
cpu->R[cpu->CurInstr & 0x7] = res;
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarryAdd(a, b),
|
||||
OverflowAdd(a, b));
|
||||
CARRY_ADD(a, b),
|
||||
OVERFLOW_ADD(a, b, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1245,8 +1217,8 @@ void T_SUB_IMM_(ARM* cpu)
|
|||
cpu->R[cpu->CurInstr & 0x7] = res;
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarrySub(a, b),
|
||||
OverflowSub(a, b));
|
||||
CARRY_SUB(a, b),
|
||||
OVERFLOW_SUB(a, b, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1266,8 +1238,8 @@ void T_CMP_IMM(ARM* cpu)
|
|||
u32 res = a - b;
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarrySub(a, b),
|
||||
OverflowSub(a, b));
|
||||
CARRY_SUB(a, b),
|
||||
OVERFLOW_SUB(a, b, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1279,8 +1251,8 @@ void T_ADD_IMM(ARM* cpu)
|
|||
cpu->R[(cpu->CurInstr >> 8) & 0x7] = res;
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarryAdd(a, b),
|
||||
OverflowAdd(a, b));
|
||||
CARRY_ADD(a, b),
|
||||
OVERFLOW_ADD(a, b, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1292,8 +1264,8 @@ void T_SUB_IMM(ARM* cpu)
|
|||
cpu->R[(cpu->CurInstr >> 8) & 0x7] = res;
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarrySub(a, b),
|
||||
OverflowSub(a, b));
|
||||
CARRY_SUB(a, b),
|
||||
OVERFLOW_SUB(a, b, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1363,8 +1335,8 @@ void T_ADC_REG(ARM* cpu)
|
|||
cpu->R[cpu->CurInstr & 0x7] = res;
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarryAdd(a, b) | CarryAdd(res_tmp, carry),
|
||||
OverflowAdc(a, b, carry));
|
||||
CARRY_ADD(a, b) | CARRY_ADD(res_tmp, carry),
|
||||
OVERFLOW_ADD(a, b, res_tmp) | OVERFLOW_ADD(res_tmp, carry, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1378,8 +1350,8 @@ void T_SBC_REG(ARM* cpu)
|
|||
cpu->R[cpu->CurInstr & 0x7] = res;
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarrySub(a, b) & CarrySub(res_tmp, carry),
|
||||
OverflowSbc(a, b, carry));
|
||||
CARRY_SUB(a, b) & CARRY_SUB(res_tmp, carry),
|
||||
OVERFLOW_SUB(a, b, res_tmp) | OVERFLOW_SUB(res_tmp, carry, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1411,8 +1383,8 @@ void T_NEG_REG(ARM* cpu)
|
|||
cpu->R[cpu->CurInstr & 0x7] = res;
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarrySub(0, b),
|
||||
OverflowSub(0, b));
|
||||
CARRY_SUB(0, b),
|
||||
OVERFLOW_SUB(0, b, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1423,8 +1395,8 @@ void T_CMP_REG(ARM* cpu)
|
|||
u32 res = a - b;
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarrySub(a, b),
|
||||
OverflowSub(a, b));
|
||||
CARRY_SUB(a, b),
|
||||
OVERFLOW_SUB(a, b, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1435,8 +1407,8 @@ void T_CMN_REG(ARM* cpu)
|
|||
u32 res = a + b;
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarryAdd(a, b),
|
||||
OverflowAdd(a, b));
|
||||
CARRY_ADD(a, b),
|
||||
OVERFLOW_ADD(a, b, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1532,8 +1504,8 @@ void T_CMP_HIREG(ARM* cpu)
|
|||
|
||||
cpu->SetNZCV(res & 0x80000000,
|
||||
!res,
|
||||
CarrySub(a, b),
|
||||
OverflowSub(a, b));
|
||||
CARRY_SUB(a, b),
|
||||
OVERFLOW_SUB(a, b, res));
|
||||
cpu->AddCycles_C();
|
||||
}
|
||||
|
||||
|
|
@ -1562,7 +1534,7 @@ void T_MOV_HIREG(ARM* cpu)
|
|||
// but since they serve no purpose ATTOW, we can skip them
|
||||
u32 addr = cpu->R[15] + 4; // Skip 2nd ID and flags
|
||||
// TODO: Pass flags to NocashPrint
|
||||
cpu->NDS.NocashPrint(cpu->Num, addr);
|
||||
NDS::NocashPrint(cpu->Num, addr);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,8 +19,6 @@
|
|||
#ifndef ARMINTERPRETER_ALU_H
|
||||
#define ARMINTERPRETER_ALU_H
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
namespace ARMInterpreter
|
||||
{
|
||||
|
||||
|
|
@ -136,5 +134,4 @@ void T_ADD_SP(ARM* cpu);
|
|||
|
||||
}
|
||||
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -16,13 +16,12 @@
|
|||
with melonDS. If not, see http://www.gnu.org/licenses/.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include "ARM.h"
|
||||
#include "Platform.h"
|
||||
|
||||
namespace melonDS::ARMInterpreter
|
||||
|
||||
namespace ARMInterpreter
|
||||
{
|
||||
using Platform::Log;
|
||||
using Platform::LogLevel;
|
||||
|
||||
|
||||
void A_B(ARM* cpu)
|
||||
|
|
@ -80,7 +79,7 @@ void T_BLX_REG(ARM* cpu)
|
|||
{
|
||||
if (cpu->Num==1)
|
||||
{
|
||||
Log(LogLevel::Warn, "!! THUMB BLX_REG ON ARM7\n");
|
||||
printf("!! THUMB BLX_REG ON ARM7\n");
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,8 +19,6 @@
|
|||
#ifndef ARMINTERPRETER_BRANCH_H
|
||||
#define ARMINTERPRETER_BRANCH_H
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
namespace ARMInterpreter
|
||||
{
|
||||
|
||||
|
|
@ -38,5 +36,4 @@ void T_BL_LONG_2(ARM* cpu);
|
|||
|
||||
}
|
||||
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -20,7 +20,7 @@
|
|||
#include "ARM.h"
|
||||
|
||||
|
||||
namespace melonDS::ARMInterpreter
|
||||
namespace ARMInterpreter
|
||||
{
|
||||
|
||||
|
||||
|
|
@ -62,20 +62,14 @@ namespace melonDS::ARMInterpreter
|
|||
|
||||
#define A_STR \
|
||||
offset += cpu->R[(cpu->CurInstr>>16) & 0xF]; \
|
||||
u32 storeval = cpu->R[(cpu->CurInstr>>12) & 0xF]; \
|
||||
if (((cpu->CurInstr>>12) & 0xF) == 0xF) \
|
||||
storeval += 4; \
|
||||
cpu->DataWrite32(offset, storeval); \
|
||||
cpu->DataWrite32(offset, cpu->R[(cpu->CurInstr>>12) & 0xF]); \
|
||||
if (cpu->CurInstr & (1<<21)) cpu->R[(cpu->CurInstr>>16) & 0xF] = offset; \
|
||||
cpu->AddCycles_CD();
|
||||
|
||||
// TODO: user mode (bit21)
|
||||
#define A_STR_POST \
|
||||
u32 addr = cpu->R[(cpu->CurInstr>>16) & 0xF]; \
|
||||
u32 storeval = cpu->R[(cpu->CurInstr>>12) & 0xF]; \
|
||||
if (((cpu->CurInstr>>12) & 0xF) == 0xF) \
|
||||
storeval += 4; \
|
||||
cpu->DataWrite32(addr, storeval); \
|
||||
cpu->DataWrite32(addr, cpu->R[(cpu->CurInstr>>12) & 0xF]); \
|
||||
cpu->R[(cpu->CurInstr>>16) & 0xF] += offset; \
|
||||
cpu->AddCycles_CD();
|
||||
|
||||
|
|
@ -430,9 +424,9 @@ void A_LDM(ARM* cpu)
|
|||
}
|
||||
}
|
||||
|
||||
u32 pc = 0;
|
||||
if (cpu->CurInstr & (1<<15))
|
||||
{
|
||||
u32 pc;
|
||||
if (preinc) base += 4;
|
||||
if (first) cpu->DataRead32 (base, &pc);
|
||||
else cpu->DataRead32S(base, &pc);
|
||||
|
|
@ -440,8 +434,13 @@ void A_LDM(ARM* cpu)
|
|||
|
||||
if (cpu->Num == 1)
|
||||
pc &= ~0x1;
|
||||
|
||||
cpu->JumpTo(pc, cpu->CurInstr & (1<<22));
|
||||
}
|
||||
|
||||
if ((cpu->CurInstr & (1<<22)) && !(cpu->CurInstr & (1<<15)))
|
||||
cpu->UpdateMode((cpu->CPSR&~0x1F)|0x10, cpu->CPSR, true);
|
||||
|
||||
if (cpu->CurInstr & (1<<21))
|
||||
{
|
||||
// post writeback
|
||||
|
|
@ -461,12 +460,6 @@ void A_LDM(ARM* cpu)
|
|||
cpu->R[baseid] = wbbase;
|
||||
}
|
||||
|
||||
if ((cpu->CurInstr & (1<<22)) && !(cpu->CurInstr & (1<<15)))
|
||||
cpu->UpdateMode((cpu->CPSR&~0x1F)|0x10, cpu->CPSR, true);
|
||||
|
||||
if (cpu->CurInstr & (1<<15))
|
||||
cpu->JumpTo(pc, cpu->CurInstr & (1<<22));
|
||||
|
||||
cpu->AddCycles_CDI();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,7 +19,7 @@
|
|||
#ifndef ARMINTERPRETER_LOADSTORE_H
|
||||
#define ARMINTERPRETER_LOADSTORE_H
|
||||
|
||||
namespace melonDS::ARMInterpreter
|
||||
namespace ARMInterpreter
|
||||
{
|
||||
|
||||
#define A_PROTO_WB_LDRSTR(x) \
|
||||
|
|
|
|||
389
src/ARMJIT.cpp
389
src/ARMJIT.cpp
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -17,7 +17,7 @@
|
|||
*/
|
||||
|
||||
#include "ARMJIT.h"
|
||||
#include "ARMJIT_Memory.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
#include <unordered_map>
|
||||
|
|
@ -30,7 +30,6 @@
|
|||
#include "ARMJIT_Internal.h"
|
||||
#include "ARMJIT_Memory.h"
|
||||
#include "ARMJIT_Compiler.h"
|
||||
#include "ARMJIT_Global.h"
|
||||
|
||||
#include "ARMInterpreter_ALU.h"
|
||||
#include "ARMInterpreter_LoadStore.h"
|
||||
|
|
@ -43,52 +42,136 @@
|
|||
#include "SPU.h"
|
||||
#include "Wifi.h"
|
||||
#include "NDSCart.h"
|
||||
#include "Platform.h"
|
||||
|
||||
|
||||
#include "ARMJIT_x64/ARMJIT_Offsets.h"
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
using Platform::Log;
|
||||
using Platform::LogLevel;
|
||||
|
||||
static_assert(offsetof(ARM, CPSR) == ARM_CPSR_offset, "");
|
||||
static_assert(offsetof(ARM, Cycles) == ARM_Cycles_offset, "");
|
||||
static_assert(offsetof(ARM, StopExecution) == ARM_StopExecution_offset, "");
|
||||
|
||||
namespace ARMJIT
|
||||
{
|
||||
|
||||
#define JIT_DEBUGPRINT(msg, ...)
|
||||
//#define JIT_DEBUGPRINT(msg, ...) Platform::Log(Platform::LogLevel::Debug, msg, ## __VA_ARGS__)
|
||||
//#define JIT_DEBUGPRINT(msg, ...) printf(msg, ## __VA_ARGS__)
|
||||
|
||||
Compiler* JITCompiler;
|
||||
|
||||
int MaxBlockSize;
|
||||
bool LiteralOptimizations;
|
||||
bool BranchOptimizations;
|
||||
bool FastMemory;
|
||||
|
||||
|
||||
std::unordered_map<u32, JitBlock*> JitBlocks9;
|
||||
std::unordered_map<u32, JitBlock*> JitBlocks7;
|
||||
|
||||
std::unordered_map<u32, JitBlock*> RestoreCandidates;
|
||||
|
||||
TinyVector<u32> InvalidLiterals;
|
||||
|
||||
AddressRange CodeIndexITCM[ITCMPhysicalSize / 512];
|
||||
AddressRange CodeIndexMainRAM[NDS::MainRAMMaxSize / 512];
|
||||
AddressRange CodeIndexSWRAM[NDS::SharedWRAMSize / 512];
|
||||
AddressRange CodeIndexVRAM[0x100000 / 512];
|
||||
AddressRange CodeIndexARM9BIOS[sizeof(NDS::ARM9BIOS) / 512];
|
||||
AddressRange CodeIndexARM7BIOS[sizeof(NDS::ARM7BIOS) / 512];
|
||||
AddressRange CodeIndexARM7WRAM[NDS::ARM7WRAMSize / 512];
|
||||
AddressRange CodeIndexARM7WVRAM[0x40000 / 512];
|
||||
AddressRange CodeIndexBIOS9DSi[0x10000 / 512];
|
||||
AddressRange CodeIndexBIOS7DSi[0x10000 / 512];
|
||||
AddressRange CodeIndexNWRAM_A[DSi::NWRAMSize / 512];
|
||||
AddressRange CodeIndexNWRAM_B[DSi::NWRAMSize / 512];
|
||||
AddressRange CodeIndexNWRAM_C[DSi::NWRAMSize / 512];
|
||||
|
||||
u64 FastBlockLookupITCM[ITCMPhysicalSize / 2];
|
||||
u64 FastBlockLookupMainRAM[NDS::MainRAMMaxSize / 2];
|
||||
u64 FastBlockLookupSWRAM[NDS::SharedWRAMSize / 2];
|
||||
u64 FastBlockLookupVRAM[0x100000 / 2];
|
||||
u64 FastBlockLookupARM9BIOS[sizeof(NDS::ARM9BIOS) / 2];
|
||||
u64 FastBlockLookupARM7BIOS[sizeof(NDS::ARM7BIOS) / 2];
|
||||
u64 FastBlockLookupARM7WRAM[NDS::ARM7WRAMSize / 2];
|
||||
u64 FastBlockLookupARM7WVRAM[0x40000 / 2];
|
||||
u64 FastBlockLookupBIOS9DSi[0x10000 / 2];
|
||||
u64 FastBlockLookupBIOS7DSi[0x10000 / 2];
|
||||
u64 FastBlockLookupNWRAM_A[DSi::NWRAMSize / 2];
|
||||
u64 FastBlockLookupNWRAM_B[DSi::NWRAMSize / 2];
|
||||
u64 FastBlockLookupNWRAM_C[DSi::NWRAMSize / 2];
|
||||
|
||||
const u32 CodeRegionSizes[ARMJIT_Memory::memregions_Count] =
|
||||
{
|
||||
0,
|
||||
ITCMPhysicalSize,
|
||||
0,
|
||||
ARM9BIOSSize,
|
||||
MainRAMMaxSize,
|
||||
SharedWRAMSize,
|
||||
sizeof(NDS::ARM9BIOS),
|
||||
NDS::MainRAMMaxSize,
|
||||
NDS::SharedWRAMSize,
|
||||
0,
|
||||
0x100000,
|
||||
ARM7BIOSSize,
|
||||
ARM7WRAMSize,
|
||||
sizeof(NDS::ARM7BIOS),
|
||||
NDS::ARM7WRAMSize,
|
||||
0,
|
||||
0,
|
||||
0x40000,
|
||||
0x10000,
|
||||
0x10000,
|
||||
NWRAMSize,
|
||||
NWRAMSize,
|
||||
NWRAMSize,
|
||||
DSi::NWRAMSize,
|
||||
DSi::NWRAMSize,
|
||||
DSi::NWRAMSize,
|
||||
};
|
||||
|
||||
u32 ARMJIT::LocaliseCodeAddress(u32 num, u32 addr) const noexcept
|
||||
AddressRange* const CodeMemRegions[ARMJIT_Memory::memregions_Count] =
|
||||
{
|
||||
NULL,
|
||||
CodeIndexITCM,
|
||||
NULL,
|
||||
CodeIndexARM9BIOS,
|
||||
CodeIndexMainRAM,
|
||||
CodeIndexSWRAM,
|
||||
NULL,
|
||||
CodeIndexVRAM,
|
||||
CodeIndexARM7BIOS,
|
||||
CodeIndexARM7WRAM,
|
||||
NULL,
|
||||
NULL,
|
||||
CodeIndexARM7WVRAM,
|
||||
CodeIndexBIOS9DSi,
|
||||
CodeIndexBIOS7DSi,
|
||||
CodeIndexNWRAM_A,
|
||||
CodeIndexNWRAM_B,
|
||||
CodeIndexNWRAM_C
|
||||
};
|
||||
|
||||
u64* const FastBlockLookupRegions[ARMJIT_Memory::memregions_Count] =
|
||||
{
|
||||
NULL,
|
||||
FastBlockLookupITCM,
|
||||
NULL,
|
||||
FastBlockLookupARM9BIOS,
|
||||
FastBlockLookupMainRAM,
|
||||
FastBlockLookupSWRAM,
|
||||
NULL,
|
||||
FastBlockLookupVRAM,
|
||||
FastBlockLookupARM7BIOS,
|
||||
FastBlockLookupARM7WRAM,
|
||||
NULL,
|
||||
NULL,
|
||||
FastBlockLookupARM7WVRAM,
|
||||
FastBlockLookupBIOS9DSi,
|
||||
FastBlockLookupBIOS7DSi,
|
||||
FastBlockLookupNWRAM_A,
|
||||
FastBlockLookupNWRAM_B,
|
||||
FastBlockLookupNWRAM_C
|
||||
};
|
||||
|
||||
u32 LocaliseCodeAddress(u32 num, u32 addr)
|
||||
{
|
||||
int region = num == 0
|
||||
? Memory.ClassifyAddress9(addr)
|
||||
: Memory.ClassifyAddress7(addr);
|
||||
? ARMJIT_Memory::ClassifyAddress9(addr)
|
||||
: ARMJIT_Memory::ClassifyAddress7(addr);
|
||||
|
||||
if (CodeMemRegions[region])
|
||||
return Memory.LocaliseAddress(region, num, addr);
|
||||
return ARMJIT_Memory::LocaliseAddress(region, num, addr);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -104,31 +187,11 @@ T SlowRead9(u32 addr, ARMv5* cpu)
|
|||
else if ((addr & cpu->DTCMMask) == cpu->DTCMBase)
|
||||
val = *(T*)&cpu->DTCM[addr & 0x3FFF];
|
||||
else if (std::is_same<T, u32>::value)
|
||||
val = NDS::Current->ARM9Read32(addr);
|
||||
val = (ConsoleType == 0 ? NDS::ARM9Read32 : DSi::ARM9Read32)(addr);
|
||||
else if (std::is_same<T, u16>::value)
|
||||
val = NDS::Current->ARM9Read16(addr);
|
||||
val = (ConsoleType == 0 ? NDS::ARM9Read16 : DSi::ARM9Read16)(addr);
|
||||
else
|
||||
val = NDS::Current->ARM9Read8(addr);
|
||||
|
||||
if (std::is_same<T, u32>::value)
|
||||
return ROR(val, offset << 3);
|
||||
else
|
||||
return val;
|
||||
}
|
||||
|
||||
template <typename T, int ConsoleType>
|
||||
T SlowRead7(u32 addr)
|
||||
{
|
||||
u32 offset = addr & 0x3;
|
||||
addr &= ~(sizeof(T) - 1);
|
||||
|
||||
T val;
|
||||
if (std::is_same<T, u32>::value)
|
||||
val = NDS::Current->ARM7Read32(addr);
|
||||
else if (std::is_same<T, u16>::value)
|
||||
val = NDS::Current->ARM7Read16(addr);
|
||||
else
|
||||
val = NDS::Current->ARM7Read8(addr);
|
||||
val = (ConsoleType == 0 ? NDS::ARM9Read8 : DSi::ARM9Read8)(addr);
|
||||
|
||||
if (std::is_same<T, u32>::value)
|
||||
return ROR(val, offset << 3);
|
||||
|
|
@ -143,7 +206,7 @@ void SlowWrite9(u32 addr, ARMv5* cpu, u32 val)
|
|||
|
||||
if (addr < cpu->ITCMSize)
|
||||
{
|
||||
cpu->NDS.JIT.CheckAndInvalidate<0, ARMJIT_Memory::memregion_ITCM>(addr);
|
||||
CheckAndInvalidate<0, ARMJIT_Memory::memregion_ITCM>(addr);
|
||||
*(T*)&cpu->ITCM[addr & 0x7FFF] = val;
|
||||
}
|
||||
else if ((addr & cpu->DTCMMask) == cpu->DTCMBase)
|
||||
|
|
@ -152,29 +215,49 @@ void SlowWrite9(u32 addr, ARMv5* cpu, u32 val)
|
|||
}
|
||||
else if (std::is_same<T, u32>::value)
|
||||
{
|
||||
NDS::Current->ARM9Write32(addr, val);
|
||||
(ConsoleType == 0 ? NDS::ARM9Write32 : DSi::ARM9Write32)(addr, val);
|
||||
}
|
||||
else if (std::is_same<T, u16>::value)
|
||||
{
|
||||
NDS::Current->ARM9Write16(addr, val);
|
||||
(ConsoleType == 0 ? NDS::ARM9Write16 : DSi::ARM9Write16)(addr, val);
|
||||
}
|
||||
else
|
||||
{
|
||||
NDS::Current->ARM9Write8(addr, val);
|
||||
(ConsoleType == 0 ? NDS::ARM9Write8 : DSi::ARM9Write8)(addr, val);
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T, int ConsoleType>
|
||||
T SlowRead7(u32 addr)
|
||||
{
|
||||
u32 offset = addr & 0x3;
|
||||
addr &= ~(sizeof(T) - 1);
|
||||
|
||||
T val;
|
||||
if (std::is_same<T, u32>::value)
|
||||
val = (ConsoleType == 0 ? NDS::ARM7Read32 : DSi::ARM7Read32)(addr);
|
||||
else if (std::is_same<T, u16>::value)
|
||||
val = (ConsoleType == 0 ? NDS::ARM7Read16 : DSi::ARM7Read16)(addr);
|
||||
else
|
||||
val = (ConsoleType == 0 ? NDS::ARM7Read8 : DSi::ARM7Read8)(addr);
|
||||
|
||||
if (std::is_same<T, u32>::value)
|
||||
return ROR(val, offset << 3);
|
||||
else
|
||||
return val;
|
||||
}
|
||||
|
||||
template <typename T, int ConsoleType>
|
||||
void SlowWrite7(u32 addr, u32 val)
|
||||
{
|
||||
addr &= ~(sizeof(T) - 1);
|
||||
|
||||
if (std::is_same<T, u32>::value)
|
||||
NDS::Current->ARM7Write32(addr, val);
|
||||
(ConsoleType == 0 ? NDS::ARM7Write32 : DSi::ARM7Write32)(addr, val);
|
||||
else if (std::is_same<T, u16>::value)
|
||||
NDS::Current->ARM7Write16(addr, val);
|
||||
(ConsoleType == 0 ? NDS::ARM7Write16 : DSi::ARM7Write16)(addr, val);
|
||||
else
|
||||
NDS::Current->ARM7Write8(addr, val);
|
||||
(ConsoleType == 0 ? NDS::ARM7Write8 : DSi::ARM7Write8)(addr, val);
|
||||
}
|
||||
|
||||
template <bool Write, int ConsoleType>
|
||||
|
|
@ -230,18 +313,38 @@ void SlowBlockTransfer7(u32 addr, u64* data, u32 num)
|
|||
INSTANTIATE_SLOWMEM(0)
|
||||
INSTANTIATE_SLOWMEM(1)
|
||||
|
||||
ARMJIT::~ARMJIT() noexcept
|
||||
void Init()
|
||||
{
|
||||
JitEnableWrite();
|
||||
ResetBlockCache();
|
||||
JITCompiler = new Compiler();
|
||||
|
||||
ARMJIT_Memory::Init();
|
||||
}
|
||||
|
||||
void ARMJIT::Reset() noexcept
|
||||
void DeInit()
|
||||
{
|
||||
JitEnableWrite();
|
||||
ResetBlockCache();
|
||||
ARMJIT_Memory::DeInit();
|
||||
|
||||
Memory.Reset();
|
||||
delete JITCompiler;
|
||||
}
|
||||
|
||||
void Reset()
|
||||
{
|
||||
MaxBlockSize = Platform::GetConfigInt(Platform::JIT_MaxBlockSize);
|
||||
LiteralOptimizations = Platform::GetConfigBool(Platform::JIT_LiteralOptimizations);
|
||||
BranchOptimizations = Platform::GetConfigBool(Platform::JIT_BranchOptimizations);
|
||||
FastMemory = Platform::GetConfigBool(Platform::JIT_FastMemory);
|
||||
|
||||
if (MaxBlockSize < 1)
|
||||
MaxBlockSize = 1;
|
||||
if (MaxBlockSize > 32)
|
||||
MaxBlockSize = 32;
|
||||
|
||||
JitEnableWrite();
|
||||
ResetBlockCache();
|
||||
|
||||
ARMJIT_Memory::Reset();
|
||||
}
|
||||
|
||||
void FloodFillSetFlags(FetchedInstr instrs[], int start, u8 flags)
|
||||
|
|
@ -468,17 +571,7 @@ InterpreterFunc InterpretTHUMB[ARMInstrInfo::tk_Count] =
|
|||
};
|
||||
#undef F
|
||||
|
||||
ARMJIT::ARMJIT(melonDS::NDS& nds, std::optional<JITArgs> jit) noexcept :
|
||||
NDS(nds),
|
||||
Memory(nds),
|
||||
JITCompiler(nds),
|
||||
MaxBlockSize(jit.has_value() ? std::clamp(jit->MaxBlockSize, 1u, 32u) : 32),
|
||||
LiteralOptimizations(jit.has_value() ? jit->LiteralOptimizations : false),
|
||||
BranchOptimizations(jit.has_value() ? jit->BranchOptimizations : false),
|
||||
FastMemory((jit.has_value() ? jit->FastMemory : false) && ARMJIT_Memory::IsFastMemSupported())
|
||||
{}
|
||||
|
||||
void ARMJIT::RetireJitBlock(JitBlock* block) noexcept
|
||||
void RetireJitBlock(JitBlock* block)
|
||||
{
|
||||
auto it = RestoreCandidates.find(block->InstrHash);
|
||||
if (it != RestoreCandidates.end())
|
||||
|
|
@ -492,44 +585,7 @@ void ARMJIT::RetireJitBlock(JitBlock* block) noexcept
|
|||
}
|
||||
}
|
||||
|
||||
void ARMJIT::SetJITArgs(JITArgs args) noexcept
|
||||
{
|
||||
args.FastMemory = args.FastMemory && ARMJIT_Memory::IsFastMemSupported();
|
||||
args.MaxBlockSize = std::clamp(args.MaxBlockSize, 1u, 32u);
|
||||
|
||||
if (MaxBlockSize != args.MaxBlockSize
|
||||
|| LiteralOptimizations != args.LiteralOptimizations
|
||||
|| BranchOptimizations != args.BranchOptimizations
|
||||
|| FastMemory != args.FastMemory)
|
||||
ResetBlockCache();
|
||||
|
||||
MaxBlockSize = args.MaxBlockSize;
|
||||
LiteralOptimizations = args.LiteralOptimizations;
|
||||
BranchOptimizations = args.BranchOptimizations;
|
||||
FastMemory = args.FastMemory;
|
||||
}
|
||||
|
||||
void ARMJIT::SetMaxBlockSize(int size) noexcept
|
||||
{
|
||||
SetJITArgs(JITArgs{static_cast<unsigned>(size), LiteralOptimizations, LiteralOptimizations, FastMemory});
|
||||
}
|
||||
|
||||
void ARMJIT::SetLiteralOptimizations(bool enabled) noexcept
|
||||
{
|
||||
SetJITArgs(JITArgs{static_cast<unsigned>(MaxBlockSize), enabled, BranchOptimizations, FastMemory});
|
||||
}
|
||||
|
||||
void ARMJIT::SetBranchOptimizations(bool enabled) noexcept
|
||||
{
|
||||
SetJITArgs(JITArgs{static_cast<unsigned>(MaxBlockSize), LiteralOptimizations, enabled, FastMemory});
|
||||
}
|
||||
|
||||
void ARMJIT::SetFastMemory(bool enabled) noexcept
|
||||
{
|
||||
SetJITArgs(JITArgs{static_cast<unsigned>(MaxBlockSize), LiteralOptimizations, BranchOptimizations, enabled});
|
||||
}
|
||||
|
||||
void ARMJIT::CompileBlock(ARM* cpu) noexcept
|
||||
void CompileBlock(ARM* cpu)
|
||||
{
|
||||
bool thumb = cpu->CPSR & 0x20;
|
||||
|
||||
|
|
@ -538,7 +594,7 @@ void ARMJIT::CompileBlock(ARM* cpu) noexcept
|
|||
u32 localAddr = LocaliseCodeAddress(cpu->Num, blockAddr);
|
||||
if (!localAddr)
|
||||
{
|
||||
Log(LogLevel::Warn, "trying to compile non executable code? %x\n", blockAddr);
|
||||
printf("trying to compile non executable code? %x\n", blockAddr);
|
||||
}
|
||||
|
||||
auto& map = cpu->Num == 0 ? JitBlocks9 : JitBlocks7;
|
||||
|
|
@ -556,7 +612,7 @@ void ARMJIT::CompileBlock(ARM* cpu) noexcept
|
|||
|
||||
u64* entry = &FastBlockLookupRegions[localAddr >> 27][(localAddr & 0x7FFFFFF) / 2];
|
||||
*entry = ((u64)blockAddr | cpu->Num) << 32;
|
||||
*entry |= JITCompiler.SubEntryOffset(existingBlockIt->second->EntryPoint);
|
||||
*entry |= JITCompiler->SubEntryOffset(existingBlockIt->second->EntryPoint);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -657,7 +713,7 @@ void ARMJIT::CompileBlock(ARM* cpu) noexcept
|
|||
nextInstr[1] = cpuv4->CodeRead32(r15);
|
||||
instrs[i].CodeCycles = cpu->CodeCycles;
|
||||
}
|
||||
instrs[i].Info = ARMInstrInfo::Decode(thumb, cpu->Num, instrs[i].Instr, LiteralOptimizations);
|
||||
instrs[i].Info = ARMInstrInfo::Decode(thumb, cpu->Num, instrs[i].Instr);
|
||||
|
||||
hasMemoryInstr |= thumb
|
||||
? (instrs[i].Info.Kind >= ARMInstrInfo::tk_LDR_PCREL && instrs[i].Info.Kind <= ARMInstrInfo::tk_STMIA)
|
||||
|
|
@ -708,7 +764,7 @@ void ARMJIT::CompileBlock(ARM* cpu) noexcept
|
|||
u32 translatedAddr = LocaliseCodeAddress(cpu->Num, literalAddr);
|
||||
if (!translatedAddr)
|
||||
{
|
||||
Log(LogLevel::Warn,"literal in non executable memory?\n");
|
||||
printf("literal in non executable memory?\n");
|
||||
}
|
||||
if (InvalidLiterals.Find(translatedAddr) == -1)
|
||||
{
|
||||
|
|
@ -759,7 +815,7 @@ void ARMJIT::CompileBlock(ARM* cpu) noexcept
|
|||
{
|
||||
for (int j = 0; j < i; j++)
|
||||
{
|
||||
if (instrs[j].Addr == target)
|
||||
if (instrs[i].Addr == target)
|
||||
{
|
||||
isBackJump = true;
|
||||
break;
|
||||
|
|
@ -815,7 +871,7 @@ void ARMJIT::CompileBlock(ARM* cpu) noexcept
|
|||
|
||||
i++;
|
||||
|
||||
bool canCompile = JITCompiler.CanCompile(thumb, instrs[i - 1].Info.Kind);
|
||||
bool canCompile = JITCompiler->CanCompile(thumb, instrs[i - 1].Info.Kind);
|
||||
bool secondaryFlagReadCond = !canCompile || (instrs[i - 1].BranchFlags & (branch_FollowCondTaken | branch_FollowCondNotTaken));
|
||||
if (instrs[i - 1].Info.ReadFlags != 0 || secondaryFlagReadCond)
|
||||
FloodFillSetFlags(instrs, i - 2, !secondaryFlagReadCond ? instrs[i - 1].Info.ReadFlags : 0xF);
|
||||
|
|
@ -896,7 +952,7 @@ void ARMJIT::CompileBlock(ARM* cpu) noexcept
|
|||
FloodFillSetFlags(instrs, i - 1, 0xF);
|
||||
|
||||
JitEnableWrite();
|
||||
block->EntryPoint = JITCompiler.CompileBlock(cpu, thumb, instrs, i, hasMemoryInstr);
|
||||
block->EntryPoint = JITCompiler->CompileBlock(cpu, thumb, instrs, i, hasMemoryInstr);
|
||||
JitEnableExecute();
|
||||
|
||||
JIT_DEBUGPRINT("block start %p\n", block->EntryPoint);
|
||||
|
|
@ -916,8 +972,8 @@ void ARMJIT::CompileBlock(ARM* cpu) noexcept
|
|||
|
||||
AddressRange* region = CodeMemRegions[addressRanges[j] >> 27];
|
||||
|
||||
if (!PageContainsCode(®ion[(addressRanges[j] & 0x7FFF000 & ~(Memory.PageSize - 1)) / 512], Memory.PageSize))
|
||||
Memory.SetCodeProtection(addressRanges[j] >> 27, addressRanges[j] & 0x7FFFFFF, true);
|
||||
if (!PageContainsCode(®ion[(addressRanges[j] & 0x7FFF000) / 512]))
|
||||
ARMJIT_Memory::SetCodeProtection(addressRanges[j] >> 27, addressRanges[j] & 0x7FFFFFF, true);
|
||||
|
||||
AddressRange* range = ®ion[(addressRanges[j] & 0x7FFFFFF) / 512];
|
||||
range->Code |= addressMasks[j];
|
||||
|
|
@ -931,10 +987,10 @@ void ARMJIT::CompileBlock(ARM* cpu) noexcept
|
|||
|
||||
u64* entry = &FastBlockLookupRegions[(localAddr >> 27)][(localAddr & 0x7FFFFFF) / 2];
|
||||
*entry = ((u64)blockAddr | cpu->Num) << 32;
|
||||
*entry |= JITCompiler.SubEntryOffset(block->EntryPoint);
|
||||
*entry |= JITCompiler->SubEntryOffset(block->EntryPoint);
|
||||
}
|
||||
|
||||
void ARMJIT::InvalidateByAddr(u32 localAddr) noexcept
|
||||
void InvalidateByAddr(u32 localAddr)
|
||||
{
|
||||
JIT_DEBUGPRINT("invalidating by addr %x\n", localAddr);
|
||||
|
||||
|
|
@ -969,9 +1025,9 @@ void ARMJIT::InvalidateByAddr(u32 localAddr) noexcept
|
|||
range->Blocks.Remove(i);
|
||||
|
||||
if (range->Blocks.Length == 0
|
||||
&& !PageContainsCode(®ion[(localAddr & 0x7FFF000 & ~(Memory.PageSize - 1)) / 512], Memory.PageSize))
|
||||
&& !PageContainsCode(®ion[(localAddr & 0x7FFF000) / 512]))
|
||||
{
|
||||
Memory.SetCodeProtection(localAddr >> 27, localAddr & 0x7FFFFFF, false);
|
||||
ARMJIT_Memory::SetCodeProtection(localAddr >> 27, localAddr & 0x7FFFFFF, false);
|
||||
}
|
||||
|
||||
bool literalInvalidation = false;
|
||||
|
|
@ -1003,8 +1059,8 @@ void ARMJIT::InvalidateByAddr(u32 localAddr) noexcept
|
|||
|
||||
if (otherRange->Blocks.Length == 0)
|
||||
{
|
||||
if (!PageContainsCode(&otherRegion[(addr & 0x7FFF000 & ~(Memory.PageSize - 1)) / 512], Memory.PageSize))
|
||||
Memory.SetCodeProtection(addr >> 27, addr & 0x7FFFFFF, false);
|
||||
if (!PageContainsCode(&otherRegion[(addr & 0x7FFF000) / 512]))
|
||||
ARMJIT_Memory::SetCodeProtection(addr >> 27, addr & 0x7FFFFFF, false);
|
||||
|
||||
otherRange->Code = 0;
|
||||
}
|
||||
|
|
@ -1028,64 +1084,49 @@ void ARMJIT::InvalidateByAddr(u32 localAddr) noexcept
|
|||
}
|
||||
}
|
||||
|
||||
void ARMJIT::CheckAndInvalidateITCM() noexcept
|
||||
void CheckAndInvalidateITCM()
|
||||
{
|
||||
for (u32 i = 0; i < ITCMPhysicalSize; i+=512)
|
||||
for (u32 i = 0; i < ITCMPhysicalSize; i+=16)
|
||||
{
|
||||
if (CodeIndexITCM[i / 512].Code)
|
||||
if (CodeIndexITCM[i / 512].Code & (1 << ((i & 0x1FF) / 16)))
|
||||
{
|
||||
// maybe using bitscan would be better here?
|
||||
// The thing is that in densely populated sets
|
||||
// The old fashioned way can actually be faster
|
||||
for (u32 j = 0; j < 512; j += 16)
|
||||
{
|
||||
if (CodeIndexITCM[i / 512].Code & (1 << ((j & 0x1FF) / 16)))
|
||||
InvalidateByAddr((i+j) | (ARMJIT_Memory::memregion_ITCM << 27));
|
||||
}
|
||||
InvalidateByAddr(i | (ARMJIT_Memory::memregion_ITCM << 27));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void ARMJIT::CheckAndInvalidateWVRAM(int bank) noexcept
|
||||
template <u32 num, int region>
|
||||
void CheckAndInvalidate(u32 addr)
|
||||
{
|
||||
u32 start = bank == 1 ? 0x20000 : 0;
|
||||
for (u32 i = start; i < start+0x20000; i+=512)
|
||||
{
|
||||
if (CodeIndexARM7WVRAM[i / 512].Code)
|
||||
{
|
||||
for (u32 j = 0; j < 512; j += 16)
|
||||
{
|
||||
if (CodeIndexARM7WVRAM[i / 512].Code & (1 << ((j & 0x1FF) / 16)))
|
||||
InvalidateByAddr((i+j) | (ARMJIT_Memory::memregion_VWRAM << 27));
|
||||
}
|
||||
}
|
||||
}
|
||||
u32 localAddr = ARMJIT_Memory::LocaliseAddress(region, num, addr);
|
||||
if (CodeMemRegions[region][(localAddr & 0x7FFFFFF) / 512].Code & (1 << ((localAddr & 0x1FF) / 16)))
|
||||
InvalidateByAddr(localAddr);
|
||||
}
|
||||
|
||||
JitBlockEntry ARMJIT::LookUpBlock(u32 num, u64* entries, u32 offset, u32 addr) noexcept
|
||||
JitBlockEntry LookUpBlock(u32 num, u64* entries, u32 offset, u32 addr)
|
||||
{
|
||||
u64* entry = &entries[offset / 2];
|
||||
if (*entry >> 32 == (addr | num))
|
||||
return JITCompiler.AddEntryOffset((u32)*entry);
|
||||
return JITCompiler->AddEntryOffset((u32)*entry);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void ARMJIT::blockSanityCheck(u32 num, u32 blockAddr, JitBlockEntry entry) noexcept
|
||||
void blockSanityCheck(u32 num, u32 blockAddr, JitBlockEntry entry)
|
||||
{
|
||||
u32 localAddr = LocaliseCodeAddress(num, blockAddr);
|
||||
assert(JITCompiler.AddEntryOffset((u32)FastBlockLookupRegions[localAddr >> 27][(localAddr & 0x7FFFFFF) / 2]) == entry);
|
||||
assert(JITCompiler->AddEntryOffset((u32)FastBlockLookupRegions[localAddr >> 27][(localAddr & 0x7FFFFFF) / 2]) == entry);
|
||||
}
|
||||
|
||||
bool ARMJIT::SetupExecutableRegion(u32 num, u32 blockAddr, u64*& entry, u32& start, u32& size) noexcept
|
||||
bool SetupExecutableRegion(u32 num, u32 blockAddr, u64*& entry, u32& start, u32& size)
|
||||
{
|
||||
// amazingly ignoring the DTCM is the proper behaviour for code fetches
|
||||
int region = num == 0
|
||||
? Memory.ClassifyAddress9(blockAddr)
|
||||
: Memory.ClassifyAddress7(blockAddr);
|
||||
? ARMJIT_Memory::ClassifyAddress9(blockAddr)
|
||||
: ARMJIT_Memory::ClassifyAddress7(blockAddr);
|
||||
|
||||
u32 memoryOffset;
|
||||
if (FastBlockLookupRegions[region]
|
||||
&& Memory.GetMirrorLocation(region, num, blockAddr, memoryOffset, start, size))
|
||||
&& ARMJIT_Memory::GetMirrorLocation(region, num, blockAddr, memoryOffset, start, size))
|
||||
{
|
||||
//printf("setup exec region %d %d %08x %08x %x %x\n", num, region, blockAddr, start, size, memoryOffset);
|
||||
entry = FastBlockLookupRegions[region] + memoryOffset / 2;
|
||||
|
|
@ -1094,28 +1135,28 @@ bool ARMJIT::SetupExecutableRegion(u32 num, u32 blockAddr, u64*& entry, u32& sta
|
|||
return false;
|
||||
}
|
||||
|
||||
template void ARMJIT::CheckAndInvalidate<0, ARMJIT_Memory::memregion_MainRAM>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<1, ARMJIT_Memory::memregion_MainRAM>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<0, ARMJIT_Memory::memregion_SharedWRAM>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<1, ARMJIT_Memory::memregion_SharedWRAM>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<1, ARMJIT_Memory::memregion_WRAM7>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<1, ARMJIT_Memory::memregion_VWRAM>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<0, ARMJIT_Memory::memregion_VRAM>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<0, ARMJIT_Memory::memregion_ITCM>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<0, ARMJIT_Memory::memregion_NewSharedWRAM_A>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<1, ARMJIT_Memory::memregion_NewSharedWRAM_A>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<0, ARMJIT_Memory::memregion_NewSharedWRAM_B>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<1, ARMJIT_Memory::memregion_NewSharedWRAM_B>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<0, ARMJIT_Memory::memregion_NewSharedWRAM_C>(u32) noexcept;
|
||||
template void ARMJIT::CheckAndInvalidate<1, ARMJIT_Memory::memregion_NewSharedWRAM_C>(u32) noexcept;
|
||||
template void CheckAndInvalidate<0, ARMJIT_Memory::memregion_MainRAM>(u32);
|
||||
template void CheckAndInvalidate<1, ARMJIT_Memory::memregion_MainRAM>(u32);
|
||||
template void CheckAndInvalidate<0, ARMJIT_Memory::memregion_SharedWRAM>(u32);
|
||||
template void CheckAndInvalidate<1, ARMJIT_Memory::memregion_SharedWRAM>(u32);
|
||||
template void CheckAndInvalidate<1, ARMJIT_Memory::memregion_WRAM7>(u32);
|
||||
template void CheckAndInvalidate<1, ARMJIT_Memory::memregion_VWRAM>(u32);
|
||||
template void CheckAndInvalidate<0, ARMJIT_Memory::memregion_VRAM>(u32);
|
||||
template void CheckAndInvalidate<0, ARMJIT_Memory::memregion_ITCM>(u32);
|
||||
template void CheckAndInvalidate<0, ARMJIT_Memory::memregion_NewSharedWRAM_A>(u32);
|
||||
template void CheckAndInvalidate<1, ARMJIT_Memory::memregion_NewSharedWRAM_A>(u32);
|
||||
template void CheckAndInvalidate<0, ARMJIT_Memory::memregion_NewSharedWRAM_B>(u32);
|
||||
template void CheckAndInvalidate<1, ARMJIT_Memory::memregion_NewSharedWRAM_B>(u32);
|
||||
template void CheckAndInvalidate<0, ARMJIT_Memory::memregion_NewSharedWRAM_C>(u32);
|
||||
template void CheckAndInvalidate<1, ARMJIT_Memory::memregion_NewSharedWRAM_C>(u32);
|
||||
|
||||
void ARMJIT::ResetBlockCache() noexcept
|
||||
void ResetBlockCache()
|
||||
{
|
||||
Log(LogLevel::Debug, "Resetting JIT block cache...\n");
|
||||
printf("Resetting JIT block cache...\n");
|
||||
|
||||
// could be replace through a function which only resets
|
||||
// the permissions but we're too lazy
|
||||
Memory.Reset();
|
||||
ARMJIT_Memory::Reset();
|
||||
|
||||
InvalidLiterals.Clear();
|
||||
for (int i = 0; i < ARMJIT_Memory::memregions_Count; i++)
|
||||
|
|
@ -1153,10 +1194,10 @@ void ARMJIT::ResetBlockCache() noexcept
|
|||
JitBlocks9.clear();
|
||||
JitBlocks7.clear();
|
||||
|
||||
JITCompiler.Reset();
|
||||
JITCompiler->Reset();
|
||||
}
|
||||
|
||||
void ARMJIT::JitEnableWrite() noexcept
|
||||
void JitEnableWrite()
|
||||
{
|
||||
#if defined(__APPLE__) && defined(__aarch64__)
|
||||
if (__builtin_available(macOS 11.0, *))
|
||||
|
|
@ -1164,7 +1205,7 @@ void ARMJIT::JitEnableWrite() noexcept
|
|||
#endif
|
||||
}
|
||||
|
||||
void ARMJIT::JitEnableExecute() noexcept
|
||||
void JitEnableExecute()
|
||||
{
|
||||
#if defined(__APPLE__) && defined(__aarch64__)
|
||||
if (__builtin_available(macOS 11.0, *))
|
||||
|
|
|
|||
188
src/ARMJIT.h
188
src/ARMJIT.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,188 +19,48 @@
|
|||
#ifndef ARMJIT_H
|
||||
#define ARMJIT_H
|
||||
|
||||
#include <algorithm>
|
||||
#include <optional>
|
||||
#include <memory>
|
||||
#include "types.h"
|
||||
#include "MemConstants.h"
|
||||
#include "Args.h"
|
||||
#include "ARMJIT_Memory.h"
|
||||
|
||||
#ifdef JIT_ENABLED
|
||||
#include "JitBlock.h"
|
||||
#include "ARM.h"
|
||||
#include "ARM_InstrInfo.h"
|
||||
|
||||
#if defined(__APPLE__) && defined(__aarch64__)
|
||||
#include <pthread.h>
|
||||
#endif
|
||||
|
||||
#include "ARMJIT_Compiler.h"
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT
|
||||
{
|
||||
class ARM;
|
||||
|
||||
class JitBlock;
|
||||
class ARMJIT
|
||||
{
|
||||
public:
|
||||
ARMJIT(melonDS::NDS& nds, std::optional<JITArgs> jit) noexcept;
|
||||
~ARMJIT() noexcept;
|
||||
void InvalidateByAddr(u32) noexcept;
|
||||
void CheckAndInvalidateWVRAM(int) noexcept;
|
||||
void CheckAndInvalidateITCM() noexcept;
|
||||
void Reset() noexcept;
|
||||
void JitEnableWrite() noexcept;
|
||||
void JitEnableExecute() noexcept;
|
||||
void CompileBlock(ARM* cpu) noexcept;
|
||||
void ResetBlockCache() noexcept;
|
||||
typedef void (*JitBlockEntry)();
|
||||
|
||||
template <u32 num, int region>
|
||||
void CheckAndInvalidate(u32 addr) noexcept
|
||||
{
|
||||
u32 localAddr = Memory.LocaliseAddress(region, num, addr);
|
||||
if (CodeMemRegions[region][(localAddr & 0x7FFFFFF) / 512].Code & (1 << ((localAddr & 0x1FF) / 16)))
|
||||
InvalidateByAddr(localAddr);
|
||||
}
|
||||
JitBlockEntry LookUpBlock(u32 num, u64* entries, u32 offset, u32 addr) noexcept;
|
||||
bool SetupExecutableRegion(u32 num, u32 blockAddr, u64*& entry, u32& start, u32& size) noexcept;
|
||||
u32 LocaliseCodeAddress(u32 num, u32 addr) const noexcept;
|
||||
extern int MaxBlockSize;
|
||||
extern bool LiteralOptimizations;
|
||||
extern bool BranchOptimizations;
|
||||
extern bool FastMemory;
|
||||
|
||||
ARMJIT_Memory Memory;
|
||||
private:
|
||||
int MaxBlockSize {};
|
||||
bool LiteralOptimizations = false;
|
||||
bool BranchOptimizations = false;
|
||||
bool FastMemory = false;
|
||||
void Init();
|
||||
void DeInit();
|
||||
|
||||
public:
|
||||
melonDS::NDS& NDS;
|
||||
TinyVector<u32> InvalidLiterals {};
|
||||
friend class ARMJIT_Memory;
|
||||
void blockSanityCheck(u32 num, u32 blockAddr, JitBlockEntry entry) noexcept;
|
||||
void RetireJitBlock(JitBlock* block) noexcept;
|
||||
void Reset();
|
||||
|
||||
int GetMaxBlockSize() const noexcept { return MaxBlockSize; }
|
||||
bool LiteralOptimizationsEnabled() const noexcept { return LiteralOptimizations; }
|
||||
bool BranchOptimizationsEnabled() const noexcept { return BranchOptimizations; }
|
||||
bool FastMemoryEnabled() const noexcept { return FastMemory; }
|
||||
void CheckAndInvalidateITCM();
|
||||
|
||||
void SetJITArgs(JITArgs args) noexcept;
|
||||
void SetMaxBlockSize(int size) noexcept;
|
||||
void SetLiteralOptimizations(bool enabled) noexcept;
|
||||
void SetBranchOptimizations(bool enabled) noexcept;
|
||||
void SetFastMemory(bool enabled) noexcept;
|
||||
void InvalidateByAddr(u32 pseudoPhysical);
|
||||
|
||||
Compiler JITCompiler;
|
||||
std::unordered_map<u32, JitBlock*> JitBlocks9 {};
|
||||
std::unordered_map<u32, JitBlock*> JitBlocks7 {};
|
||||
template <u32 num, int region>
|
||||
void CheckAndInvalidate(u32 addr);
|
||||
|
||||
std::unordered_map<u32, JitBlock*> RestoreCandidates {};
|
||||
void CompileBlock(ARM* cpu);
|
||||
|
||||
void ResetBlockCache();
|
||||
|
||||
AddressRange CodeIndexITCM[ITCMPhysicalSize / 512] {};
|
||||
AddressRange CodeIndexMainRAM[MainRAMMaxSize / 512] {};
|
||||
AddressRange CodeIndexSWRAM[SharedWRAMSize / 512] {};
|
||||
AddressRange CodeIndexVRAM[0x100000 / 512] {};
|
||||
AddressRange CodeIndexARM9BIOS[ARM9BIOSSize / 512] {};
|
||||
AddressRange CodeIndexARM7BIOS[ARM7BIOSSize / 512] {};
|
||||
AddressRange CodeIndexARM7WRAM[ARM7WRAMSize / 512] {};
|
||||
AddressRange CodeIndexARM7WVRAM[0x40000 / 512] {};
|
||||
AddressRange CodeIndexBIOS9DSi[0x10000 / 512] {};
|
||||
AddressRange CodeIndexBIOS7DSi[0x10000 / 512] {};
|
||||
AddressRange CodeIndexNWRAM_A[NWRAMSize / 512] {};
|
||||
AddressRange CodeIndexNWRAM_B[NWRAMSize / 512] {};
|
||||
AddressRange CodeIndexNWRAM_C[NWRAMSize / 512] {};
|
||||
JitBlockEntry LookUpBlock(u32 num, u64* entries, u32 offset, u32 addr);
|
||||
bool SetupExecutableRegion(u32 num, u32 blockAddr, u64*& entry, u32& start, u32& size);
|
||||
|
||||
u64 FastBlockLookupITCM[ITCMPhysicalSize / 2] {};
|
||||
u64 FastBlockLookupMainRAM[MainRAMMaxSize / 2] {};
|
||||
u64 FastBlockLookupSWRAM[SharedWRAMSize / 2] {};
|
||||
u64 FastBlockLookupVRAM[0x100000 / 2] {};
|
||||
u64 FastBlockLookupARM9BIOS[ARM9BIOSSize / 2] {};
|
||||
u64 FastBlockLookupARM7BIOS[ARM7BIOSSize / 2] {};
|
||||
u64 FastBlockLookupARM7WRAM[ARM7WRAMSize / 2] {};
|
||||
u64 FastBlockLookupARM7WVRAM[0x40000 / 2] {};
|
||||
u64 FastBlockLookupBIOS9DSi[0x10000 / 2] {};
|
||||
u64 FastBlockLookupBIOS7DSi[0x10000 / 2] {};
|
||||
u64 FastBlockLookupNWRAM_A[NWRAMSize / 2] {};
|
||||
u64 FastBlockLookupNWRAM_B[NWRAMSize / 2] {};
|
||||
u64 FastBlockLookupNWRAM_C[NWRAMSize / 2] {};
|
||||
|
||||
AddressRange* const CodeMemRegions[ARMJIT_Memory::memregions_Count] =
|
||||
{
|
||||
NULL,
|
||||
CodeIndexITCM,
|
||||
NULL,
|
||||
CodeIndexARM9BIOS,
|
||||
CodeIndexMainRAM,
|
||||
CodeIndexSWRAM,
|
||||
NULL,
|
||||
CodeIndexVRAM,
|
||||
CodeIndexARM7BIOS,
|
||||
CodeIndexARM7WRAM,
|
||||
NULL,
|
||||
NULL,
|
||||
CodeIndexARM7WVRAM,
|
||||
CodeIndexBIOS9DSi,
|
||||
CodeIndexBIOS7DSi,
|
||||
CodeIndexNWRAM_A,
|
||||
CodeIndexNWRAM_B,
|
||||
CodeIndexNWRAM_C
|
||||
};
|
||||
|
||||
u64* const FastBlockLookupRegions[ARMJIT_Memory::memregions_Count] =
|
||||
{
|
||||
NULL,
|
||||
FastBlockLookupITCM,
|
||||
NULL,
|
||||
FastBlockLookupARM9BIOS,
|
||||
FastBlockLookupMainRAM,
|
||||
FastBlockLookupSWRAM,
|
||||
NULL,
|
||||
FastBlockLookupVRAM,
|
||||
FastBlockLookupARM7BIOS,
|
||||
FastBlockLookupARM7WRAM,
|
||||
NULL,
|
||||
NULL,
|
||||
FastBlockLookupARM7WVRAM,
|
||||
FastBlockLookupBIOS9DSi,
|
||||
FastBlockLookupBIOS7DSi,
|
||||
FastBlockLookupNWRAM_A,
|
||||
FastBlockLookupNWRAM_B,
|
||||
FastBlockLookupNWRAM_C
|
||||
};
|
||||
};
|
||||
void JitEnableWrite();
|
||||
void JitEnableExecute();
|
||||
}
|
||||
|
||||
// Defined in assembly
|
||||
extern "C" void ARM_Dispatch(melonDS::ARM* cpu, melonDS::JitBlockEntry entry);
|
||||
#else
|
||||
namespace melonDS
|
||||
{
|
||||
class ARM;
|
||||
|
||||
// This version is a stub; the methods all do nothing,
|
||||
// but there's still a Memory member.
|
||||
class ARMJIT
|
||||
{
|
||||
public:
|
||||
ARMJIT(melonDS::NDS& nds, std::optional<JITArgs>) noexcept : Memory(nds) {}
|
||||
~ARMJIT() noexcept {}
|
||||
void InvalidateByAddr(u32) noexcept {}
|
||||
void CheckAndInvalidateWVRAM(int) noexcept {}
|
||||
void CheckAndInvalidateITCM() noexcept {}
|
||||
void Reset() noexcept {}
|
||||
void JitEnableWrite() noexcept {}
|
||||
void JitEnableExecute() noexcept {}
|
||||
void CompileBlock(ARM*) noexcept {}
|
||||
void ResetBlockCache() noexcept {}
|
||||
template <u32, int>
|
||||
void CheckAndInvalidate(u32 addr) noexcept {}
|
||||
|
||||
ARMJIT_Memory Memory;
|
||||
};
|
||||
}
|
||||
#endif // JIT_ENABLED
|
||||
|
||||
#endif // ARMJIT_H
|
||||
extern "C" void ARM_Dispatch(ARM* cpu, ARMJIT::JitBlockEntry entry);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team, RSDuck
|
||||
Copyright 2016-2022 melonDS team, RSDuck
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -20,7 +20,7 @@
|
|||
|
||||
using namespace Arm64Gen;
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT
|
||||
{
|
||||
|
||||
void Compiler::Comp_RegShiftReg(int op, bool S, Op2& op2, ARM64Reg rs)
|
||||
|
|
@ -480,7 +480,7 @@ void Compiler::A_Comp_GetOp2(bool S, Op2& op2)
|
|||
Comp_AddCycles_C();
|
||||
|
||||
u32 shift = (CurInstr.Instr >> 7) & 0x1E;
|
||||
u32 imm = melonDS::ROR(CurInstr.Instr & 0xFF, shift);
|
||||
u32 imm = ::ROR(CurInstr.Instr & 0xFF, shift);
|
||||
|
||||
if (S && shift && (CurInstr.SetFlags & 0x2))
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team, RSDuck
|
||||
Copyright 2016-2022 melonDS team, RSDuck
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -17,14 +17,13 @@
|
|||
*/
|
||||
|
||||
#include "ARMJIT_Compiler.h"
|
||||
#include "../NDS.h"
|
||||
|
||||
using namespace Arm64Gen;
|
||||
|
||||
// hack
|
||||
const int kCodeCacheTiming = 3;
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT
|
||||
{
|
||||
|
||||
template <typename T>
|
||||
|
|
@ -83,7 +82,7 @@ void Compiler::Comp_JumpTo(u32 addr, bool forceNonConstantCycles)
|
|||
// doesn't matter if we put garbage in the MSbs there
|
||||
if (addr & 0x2)
|
||||
{
|
||||
cpu9->CodeRead32(addr-2, true);
|
||||
cpu9->CodeRead32(addr-2, true) >> 16;
|
||||
cycles += cpu9->CodeCycles;
|
||||
cpu9->CodeRead32(addr+2, false);
|
||||
cycles += CurCPU->CodeCycles;
|
||||
|
|
@ -133,7 +132,7 @@ void Compiler::Comp_JumpTo(u32 addr, bool forceNonConstantCycles)
|
|||
u32 compileTimePC = CurCPU->R[15];
|
||||
CurCPU->R[15] = newPC;
|
||||
|
||||
cycles += NDS.ARM7MemTimings[codeCycles][0] + NDS.ARM7MemTimings[codeCycles][1];
|
||||
cycles += NDS::ARM7MemTimings[codeCycles][0] + NDS::ARM7MemTimings[codeCycles][1];
|
||||
|
||||
CurCPU->R[15] = compileTimePC;
|
||||
}
|
||||
|
|
@ -145,7 +144,7 @@ void Compiler::Comp_JumpTo(u32 addr, bool forceNonConstantCycles)
|
|||
u32 compileTimePC = CurCPU->R[15];
|
||||
CurCPU->R[15] = newPC;
|
||||
|
||||
cycles += NDS.ARM7MemTimings[codeCycles][2] + NDS.ARM7MemTimings[codeCycles][3];
|
||||
cycles += NDS::ARM7MemTimings[codeCycles][2] + NDS::ARM7MemTimings[codeCycles][3];
|
||||
|
||||
CurCPU->R[15] = compileTimePC;
|
||||
}
|
||||
|
|
@ -236,7 +235,7 @@ void* Compiler::Gen_JumpTo7(int kind)
|
|||
LSR(W1, W0, 15);
|
||||
STR(INDEX_UNSIGNED, W1, RCPU, offsetof(ARM, CodeCycles));
|
||||
|
||||
MOVP2R(X2, NDS.ARM7MemTimings);
|
||||
MOVP2R(X2, NDS::ARM7MemTimings);
|
||||
LDR(W3, X2, ArithOption(W1, true));
|
||||
|
||||
FixupBranch switchToThumb;
|
||||
|
|
@ -389,7 +388,7 @@ void Compiler::T_Comp_BranchXchangeReg()
|
|||
{
|
||||
if (Num == 1)
|
||||
{
|
||||
Log(LogLevel::Warn, "BLX unsupported on ARM7!!!\n");
|
||||
printf("BLX unsupported on ARM7!!!\n");
|
||||
return;
|
||||
}
|
||||
MOV(W0, MapReg(CurInstr.A_Reg(3)));
|
||||
|
|
@ -437,4 +436,4 @@ void Compiler::T_Comp_BL_Merged()
|
|||
Comp_JumpTo(target);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team, RSDuck
|
||||
Copyright 2016-2022 melonDS team, RSDuck
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -20,9 +20,15 @@
|
|||
|
||||
#include "../ARMJIT_Internal.h"
|
||||
#include "../ARMInterpreter.h"
|
||||
#include "../ARMJIT.h"
|
||||
#include "../NDS.h"
|
||||
#include "../ARMJIT_Global.h"
|
||||
|
||||
#ifdef __SWITCH__
|
||||
#include <switch.h>
|
||||
|
||||
extern char __start__;
|
||||
#else
|
||||
#include <sys/mman.h>
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
|
|
@ -30,7 +36,7 @@ using namespace Arm64Gen;
|
|||
|
||||
extern "C" void ARM_Ret();
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT
|
||||
{
|
||||
|
||||
/*
|
||||
|
|
@ -56,6 +62,11 @@ const int RegisterCache<Compiler, ARM64Reg>::NativeRegsAvailable = 15;
|
|||
|
||||
const BitSet32 CallerSavedPushRegs({W8, W9, W10, W11, W12, W13, W14, W15});
|
||||
|
||||
const int JitMemSize = 16 * 1024 * 1024;
|
||||
#ifndef __SWITCH__
|
||||
u8 JitMem[JitMemSize];
|
||||
#endif
|
||||
|
||||
void Compiler::MovePC()
|
||||
{
|
||||
ADD(MapReg(15), MapReg(15), Thumb ? 2 : 4);
|
||||
|
|
@ -92,7 +103,7 @@ void Compiler::A_Comp_MSR()
|
|||
if (CurInstr.Instr & (1 << 25))
|
||||
{
|
||||
val = W0;
|
||||
MOVI2R(val, melonDS::ROR((CurInstr.Instr & 0xFF), ((CurInstr.Instr >> 7) & 0x1E)));
|
||||
MOVI2R(val, ::ROR((CurInstr.Instr & 0xFF), ((CurInstr.Instr >> 7) & 0x1E)));
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -206,7 +217,7 @@ void Compiler::PopRegs(bool saveHiRegs, bool saveRegsToBeChanged)
|
|||
}
|
||||
}
|
||||
|
||||
Compiler::Compiler(melonDS::NDS& nds) : Arm64Gen::ARM64XEmitter(), NDS(nds)
|
||||
Compiler::Compiler()
|
||||
{
|
||||
#ifdef __SWITCH__
|
||||
JitRWBase = aligned_alloc(0x1000, JitMemSize);
|
||||
|
|
@ -226,7 +237,7 @@ Compiler::Compiler(melonDS::NDS& nds) : Arm64Gen::ARM64XEmitter(), NDS(nds)
|
|||
break;
|
||||
if (i++ > 8)
|
||||
{
|
||||
Log(LogLevel::Error, "couldn't find unmapped place for jit memory\n");
|
||||
printf("couldn't find unmapped place for jit memory\n");
|
||||
JitRXStart = NULL;
|
||||
}
|
||||
}
|
||||
|
|
@ -245,13 +256,18 @@ Compiler::Compiler(melonDS::NDS& nds) : Arm64Gen::ARM64XEmitter(), NDS(nds)
|
|||
SetCodeBase((u8*)JitRWStart, (u8*)JitRXStart);
|
||||
JitMemMainSize = JitMemSize;
|
||||
#else
|
||||
ARMJIT_Global::Init();
|
||||
u64 pageSize = sysconf(_SC_PAGE_SIZE);
|
||||
u8* pageAligned = (u8*)(((u64)JitMem & ~(pageSize - 1)) + pageSize);
|
||||
u64 alignedSize = (((u64)JitMem + sizeof(JitMem)) & ~(pageSize - 1)) - (u64)pageAligned;
|
||||
#ifdef __APPLE__
|
||||
pageAligned = (u8*)mmap(NULL, 1024*1024*16, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS | MAP_JIT,-1, 0);
|
||||
JitEnableWrite();
|
||||
#else
|
||||
mprotect(pageAligned, alignedSize, PROT_EXEC | PROT_READ | PROT_WRITE);
|
||||
#endif
|
||||
|
||||
CodeMemBase = ARMJIT_Global::AllocateCodeMem();
|
||||
nds.JIT.JitEnableWrite();
|
||||
|
||||
SetCodeBase(reinterpret_cast<u8*>(CodeMemBase), reinterpret_cast<u8*>(CodeMemBase));
|
||||
JitMemMainSize = ARMJIT_Global::CodeMemorySliceSize;
|
||||
SetCodeBase(pageAligned, pageAligned);
|
||||
JitMemMainSize = alignedSize;
|
||||
#endif
|
||||
SetCodePtr(0);
|
||||
|
||||
|
|
@ -462,9 +478,6 @@ Compiler::~Compiler()
|
|||
free(JitRWBase);
|
||||
}
|
||||
#endif
|
||||
|
||||
ARMJIT_Global::FreeCodeMem(CodeMemBase);
|
||||
ARMJIT_Global::DeInit();
|
||||
}
|
||||
|
||||
void Compiler::LoadCycles()
|
||||
|
|
@ -677,13 +690,13 @@ JitBlockEntry Compiler::CompileBlock(ARM* cpu, bool thumb, FetchedInstr instrs[]
|
|||
{
|
||||
if (JitMemMainSize - GetCodeOffset() < 1024 * 16)
|
||||
{
|
||||
Log(LogLevel::Debug, "JIT near memory full, resetting...\n");
|
||||
NDS.JIT.ResetBlockCache();
|
||||
printf("JIT near memory full, resetting...\n");
|
||||
ResetBlockCache();
|
||||
}
|
||||
if ((JitMemMainSize + JitMemSecondarySize) - OtherCodeRegion < 1024 * 8)
|
||||
{
|
||||
Log(LogLevel::Debug, "JIT far memory full, resetting...\n");
|
||||
NDS.JIT.ResetBlockCache();
|
||||
printf("JIT far memory full, resetting...\n");
|
||||
ResetBlockCache();
|
||||
}
|
||||
|
||||
JitBlockEntry res = (JitBlockEntry)GetRXPtr();
|
||||
|
|
@ -696,7 +709,7 @@ JitBlockEntry Compiler::CompileBlock(ARM* cpu, bool thumb, FetchedInstr instrs[]
|
|||
CPSRDirty = false;
|
||||
|
||||
if (hasMemInstr)
|
||||
MOVP2R(RMemBase, Num == 0 ? NDS.JIT.Memory.FastMem9Start : NDS.JIT.Memory.FastMem7Start);
|
||||
MOVP2R(RMemBase, Num == 0 ? ARMJIT_Memory::FastMem9Start : ARMJIT_Memory::FastMem7Start);
|
||||
|
||||
for (int i = 0; i < instrsCount; i++)
|
||||
{
|
||||
|
|
@ -844,7 +857,7 @@ void Compiler::Reset()
|
|||
void Compiler::Comp_AddCycles_C(bool forceNonConstant)
|
||||
{
|
||||
s32 cycles = Num ?
|
||||
NDS.ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 1 : 3]
|
||||
NDS::ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 1 : 3]
|
||||
: ((R15 & 0x2) ? 0 : CurInstr.CodeCycles);
|
||||
|
||||
if (forceNonConstant)
|
||||
|
|
@ -858,7 +871,7 @@ void Compiler::Comp_AddCycles_CI(u32 numI)
|
|||
IrregularCycles = true;
|
||||
|
||||
s32 cycles = (Num ?
|
||||
NDS.ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2]
|
||||
NDS::ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2]
|
||||
: ((R15 & 0x2) ? 0 : CurInstr.CodeCycles)) + numI;
|
||||
|
||||
if (Thumb || CurInstr.Cond() == 0xE)
|
||||
|
|
@ -872,7 +885,7 @@ void Compiler::Comp_AddCycles_CI(u32 c, ARM64Reg numI, ArithOption shift)
|
|||
IrregularCycles = true;
|
||||
|
||||
s32 cycles = (Num ?
|
||||
NDS.ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2]
|
||||
NDS::ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2]
|
||||
: ((R15 & 0x2) ? 0 : CurInstr.CodeCycles)) + c;
|
||||
|
||||
ADD(RCycles, RCycles, cycles);
|
||||
|
|
@ -892,7 +905,7 @@ void Compiler::Comp_AddCycles_CDI()
|
|||
|
||||
s32 cycles;
|
||||
|
||||
s32 numC = NDS.ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2];
|
||||
s32 numC = NDS::ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2];
|
||||
s32 numD = CurInstr.DataCycles;
|
||||
|
||||
if ((CurInstr.DataRegion >> 24) == 0x02) // mainRAM
|
||||
|
|
@ -937,7 +950,7 @@ void Compiler::Comp_AddCycles_CD()
|
|||
}
|
||||
else
|
||||
{
|
||||
s32 numC = NDS.ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2];
|
||||
s32 numC = NDS::ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2];
|
||||
s32 numD = CurInstr.DataCycles;
|
||||
|
||||
if ((CurInstr.DataRegion >> 24) == 0x02)
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team, RSDuck
|
||||
Copyright 2016-2022 melonDS team, RSDuck
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,9 +19,8 @@
|
|||
#ifndef ARMJIT_A64_COMPILER_H
|
||||
#define ARMJIT_A64_COMPILER_H
|
||||
|
||||
#if defined(JIT_ENABLED) && defined(__aarch64__)
|
||||
|
||||
#include "../ARM.h"
|
||||
#include "../ARMJIT.h"
|
||||
|
||||
#include "../dolphin/Arm64Emitter.h"
|
||||
|
||||
|
|
@ -30,9 +29,9 @@
|
|||
|
||||
#include <unordered_map>
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT
|
||||
{
|
||||
class ARMJIT;
|
||||
|
||||
const Arm64Gen::ARM64Reg RMemBase = Arm64Gen::X26;
|
||||
const Arm64Gen::ARM64Reg RCPSR = Arm64Gen::W27;
|
||||
const Arm64Gen::ARM64Reg RCycles = Arm64Gen::W28;
|
||||
|
|
@ -69,7 +68,7 @@ struct Op2
|
|||
bool IsSimpleReg()
|
||||
{ return !IsImm && !Reg.ShiftAmount && Reg.ShiftType == Arm64Gen::ST_LSL; }
|
||||
bool ImmFits12Bit()
|
||||
{ return IsImm && ((Imm & 0xFFF) == Imm); }
|
||||
{ return IsImm && (Imm & 0xFFF == Imm); }
|
||||
bool IsZero()
|
||||
{ return IsImm && !Imm; }
|
||||
|
||||
|
|
@ -98,8 +97,8 @@ class Compiler : public Arm64Gen::ARM64XEmitter
|
|||
public:
|
||||
typedef void (Compiler::*CompileFunc)();
|
||||
|
||||
explicit Compiler(melonDS::NDS& nds);
|
||||
~Compiler() override;
|
||||
Compiler();
|
||||
~Compiler();
|
||||
|
||||
void PushRegs(bool saveHiRegs, bool saveRegsToBeChanged, bool allowUnload = true);
|
||||
void PopRegs(bool saveHiRegs, bool saveRegsToBeChanged);
|
||||
|
|
@ -114,7 +113,7 @@ public:
|
|||
|
||||
bool CanCompile(bool thumb, u16 kind);
|
||||
|
||||
bool FlagsNZNeeded() const
|
||||
bool FlagsNZNeeded()
|
||||
{
|
||||
return CurInstr.SetFlags & 0xC;
|
||||
}
|
||||
|
|
@ -234,7 +233,7 @@ public:
|
|||
return (u8*)entry - GetRXBase();
|
||||
}
|
||||
|
||||
bool IsJITFault(const u8* pc);
|
||||
bool IsJITFault(u8* pc);
|
||||
u8* RewriteMemAccess(u8* pc);
|
||||
|
||||
void SwapCodeRegion()
|
||||
|
|
@ -244,7 +243,6 @@ public:
|
|||
OtherCodeRegion = offset;
|
||||
}
|
||||
|
||||
melonDS::NDS& NDS;
|
||||
ptrdiff_t OtherCodeRegion;
|
||||
|
||||
bool Exit;
|
||||
|
|
@ -275,7 +273,6 @@ public:
|
|||
void* JitRWStart;
|
||||
void* JitRXStart;
|
||||
#endif
|
||||
void* CodeMemBase;
|
||||
|
||||
void* ReadBanked, *WriteBanked;
|
||||
|
||||
|
|
@ -290,5 +287,3 @@ public:
|
|||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team, RSDuck
|
||||
Copyright 2016-2022 melonDS team, RSDuck
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -94,8 +94,3 @@ ARM_RestoreContext:
|
|||
mov sp, x17
|
||||
|
||||
br x18
|
||||
|
||||
#if !defined(__APPLE__) && !defined(__WIN32__)
|
||||
.section .note.GNU-stack,"",@progbits
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team, RSDuck
|
||||
Copyright 2016-2022 melonDS team, RSDuck
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -21,14 +21,13 @@
|
|||
#include "../ARMJIT.h"
|
||||
|
||||
#include "../ARMJIT_Memory.h"
|
||||
#include "../NDS.h"
|
||||
|
||||
using namespace Arm64Gen;
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT
|
||||
{
|
||||
|
||||
bool Compiler::IsJITFault(const u8* pc)
|
||||
bool Compiler::IsJITFault(u8* pc)
|
||||
{
|
||||
return (u64)pc >= (u64)GetRXBase() && (u64)pc - (u64)GetRXBase() < (JitMemMainSize + JitMemSecondarySize);
|
||||
}
|
||||
|
|
@ -57,15 +56,15 @@ u8* Compiler::RewriteMemAccess(u8* pc)
|
|||
|
||||
return pc + (ptrdiff_t)patch.PatchOffset;
|
||||
}
|
||||
Log(LogLevel::Error, "this is a JIT bug! %08x\n", __builtin_bswap32(*(u32*)pc));
|
||||
printf("this is a JIT bug! %08x\n", __builtin_bswap32(*(u32*)pc));
|
||||
abort();
|
||||
}
|
||||
|
||||
bool Compiler::Comp_MemLoadLiteral(int size, bool signExtend, int rd, u32 addr)
|
||||
{
|
||||
u32 localAddr = NDS.JIT.LocaliseCodeAddress(Num, addr);
|
||||
u32 localAddr = LocaliseCodeAddress(Num, addr);
|
||||
|
||||
int invalidLiteralIdx = NDS.JIT.InvalidLiterals.Find(localAddr);
|
||||
int invalidLiteralIdx = InvalidLiterals.Find(localAddr);
|
||||
if (invalidLiteralIdx != -1)
|
||||
{
|
||||
return false;
|
||||
|
|
@ -80,7 +79,7 @@ bool Compiler::Comp_MemLoadLiteral(int size, bool signExtend, int rd, u32 addr)
|
|||
if (size == 32)
|
||||
{
|
||||
CurCPU->DataRead32(addr & ~0x3, &val);
|
||||
val = melonDS::ROR(val, (addr & 0x3) << 3);
|
||||
val = ::ROR(val, (addr & 0x3) << 3);
|
||||
}
|
||||
else if (size == 16)
|
||||
{
|
||||
|
|
@ -112,7 +111,7 @@ void Compiler::Comp_MemAccess(int rd, int rn, Op2 offset, int size, int flags)
|
|||
if (size == 16)
|
||||
addressMask = ~1;
|
||||
|
||||
if (NDS.JIT.LiteralOptimizationsEnabled() && rn == 15 && rd != 15 && offset.IsImm && !(flags & (memop_Post|memop_Store|memop_Writeback)))
|
||||
if (ARMJIT::LiteralOptimizations && rn == 15 && rd != 15 && offset.IsImm && !(flags & (memop_Post|memop_Store|memop_Writeback)))
|
||||
{
|
||||
u32 addr = R15 + offset.Imm * ((flags & memop_SubtractOffset) ? -1 : 1);
|
||||
|
||||
|
|
@ -147,7 +146,7 @@ void Compiler::Comp_MemAccess(int rd, int rn, Op2 offset, int size, int flags)
|
|||
MOV(W0, rnMapped);
|
||||
}
|
||||
|
||||
bool addrIsStatic = NDS.JIT.LiteralOptimizationsEnabled()
|
||||
bool addrIsStatic = ARMJIT::LiteralOptimizations
|
||||
&& RegCache.IsLiteral(rn) && offset.IsImm && !(flags & (memop_Writeback|memop_Post));
|
||||
u32 staticAddress;
|
||||
if (addrIsStatic)
|
||||
|
|
@ -186,18 +185,18 @@ void Compiler::Comp_MemAccess(int rd, int rn, Op2 offset, int size, int flags)
|
|||
MOV(rnMapped, W0);
|
||||
|
||||
u32 expectedTarget = Num == 0
|
||||
? NDS.JIT.Memory.ClassifyAddress9(addrIsStatic ? staticAddress : CurInstr.DataRegion)
|
||||
: NDS.JIT.Memory.ClassifyAddress7(addrIsStatic ? staticAddress : CurInstr.DataRegion);
|
||||
? ARMJIT_Memory::ClassifyAddress9(addrIsStatic ? staticAddress : CurInstr.DataRegion)
|
||||
: ARMJIT_Memory::ClassifyAddress7(addrIsStatic ? staticAddress : CurInstr.DataRegion);
|
||||
|
||||
if (NDS.JIT.FastMemoryEnabled() && ((!Thumb && CurInstr.Cond() != 0xE) || NDS.JIT.Memory.IsFastmemCompatible(expectedTarget)))
|
||||
if (ARMJIT::FastMemory && ((!Thumb && CurInstr.Cond() != 0xE) || ARMJIT_Memory::IsFastmemCompatible(expectedTarget)))
|
||||
{
|
||||
ptrdiff_t memopStart = GetCodeOffset();
|
||||
LoadStorePatch patch;
|
||||
|
||||
assert((rdMapped >= W8 && rdMapped <= W15) || (rdMapped >= W19 && rdMapped <= W25) || rdMapped == W4);
|
||||
patch.PatchFunc = flags & memop_Store
|
||||
? PatchedStoreFuncs[NDS.ConsoleType][Num][__builtin_ctz(size) - 3][rdMapped]
|
||||
: PatchedLoadFuncs[NDS.ConsoleType][Num][__builtin_ctz(size) - 3][!!(flags & memop_SignExtend)][rdMapped];
|
||||
? PatchedStoreFuncs[NDS::ConsoleType][Num][__builtin_ctz(size) - 3][rdMapped]
|
||||
: PatchedLoadFuncs[NDS::ConsoleType][Num][__builtin_ctz(size) - 3][!!(flags & memop_SignExtend)][rdMapped];
|
||||
|
||||
// take a chance at fastmem
|
||||
if (size > 8)
|
||||
|
|
@ -226,7 +225,7 @@ void Compiler::Comp_MemAccess(int rd, int rn, Op2 offset, int size, int flags)
|
|||
{
|
||||
void* func = NULL;
|
||||
if (addrIsStatic)
|
||||
func = NDS.JIT.Memory.GetFuncForAddr(CurCPU, staticAddress, flags & memop_Store, size);
|
||||
func = ARMJIT_Memory::GetFuncForAddr(CurCPU, staticAddress, flags & memop_Store, size);
|
||||
|
||||
PushRegs(false, false);
|
||||
|
||||
|
|
@ -264,7 +263,7 @@ void Compiler::Comp_MemAccess(int rd, int rn, Op2 offset, int size, int flags)
|
|||
if (flags & memop_Store)
|
||||
{
|
||||
MOV(W2, rdMapped);
|
||||
switch (size | NDS.ConsoleType)
|
||||
switch (size | NDS::ConsoleType)
|
||||
{
|
||||
case 32: QuickCallFunction(X3, SlowWrite9<u32, 0>); break;
|
||||
case 33: QuickCallFunction(X3, SlowWrite9<u32, 1>); break;
|
||||
|
|
@ -276,7 +275,7 @@ void Compiler::Comp_MemAccess(int rd, int rn, Op2 offset, int size, int flags)
|
|||
}
|
||||
else
|
||||
{
|
||||
switch (size | NDS.ConsoleType)
|
||||
switch (size | NDS::ConsoleType)
|
||||
{
|
||||
case 32: QuickCallFunction(X3, SlowRead9<u32, 0>); break;
|
||||
case 33: QuickCallFunction(X3, SlowRead9<u32, 1>); break;
|
||||
|
|
@ -292,7 +291,7 @@ void Compiler::Comp_MemAccess(int rd, int rn, Op2 offset, int size, int flags)
|
|||
if (flags & memop_Store)
|
||||
{
|
||||
MOV(W1, rdMapped);
|
||||
switch (size | NDS.ConsoleType)
|
||||
switch (size | NDS::ConsoleType)
|
||||
{
|
||||
case 32: QuickCallFunction(X3, SlowWrite7<u32, 0>); break;
|
||||
case 33: QuickCallFunction(X3, SlowWrite7<u32, 1>); break;
|
||||
|
|
@ -304,7 +303,7 @@ void Compiler::Comp_MemAccess(int rd, int rn, Op2 offset, int size, int flags)
|
|||
}
|
||||
else
|
||||
{
|
||||
switch (size | NDS.ConsoleType)
|
||||
switch (size | NDS::ConsoleType)
|
||||
{
|
||||
case 32: QuickCallFunction(X3, SlowRead7<u32, 0>); break;
|
||||
case 33: QuickCallFunction(X3, SlowRead7<u32, 1>); break;
|
||||
|
|
@ -333,7 +332,7 @@ void Compiler::Comp_MemAccess(int rd, int rn, Op2 offset, int size, int flags)
|
|||
if (CurInstr.Info.Branches())
|
||||
{
|
||||
if (size < 32)
|
||||
Log(LogLevel::Debug, "LDR size < 32 branching?\n");
|
||||
printf("LDR size < 32 branching?\n");
|
||||
Comp_JumpTo(rdMapped, Num == 0, false);
|
||||
}
|
||||
}
|
||||
|
|
@ -453,7 +452,7 @@ void Compiler::T_Comp_LoadPCRel()
|
|||
u32 offset = ((CurInstr.Instr & 0xFF) << 2);
|
||||
u32 addr = (R15 & ~0x2) + offset;
|
||||
|
||||
if (!NDS.JIT.LiteralOptimizationsEnabled() || !Comp_MemLoadLiteral(32, false, CurInstr.T_Reg(8), addr))
|
||||
if (!ARMJIT::LiteralOptimizations || !Comp_MemLoadLiteral(32, false, CurInstr.T_Reg(8), addr))
|
||||
Comp_MemAccess(CurInstr.T_Reg(8), 15, Op2(offset), 32, 0);
|
||||
}
|
||||
|
||||
|
|
@ -495,11 +494,11 @@ s32 Compiler::Comp_MemAccessBlock(int rn, BitSet16 regs, bool store, bool preinc
|
|||
Comp_AddCycles_CDI();
|
||||
|
||||
int expectedTarget = Num == 0
|
||||
? NDS.JIT.Memory.ClassifyAddress9(CurInstr.DataRegion)
|
||||
: NDS.JIT.Memory.ClassifyAddress7(CurInstr.DataRegion);
|
||||
? ARMJIT_Memory::ClassifyAddress9(CurInstr.DataRegion)
|
||||
: ARMJIT_Memory::ClassifyAddress7(CurInstr.DataRegion);
|
||||
|
||||
bool compileFastPath = NDS.JIT.FastMemoryEnabled()
|
||||
&& store && !usermode && (CurInstr.Cond() < 0xE || NDS.JIT.Memory.IsFastmemCompatible(expectedTarget));
|
||||
bool compileFastPath = ARMJIT::FastMemory
|
||||
&& store && !usermode && (CurInstr.Cond() < 0xE || ARMJIT_Memory::IsFastmemCompatible(expectedTarget));
|
||||
|
||||
{
|
||||
s32 offset = decrement
|
||||
|
|
@ -681,7 +680,7 @@ s32 Compiler::Comp_MemAccessBlock(int rn, BitSet16 regs, bool store, bool preinc
|
|||
if (Num == 0)
|
||||
{
|
||||
MOV(X3, RCPU);
|
||||
switch ((u32)store * 2 | NDS.ConsoleType)
|
||||
switch ((u32)store * 2 | NDS::ConsoleType)
|
||||
{
|
||||
case 0: QuickCallFunction(X4, SlowBlockTransfer9<false, 0>); break;
|
||||
case 1: QuickCallFunction(X4, SlowBlockTransfer9<false, 1>); break;
|
||||
|
|
@ -691,7 +690,7 @@ s32 Compiler::Comp_MemAccessBlock(int rn, BitSet16 regs, bool store, bool preinc
|
|||
}
|
||||
else
|
||||
{
|
||||
switch ((u32)store * 2 | NDS.ConsoleType)
|
||||
switch ((u32)store * 2 | NDS::ConsoleType)
|
||||
{
|
||||
case 0: QuickCallFunction(X4, SlowBlockTransfer7<false, 0>); break;
|
||||
case 1: QuickCallFunction(X4, SlowBlockTransfer7<false, 1>); break;
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team, RSDuck
|
||||
Copyright 2016-2022 melonDS team, RSDuck
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,8 +19,6 @@
|
|||
#ifndef ARMJIT_COMPILER_H
|
||||
#define ARMJIT_COMPILER_H
|
||||
|
||||
#ifdef JIT_ENABLED
|
||||
|
||||
#if defined(__x86_64__)
|
||||
#include "ARMJIT_x64/ARMJIT_Compiler.h"
|
||||
#elif defined(__aarch64__)
|
||||
|
|
@ -29,6 +27,9 @@
|
|||
#error "The current target platform doesn't have a JIT backend"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
namespace ARMJIT
|
||||
{
|
||||
extern Compiler* JITCompiler;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,126 +0,0 @@
|
|||
#include "ARMJIT_Global.h"
|
||||
#include "ARMJIT_Memory.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <sys/mman.h>
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include <mutex>
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
|
||||
namespace ARMJIT_Global
|
||||
{
|
||||
|
||||
std::mutex globalMutex;
|
||||
|
||||
#if defined(__APPLE__) && defined(__aarch64__)
|
||||
#define APPLE_AARCH64
|
||||
#endif
|
||||
|
||||
#ifndef APPLE_AARCH64
|
||||
static constexpr size_t NumCodeMemSlices = 4;
|
||||
static constexpr size_t CodeMemoryAlignedSize = NumCodeMemSlices * CodeMemorySliceSize;
|
||||
|
||||
// I haven't heard of pages larger than 16 KB
|
||||
u8 CodeMemory[CodeMemoryAlignedSize + 16*1024];
|
||||
|
||||
u32 AvailableCodeMemSlices = (1 << NumCodeMemSlices) - 1;
|
||||
|
||||
u8* GetAlignedCodeMemoryStart()
|
||||
{
|
||||
return reinterpret_cast<u8*>((reinterpret_cast<intptr_t>(CodeMemory) + (16*1024-1)) & ~static_cast<intptr_t>(16*1024-1));
|
||||
}
|
||||
#endif
|
||||
|
||||
int RefCounter = 0;
|
||||
|
||||
void* AllocateCodeMem()
|
||||
{
|
||||
std::lock_guard guard(globalMutex);
|
||||
|
||||
#ifndef APPLE_AARCH64
|
||||
if (AvailableCodeMemSlices)
|
||||
{
|
||||
int slice = __builtin_ctz(AvailableCodeMemSlices);
|
||||
AvailableCodeMemSlices &= ~(1 << slice);
|
||||
//printf("allocating slice %d\n", slice);
|
||||
return &GetAlignedCodeMemoryStart()[slice * CodeMemorySliceSize];
|
||||
}
|
||||
#endif
|
||||
|
||||
// allocate
|
||||
#ifdef _WIN32
|
||||
return VirtualAlloc(nullptr, CodeMemorySliceSize, MEM_RESERVE|MEM_COMMIT, PAGE_EXECUTE_READWRITE);
|
||||
#elif defined(APPLE_AARCH64)
|
||||
return mmap(NULL, CodeMemorySliceSize, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS | MAP_JIT,-1, 0);
|
||||
#else
|
||||
//printf("mmaping...\n");
|
||||
return mmap(nullptr, CodeMemorySliceSize, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
void FreeCodeMem(void* codeMem)
|
||||
{
|
||||
std::lock_guard guard(globalMutex);
|
||||
|
||||
#ifndef APPLE_AARCH64
|
||||
for (int i = 0; i < NumCodeMemSlices; i++)
|
||||
{
|
||||
if (codeMem == &GetAlignedCodeMemoryStart()[CodeMemorySliceSize * i])
|
||||
{
|
||||
//printf("freeing slice\n");
|
||||
AvailableCodeMemSlices |= 1 << i;
|
||||
return;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
VirtualFree(codeMem, CodeMemorySliceSize, MEM_RELEASE|MEM_DECOMMIT);
|
||||
#else
|
||||
munmap(codeMem, CodeMemorySliceSize);
|
||||
#endif
|
||||
}
|
||||
|
||||
void Init()
|
||||
{
|
||||
std::lock_guard guard(globalMutex);
|
||||
|
||||
RefCounter++;
|
||||
if (RefCounter == 1)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
DWORD dummy;
|
||||
VirtualProtect(GetAlignedCodeMemoryStart(), CodeMemoryAlignedSize, PAGE_EXECUTE_READWRITE, &dummy);
|
||||
#elif defined(APPLE_AARCH64)
|
||||
// Apple aarch64 always uses dynamic allocation
|
||||
#else
|
||||
mprotect(GetAlignedCodeMemoryStart(), CodeMemoryAlignedSize, PROT_EXEC | PROT_READ | PROT_WRITE);
|
||||
#endif
|
||||
|
||||
ARMJIT_Memory::RegisterFaultHandler();
|
||||
}
|
||||
}
|
||||
|
||||
void DeInit()
|
||||
{
|
||||
std::lock_guard guard(globalMutex);
|
||||
|
||||
RefCounter--;
|
||||
if (RefCounter == 0)
|
||||
{
|
||||
ARMJIT_Memory::UnregisterFaultHandler();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team, RSDuck
|
||||
Copyright 2016-2022 melonDS team, RSDuck
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -24,17 +24,13 @@
|
|||
#include <string.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "ARM_InstrInfo.h"
|
||||
#include "JitBlock.h"
|
||||
#include "TinyVector.h"
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
class ARM;
|
||||
class ARMv5;
|
||||
#include "ARMJIT.h"
|
||||
#include "ARMJIT_Memory.h"
|
||||
|
||||
// here lands everything which doesn't fit into ARMJIT.h
|
||||
// where it would be included by pretty much everything
|
||||
namespace ARMJIT
|
||||
{
|
||||
|
||||
enum
|
||||
{
|
||||
|
|
@ -73,6 +69,139 @@ struct FetchedInstr
|
|||
ARMInstrInfo::Info Info;
|
||||
};
|
||||
|
||||
/*
|
||||
TinyVector
|
||||
- because reinventing the wheel is the best!
|
||||
|
||||
- meant to be used very often, with not so many elements
|
||||
max 1 << 16 elements
|
||||
- doesn't allocate while no elements are inserted
|
||||
- not stl confirmant of course
|
||||
- probably only works with POD types
|
||||
- remove operations don't preserve order, but O(1)!
|
||||
*/
|
||||
template <typename T>
|
||||
struct __attribute__((packed)) TinyVector
|
||||
{
|
||||
T* Data = NULL;
|
||||
u16 Capacity = 0;
|
||||
u16 Length = 0;
|
||||
|
||||
~TinyVector()
|
||||
{
|
||||
delete[] Data;
|
||||
}
|
||||
|
||||
void MakeCapacity(u32 capacity)
|
||||
{
|
||||
assert(capacity <= UINT16_MAX);
|
||||
assert(capacity > Capacity);
|
||||
T* newMem = new T[capacity];
|
||||
if (Data != NULL)
|
||||
memcpy(newMem, Data, sizeof(T) * Length);
|
||||
|
||||
T* oldData = Data;
|
||||
Data = newMem;
|
||||
if (oldData != NULL)
|
||||
delete[] oldData;
|
||||
|
||||
Capacity = capacity;
|
||||
}
|
||||
|
||||
void SetLength(u16 length)
|
||||
{
|
||||
if (Capacity < length)
|
||||
MakeCapacity(length);
|
||||
|
||||
Length = length;
|
||||
}
|
||||
|
||||
void Clear()
|
||||
{
|
||||
Length = 0;
|
||||
}
|
||||
|
||||
void Add(T element)
|
||||
{
|
||||
assert(Length + 1 <= UINT16_MAX);
|
||||
if (Length + 1 > Capacity)
|
||||
MakeCapacity(((Capacity + 4) * 3) / 2);
|
||||
|
||||
Data[Length++] = element;
|
||||
}
|
||||
|
||||
void Remove(int index)
|
||||
{
|
||||
assert(Length > 0);
|
||||
assert(index >= 0 && index < Length);
|
||||
|
||||
Length--;
|
||||
Data[index] = Data[Length];
|
||||
/*for (int i = index; i < Length; i++)
|
||||
Data[i] = Data[i + 1];*/
|
||||
}
|
||||
|
||||
int Find(T needle)
|
||||
{
|
||||
for (int i = 0; i < Length; i++)
|
||||
{
|
||||
if (Data[i] == needle)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
bool RemoveByValue(T needle)
|
||||
{
|
||||
for (int i = 0; i < Length; i++)
|
||||
{
|
||||
if (Data[i] == needle)
|
||||
{
|
||||
Remove(i);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
T& operator[](int index)
|
||||
{
|
||||
assert(index >= 0 && index < Length);
|
||||
return Data[index];
|
||||
}
|
||||
};
|
||||
|
||||
class JitBlock
|
||||
{
|
||||
public:
|
||||
JitBlock(u32 num, u32 literalHash, u32 numAddresses, u32 numLiterals)
|
||||
{
|
||||
Num = num;
|
||||
NumAddresses = numAddresses;
|
||||
NumLiterals = numLiterals;
|
||||
Data.SetLength(numAddresses * 2 + numLiterals);
|
||||
}
|
||||
|
||||
u32 StartAddr;
|
||||
u32 StartAddrLocal;
|
||||
u32 InstrHash, LiteralHash;
|
||||
u8 Num;
|
||||
u16 NumAddresses;
|
||||
u16 NumLiterals;
|
||||
|
||||
JitBlockEntry EntryPoint;
|
||||
|
||||
u32* AddressRanges()
|
||||
{ return &Data[0]; }
|
||||
u32* AddressMasks()
|
||||
{ return &Data[NumAddresses]; }
|
||||
u32* Literals()
|
||||
{ return &Data[NumAddresses * 2]; }
|
||||
|
||||
private:
|
||||
TinyVector<u32> Data;
|
||||
};
|
||||
|
||||
// size should be 16 bytes because I'm to lazy to use mul and whatnot
|
||||
struct __attribute__((packed)) AddressRange
|
||||
{
|
||||
|
|
@ -85,9 +214,13 @@ typedef void (*InterpreterFunc)(ARM* cpu);
|
|||
extern InterpreterFunc InterpretARM[];
|
||||
extern InterpreterFunc InterpretTHUMB[];
|
||||
|
||||
inline bool PageContainsCode(const AddressRange* range, u32 pageSize)
|
||||
extern TinyVector<u32> InvalidLiterals;
|
||||
|
||||
extern AddressRange* const CodeMemRegions[ARMJIT_Memory::memregions_Count];
|
||||
|
||||
inline bool PageContainsCode(AddressRange* range)
|
||||
{
|
||||
for (int i = 0; i < pageSize / 512; i++)
|
||||
for (int i = 0; i < 8; i++)
|
||||
{
|
||||
if (range[i].Blocks.Length > 0)
|
||||
return true;
|
||||
|
|
@ -95,6 +228,11 @@ inline bool PageContainsCode(const AddressRange* range, u32 pageSize)
|
|||
return false;
|
||||
}
|
||||
|
||||
u32 LocaliseCodeAddress(u32 num, u32 addr);
|
||||
|
||||
template <u32 Num>
|
||||
void LinkBlock(ARM* cpu, u32 codeOffset);
|
||||
|
||||
template <typename T, int ConsoleType> T SlowRead9(u32 addr, ARMv5* cpu);
|
||||
template <typename T, int ConsoleType> void SlowWrite9(u32 addr, ARMv5* cpu, u32 val);
|
||||
template <typename T, int ConsoleType> T SlowRead7(u32 addr);
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -20,225 +20,62 @@
|
|||
#define ARMJIT_MEMORY
|
||||
|
||||
#include "types.h"
|
||||
#include "MemConstants.h"
|
||||
|
||||
#ifdef JIT_ENABLED
|
||||
# include <mutex>
|
||||
# include "TinyVector.h"
|
||||
# include "ARM.h"
|
||||
# if defined(__SWITCH__)
|
||||
# include <switch.h>
|
||||
# elif defined(_WIN32)
|
||||
#include <windows.h>
|
||||
# else
|
||||
# include <sys/mman.h>
|
||||
# include <sys/stat.h>
|
||||
# include <fcntl.h>
|
||||
# include <unistd.h>
|
||||
# include <signal.h>
|
||||
# endif
|
||||
#else
|
||||
# include <array>
|
||||
#endif
|
||||
#include "ARM.h"
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT_Memory
|
||||
{
|
||||
#ifdef JIT_ENABLED
|
||||
namespace Platform { struct DynamicLibrary; }
|
||||
class Compiler;
|
||||
class ARMJIT;
|
||||
#endif
|
||||
|
||||
static constexpr u32 LargePageSize = 0x4000;
|
||||
static constexpr u32 RegularPageSize = 0x1000;
|
||||
extern void* FastMem9Start;
|
||||
extern void* FastMem7Start;
|
||||
|
||||
constexpr u32 RoundUp(u32 size) noexcept
|
||||
void Init();
|
||||
void DeInit();
|
||||
|
||||
void Reset();
|
||||
|
||||
enum
|
||||
{
|
||||
return (size + LargePageSize - 1) & ~(LargePageSize - 1);
|
||||
}
|
||||
memregion_Other = 0,
|
||||
memregion_ITCM,
|
||||
memregion_DTCM,
|
||||
memregion_BIOS9,
|
||||
memregion_MainRAM,
|
||||
memregion_SharedWRAM,
|
||||
memregion_IO9,
|
||||
memregion_VRAM,
|
||||
memregion_BIOS7,
|
||||
memregion_WRAM7,
|
||||
memregion_IO7,
|
||||
memregion_Wifi,
|
||||
memregion_VWRAM,
|
||||
|
||||
static constexpr u32 MemBlockMainRAMOffset = 0;
|
||||
static constexpr u32 MemBlockSWRAMOffset = RoundUp(MainRAMMaxSize);
|
||||
static constexpr u32 MemBlockARM7WRAMOffset = MemBlockSWRAMOffset + RoundUp(SharedWRAMSize);
|
||||
static constexpr u32 MemBlockDTCMOffset = MemBlockARM7WRAMOffset + RoundUp(ARM7WRAMSize);
|
||||
static constexpr u32 MemBlockNWRAM_AOffset = MemBlockDTCMOffset + RoundUp(DTCMPhysicalSize);
|
||||
static constexpr u32 MemBlockNWRAM_BOffset = MemBlockNWRAM_AOffset + RoundUp(NWRAMSize);
|
||||
static constexpr u32 MemBlockNWRAM_COffset = MemBlockNWRAM_BOffset + RoundUp(NWRAMSize);
|
||||
static constexpr u32 MemoryTotalSize = MemBlockNWRAM_COffset + RoundUp(NWRAMSize);
|
||||
// DSi
|
||||
memregion_BIOS9DSi,
|
||||
memregion_BIOS7DSi,
|
||||
memregion_NewSharedWRAM_A,
|
||||
memregion_NewSharedWRAM_B,
|
||||
memregion_NewSharedWRAM_C,
|
||||
|
||||
class ARMJIT_Memory
|
||||
{
|
||||
public:
|
||||
enum
|
||||
{
|
||||
memregion_Other = 0,
|
||||
memregion_ITCM,
|
||||
memregion_DTCM,
|
||||
memregion_BIOS9,
|
||||
memregion_MainRAM,
|
||||
memregion_SharedWRAM,
|
||||
memregion_IO9,
|
||||
memregion_VRAM,
|
||||
memregion_BIOS7,
|
||||
memregion_WRAM7,
|
||||
memregion_IO7,
|
||||
memregion_Wifi,
|
||||
memregion_VWRAM,
|
||||
|
||||
// DSi
|
||||
memregion_BIOS9DSi,
|
||||
memregion_BIOS7DSi,
|
||||
memregion_NewSharedWRAM_A,
|
||||
memregion_NewSharedWRAM_B,
|
||||
memregion_NewSharedWRAM_C,
|
||||
|
||||
memregions_Count
|
||||
};
|
||||
|
||||
#ifdef JIT_ENABLED
|
||||
public:
|
||||
explicit ARMJIT_Memory(melonDS::NDS& nds);
|
||||
~ARMJIT_Memory() noexcept;
|
||||
ARMJIT_Memory(const ARMJIT_Memory&) = delete;
|
||||
ARMJIT_Memory(ARMJIT_Memory&&) = delete;
|
||||
ARMJIT_Memory& operator=(const ARMJIT_Memory&) = delete;
|
||||
ARMJIT_Memory& operator=(ARMJIT_Memory&&) = delete;
|
||||
void Reset() noexcept;
|
||||
void RemapDTCM(u32 newBase, u32 newSize) noexcept;
|
||||
void RemapSWRAM() noexcept;
|
||||
void RemapNWRAM(int num) noexcept;
|
||||
void SetCodeProtection(int region, u32 offset, bool protect) noexcept;
|
||||
|
||||
[[nodiscard]] u8* GetMainRAM() noexcept { return MemoryBase + MemBlockMainRAMOffset; }
|
||||
[[nodiscard]] const u8* GetMainRAM() const noexcept { return MemoryBase + MemBlockMainRAMOffset; }
|
||||
|
||||
[[nodiscard]] u8* GetSharedWRAM() noexcept { return MemoryBase + MemBlockSWRAMOffset; }
|
||||
[[nodiscard]] const u8* GetSharedWRAM() const noexcept { return MemoryBase + MemBlockSWRAMOffset; }
|
||||
|
||||
[[nodiscard]] u8* GetARM7WRAM() noexcept { return MemoryBase + MemBlockARM7WRAMOffset; }
|
||||
[[nodiscard]] const u8* GetARM7WRAM() const noexcept { return MemoryBase + MemBlockARM7WRAMOffset; }
|
||||
|
||||
[[nodiscard]] u8* GetARM9DTCM() noexcept { return MemoryBase + MemBlockDTCMOffset; }
|
||||
[[nodiscard]] const u8* GetARM9DTCM() const noexcept { return MemoryBase + MemBlockDTCMOffset; }
|
||||
|
||||
[[nodiscard]] u8* GetNWRAM_A() noexcept { return MemoryBase + MemBlockNWRAM_AOffset; }
|
||||
[[nodiscard]] const u8* GetNWRAM_A() const noexcept { return MemoryBase + MemBlockNWRAM_AOffset; }
|
||||
|
||||
[[nodiscard]] u8* GetNWRAM_B() noexcept { return MemoryBase + MemBlockNWRAM_BOffset; }
|
||||
[[nodiscard]] const u8* GetNWRAM_B() const noexcept { return MemoryBase + MemBlockNWRAM_BOffset; }
|
||||
|
||||
[[nodiscard]] u8* GetNWRAM_C() noexcept { return MemoryBase + MemBlockNWRAM_COffset; }
|
||||
[[nodiscard]] const u8* GetNWRAM_C() const noexcept { return MemoryBase + MemBlockNWRAM_COffset; }
|
||||
|
||||
int ClassifyAddress9(u32 addr) const noexcept;
|
||||
int ClassifyAddress7(u32 addr) const noexcept;
|
||||
bool GetMirrorLocation(int region, u32 num, u32 addr, u32& memoryOffset, u32& mirrorStart, u32& mirrorSize) const noexcept;
|
||||
u32 LocaliseAddress(int region, u32 num, u32 addr) const noexcept;
|
||||
bool IsFastmemCompatible(int region) const noexcept;
|
||||
void* GetFuncForAddr(ARM* cpu, u32 addr, bool store, int size) const noexcept;
|
||||
bool MapAtAddress(u32 addr) noexcept;
|
||||
|
||||
static bool IsFastMemSupported();
|
||||
|
||||
static void RegisterFaultHandler();
|
||||
static void UnregisterFaultHandler();
|
||||
|
||||
static u32 PageSize;
|
||||
static u32 PageShift;
|
||||
private:
|
||||
friend class Compiler;
|
||||
struct Mapping
|
||||
{
|
||||
u32 Addr;
|
||||
u32 Size, LocalOffset;
|
||||
u32 Num;
|
||||
|
||||
void Unmap(int region, NDS& nds) noexcept;
|
||||
};
|
||||
|
||||
struct FaultDescription
|
||||
{
|
||||
u32 EmulatedFaultAddr;
|
||||
u8* FaultPC;
|
||||
};
|
||||
static bool FaultHandler(FaultDescription& faultDesc, melonDS::NDS& nds);
|
||||
bool MapIntoRange(u32 addr, u32 num, u32 offset, u32 size) noexcept;
|
||||
bool UnmapFromRange(u32 addr, u32 num, u32 offset, u32 size) noexcept;
|
||||
void SetCodeProtectionRange(u32 addr, u32 size, u32 num, int protection) noexcept;
|
||||
|
||||
melonDS::NDS& NDS;
|
||||
void* FastMem9Start;
|
||||
void* FastMem7Start;
|
||||
u8* MemoryBase = nullptr;
|
||||
|
||||
#if defined(__SWITCH__)
|
||||
VirtmemReservation* FastMem9Reservation, *FastMem7Reservation;
|
||||
u8* MemoryBaseCodeMem;
|
||||
#elif defined(_WIN32)
|
||||
struct VirtmemPlaceholder
|
||||
{
|
||||
uintptr_t Start;
|
||||
size_t Size;
|
||||
};
|
||||
std::vector<VirtmemPlaceholder> VirtmemPlaceholders;
|
||||
|
||||
static LONG ExceptionHandler(EXCEPTION_POINTERS* exceptionInfo);
|
||||
HANDLE MemoryFile = INVALID_HANDLE_VALUE;
|
||||
#else
|
||||
|
||||
static void SigsegvHandler(int sig, siginfo_t* info, void* rawContext);
|
||||
int MemoryFile = -1;
|
||||
#endif
|
||||
#ifdef ANDROID
|
||||
Platform::DynamicLibrary* Libandroid = nullptr;
|
||||
#endif
|
||||
u8 MappingStatus9[1 << (32-12)] {};
|
||||
u8 MappingStatus7[1 << (32-12)] {};
|
||||
TinyVector<Mapping> Mappings[memregions_Count] {};
|
||||
#else
|
||||
public:
|
||||
explicit ARMJIT_Memory(melonDS::NDS&) {};
|
||||
~ARMJIT_Memory() = default;
|
||||
ARMJIT_Memory(const ARMJIT_Memory&) = delete;
|
||||
ARMJIT_Memory(ARMJIT_Memory&&) = delete;
|
||||
ARMJIT_Memory& operator=(const ARMJIT_Memory&) = delete;
|
||||
ARMJIT_Memory& operator=(ARMJIT_Memory&&) = delete;
|
||||
|
||||
void Reset() noexcept {}
|
||||
void RemapDTCM(u32 newBase, u32 newSize) noexcept {}
|
||||
void RemapSWRAM() noexcept {}
|
||||
void RemapNWRAM(int num) noexcept {}
|
||||
void SetCodeProtection(int region, u32 offset, bool protect) noexcept {}
|
||||
|
||||
[[nodiscard]] u8* GetMainRAM() noexcept { return MainRAM.data(); }
|
||||
[[nodiscard]] const u8* GetMainRAM() const noexcept { return MainRAM.data(); }
|
||||
|
||||
[[nodiscard]] u8* GetSharedWRAM() noexcept { return SharedWRAM.data(); }
|
||||
[[nodiscard]] const u8* GetSharedWRAM() const noexcept { return SharedWRAM.data(); }
|
||||
|
||||
[[nodiscard]] u8* GetARM7WRAM() noexcept { return ARM7WRAM.data(); }
|
||||
[[nodiscard]] const u8* GetARM7WRAM() const noexcept { return ARM7WRAM.data(); }
|
||||
|
||||
[[nodiscard]] u8* GetARM9DTCM() noexcept { return DTCM.data(); }
|
||||
[[nodiscard]] const u8* GetARM9DTCM() const noexcept { return DTCM.data(); }
|
||||
|
||||
[[nodiscard]] u8* GetNWRAM_A() noexcept { return NWRAM_A.data(); }
|
||||
[[nodiscard]] const u8* GetNWRAM_A() const noexcept { return NWRAM_A.data(); }
|
||||
|
||||
[[nodiscard]] u8* GetNWRAM_B() noexcept { return NWRAM_B.data(); }
|
||||
[[nodiscard]] const u8* GetNWRAM_B() const noexcept { return NWRAM_B.data(); }
|
||||
|
||||
[[nodiscard]] u8* GetNWRAM_C() noexcept { return NWRAM_C.data(); }
|
||||
[[nodiscard]] const u8* GetNWRAM_C() const noexcept { return NWRAM_C.data(); }
|
||||
private:
|
||||
std::array<u8, MainRAMMaxSize> MainRAM {};
|
||||
std::array<u8, ARM7WRAMSize> ARM7WRAM {};
|
||||
std::array<u8, SharedWRAMSize> SharedWRAM {};
|
||||
std::array<u8, DTCMPhysicalSize> DTCM {};
|
||||
std::array<u8, NWRAMSize> NWRAM_A {};
|
||||
std::array<u8, NWRAMSize> NWRAM_B {};
|
||||
std::array<u8, NWRAMSize> NWRAM_C {};
|
||||
#endif
|
||||
memregions_Count
|
||||
};
|
||||
|
||||
int ClassifyAddress9(u32 addr);
|
||||
int ClassifyAddress7(u32 addr);
|
||||
|
||||
bool GetMirrorLocation(int region, u32 num, u32 addr, u32& memoryOffset, u32& mirrorStart, u32& mirrorSize);
|
||||
u32 LocaliseAddress(int region, u32 num, u32 addr);
|
||||
|
||||
bool IsFastmemCompatible(int region);
|
||||
|
||||
void RemapDTCM(u32 newBase, u32 newSize);
|
||||
void RemapSWRAM();
|
||||
void RemapNWRAM(int num);
|
||||
|
||||
void SetCodeProtection(int region, u32 offset, bool protect);
|
||||
|
||||
void* GetFuncForAddr(ARM* cpu, u32 addr, bool store, int size);
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team, RSDuck
|
||||
Copyright 2016-2022 melonDS team, RSDuck
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,20 +19,15 @@
|
|||
#ifndef ARMJIT_REGCACHE_H
|
||||
#define ARMJIT_REGCACHE_H
|
||||
|
||||
#include "ARMJIT_Internal.h"
|
||||
#include "Platform.h"
|
||||
#include "ARMJIT.h"
|
||||
|
||||
// TODO: replace this in the future
|
||||
#include "dolphin/BitSet.h"
|
||||
|
||||
#include <assert.h>
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT
|
||||
{
|
||||
using Platform::Log;
|
||||
using Platform::LogLevel;
|
||||
using namespace Common;
|
||||
// Imported inside the namespace so that other headers aren't polluted
|
||||
|
||||
template <typename T, typename Reg>
|
||||
class RegisterCache
|
||||
|
|
@ -46,7 +41,7 @@ public:
|
|||
{
|
||||
for (int i = 0; i < 16; i++)
|
||||
Mapping[i] = (Reg)-1;
|
||||
|
||||
|
||||
PCAllocatableAsSrc = ~(pcAllocatableAsSrc
|
||||
? 0
|
||||
: (1 << 15));
|
||||
|
|
@ -84,7 +79,7 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
Log(LogLevel::Error, "this is a JIT bug! LoadRegister failed\n");
|
||||
printf("this is a JIT bug! LoadRegister failed\n");
|
||||
abort();
|
||||
}
|
||||
|
||||
|
|
@ -99,7 +94,7 @@ public:
|
|||
LiteralsLoaded &= ~(1 << reg);
|
||||
}
|
||||
|
||||
bool IsLiteral(int reg) const
|
||||
bool IsLiteral(int reg)
|
||||
{
|
||||
return LiteralsLoaded & (1 << reg);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -17,11 +17,10 @@
|
|||
*/
|
||||
|
||||
#include "ARMJIT_Compiler.h"
|
||||
#include "../ARM.h"
|
||||
|
||||
using namespace Gen;
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT
|
||||
{
|
||||
|
||||
// uses RSCRATCH3
|
||||
|
|
@ -129,7 +128,7 @@ OpArg Compiler::A_Comp_GetALUOp2(bool S, bool& carryUsed)
|
|||
Comp_AddCycles_C();
|
||||
|
||||
u32 shift = (CurInstr.Instr >> 7) & 0x1E;
|
||||
u32 imm = melonDS::ROR(CurInstr.Instr & 0xFF, shift);
|
||||
u32 imm = ::ROR(CurInstr.Instr & 0xFF, shift);
|
||||
|
||||
carryUsed = false;
|
||||
if (S && shift)
|
||||
|
|
@ -228,7 +227,7 @@ void Compiler::A_Comp_Arith()
|
|||
Comp_ArithTriOp(&Compiler::AND, rd, rn, op2, carryUsed, sFlag|opSymmetric|opInvertOp2);
|
||||
break;
|
||||
default:
|
||||
Log(LogLevel::Error, "this is a JIT bug! %04x\n", op);
|
||||
printf("this is a JIT bug! %04x\n", op);
|
||||
abort();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -17,12 +17,10 @@
|
|||
*/
|
||||
|
||||
#include "ARMJIT_Compiler.h"
|
||||
#include "../ARM.h"
|
||||
#include "../NDS.h"
|
||||
|
||||
using namespace Gen;
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT
|
||||
{
|
||||
|
||||
template <typename T>
|
||||
|
|
@ -121,7 +119,7 @@ void Compiler::Comp_JumpTo(u32 addr, bool forceNonConstantCycles)
|
|||
u32 compileTimePC = CurCPU->R[15];
|
||||
CurCPU->R[15] = newPC;
|
||||
|
||||
cycles += NDS.ARM7MemTimings[codeCycles][0] + NDS.ARM7MemTimings[codeCycles][1];
|
||||
cycles += NDS::ARM7MemTimings[codeCycles][0] + NDS::ARM7MemTimings[codeCycles][1];
|
||||
|
||||
CurCPU->R[15] = compileTimePC;
|
||||
}
|
||||
|
|
@ -133,7 +131,7 @@ void Compiler::Comp_JumpTo(u32 addr, bool forceNonConstantCycles)
|
|||
u32 compileTimePC = CurCPU->R[15];
|
||||
CurCPU->R[15] = newPC;
|
||||
|
||||
cycles += NDS.ARM7MemTimings[codeCycles][2] + NDS.ARM7MemTimings[codeCycles][3];
|
||||
cycles += NDS::ARM7MemTimings[codeCycles][2] + NDS::ARM7MemTimings[codeCycles][3];
|
||||
|
||||
CurCPU->R[15] = compileTimePC;
|
||||
}
|
||||
|
|
@ -176,9 +174,9 @@ void Compiler::Comp_JumpTo(Gen::X64Reg addr, bool restoreCPSR)
|
|||
else
|
||||
MOV(32, R(ABI_PARAM3), Imm32(true)); // what a waste
|
||||
if (Num == 0)
|
||||
ABI_CallFunction(ARMv5JumpToTrampoline);
|
||||
CALL((void*)&ARMv5JumpToTrampoline);
|
||||
else
|
||||
ABI_CallFunction(ARMv4JumpToTrampoline);
|
||||
CALL((void*)&ARMv4JumpToTrampoline);
|
||||
|
||||
PopRegs(restoreCPSR, true);
|
||||
|
||||
|
|
@ -249,7 +247,7 @@ void Compiler::T_Comp_BranchXchangeReg()
|
|||
{
|
||||
if (Num == 1)
|
||||
{
|
||||
Log(LogLevel::Warn, "BLX unsupported on ARM7!!!\n");
|
||||
printf("BLX unsupported on ARM7!!!\n");
|
||||
return;
|
||||
}
|
||||
MOV(32, R(RSCRATCH), MapReg(CurInstr.A_Reg(3)));
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -18,22 +18,25 @@
|
|||
|
||||
#include "ARMJIT_Compiler.h"
|
||||
|
||||
#include "../ARMJIT.h"
|
||||
#include "../ARMInterpreter.h"
|
||||
#include "../NDS.h"
|
||||
#include "../ARMJIT_Global.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
#include "../dolphin/CommonFuncs.h"
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#else
|
||||
#include <sys/mman.h>
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
using namespace Gen;
|
||||
using namespace Common;
|
||||
|
||||
extern "C" void ARM_Ret();
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT
|
||||
{
|
||||
template <>
|
||||
const X64Reg RegisterCache<Compiler, X64Reg>::NativeRegAllocOrder[] =
|
||||
|
|
@ -137,7 +140,7 @@ void Compiler::A_Comp_MSR()
|
|||
Comp_AddCycles_C();
|
||||
|
||||
OpArg val = CurInstr.Instr & (1 << 25)
|
||||
? Imm32(melonDS::ROR((CurInstr.Instr & 0xFF), ((CurInstr.Instr >> 7) & 0x1E)))
|
||||
? Imm32(::ROR((CurInstr.Instr & 0xFF), ((CurInstr.Instr >> 7) & 0x1E)))
|
||||
: MapReg(CurInstr.A_Reg(0));
|
||||
|
||||
u32 mask = 0;
|
||||
|
|
@ -216,21 +219,46 @@ void Compiler::A_Comp_MSR()
|
|||
MOV(32, R(ABI_PARAM3), R(RCPSR));
|
||||
MOV(32, R(ABI_PARAM2), R(RSCRATCH3));
|
||||
MOV(64, R(ABI_PARAM1), R(RCPU));
|
||||
ABI_CallFunction(UpdateModeTrampoline);
|
||||
CALL((void*)&UpdateModeTrampoline);
|
||||
|
||||
PopRegs(true, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Compiler::Compiler(melonDS::NDS& nds) : XEmitter(), NDS(nds)
|
||||
/*
|
||||
We'll repurpose this .bss memory
|
||||
|
||||
*/
|
||||
u8 CodeMemory[1024 * 1024 * 32];
|
||||
|
||||
Compiler::Compiler()
|
||||
{
|
||||
ARMJIT_Global::Init();
|
||||
{
|
||||
#ifdef _WIN32
|
||||
SYSTEM_INFO sysInfo;
|
||||
GetSystemInfo(&sysInfo);
|
||||
|
||||
CodeMemBase = static_cast<u8*>(ARMJIT_Global::AllocateCodeMem());
|
||||
CodeMemSize = ARMJIT_Global::CodeMemorySliceSize;
|
||||
u64 pageSize = (u64)sysInfo.dwPageSize;
|
||||
#else
|
||||
u64 pageSize = sysconf(_SC_PAGE_SIZE);
|
||||
#endif
|
||||
|
||||
ResetStart = CodeMemBase;
|
||||
u8* pageAligned = (u8*)(((u64)CodeMemory & ~(pageSize - 1)) + pageSize);
|
||||
u64 alignedSize = (((u64)CodeMemory + sizeof(CodeMemory)) & ~(pageSize - 1)) - (u64)pageAligned;
|
||||
|
||||
#ifdef _WIN32
|
||||
DWORD dummy;
|
||||
VirtualProtect(pageAligned, alignedSize, PAGE_EXECUTE_READWRITE, &dummy);
|
||||
#elif defined(__APPLE__)
|
||||
pageAligned = (u8*)mmap(NULL, 1024*1024*32, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_PRIVATE | MAP_ANONYMOUS ,-1, 0);
|
||||
#else
|
||||
mprotect(pageAligned, alignedSize, PROT_EXEC | PROT_READ | PROT_WRITE);
|
||||
#endif
|
||||
|
||||
ResetStart = pageAligned;
|
||||
CodeMemSize = alignedSize;
|
||||
}
|
||||
|
||||
Reset();
|
||||
|
||||
|
|
@ -444,13 +472,6 @@ Compiler::Compiler(melonDS::NDS& nds) : XEmitter(), NDS(nds)
|
|||
FarSize = (ResetStart + CodeMemSize) - FarStart;
|
||||
}
|
||||
|
||||
Compiler::~Compiler()
|
||||
{
|
||||
ARMJIT_Global::FreeCodeMem(CodeMemBase);
|
||||
|
||||
ARMJIT_Global::DeInit();
|
||||
}
|
||||
|
||||
void Compiler::LoadCPSR()
|
||||
{
|
||||
assert(!CPSRDirty);
|
||||
|
|
@ -627,7 +648,7 @@ const Compiler::CompileFunc T_Comp[ARMInstrInfo::tk_Count] = {
|
|||
};
|
||||
#undef F
|
||||
|
||||
bool Compiler::CanCompile(bool thumb, u16 kind) const
|
||||
bool Compiler::CanCompile(bool thumb, u16 kind)
|
||||
{
|
||||
return (thumb ? T_Comp[kind] : A_Comp[kind]) != NULL;
|
||||
}
|
||||
|
|
@ -643,7 +664,7 @@ void Compiler::Reset()
|
|||
LoadStorePatches.clear();
|
||||
}
|
||||
|
||||
bool Compiler::IsJITFault(const u8* addr)
|
||||
bool Compiler::IsJITFault(u8* addr)
|
||||
{
|
||||
return (u64)addr >= (u64)ResetStart && (u64)addr < (u64)ResetStart + CodeMemSize;
|
||||
}
|
||||
|
|
@ -660,7 +681,7 @@ void Compiler::Comp_SpecialBranchBehaviour(bool taken)
|
|||
|
||||
if (ConstantCycles)
|
||||
ADD(32, MDisp(RCPU, offsetof(ARM, Cycles)), Imm32(ConstantCycles));
|
||||
ABI_TailCall(ARM_Ret);
|
||||
JMP((u8*)&ARM_Ret, true);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -690,13 +711,13 @@ JitBlockEntry Compiler::CompileBlock(ARM* cpu, bool thumb, FetchedInstr instrs[]
|
|||
{
|
||||
if (NearSize - (GetCodePtr() - NearStart) < 1024 * 32) // guess...
|
||||
{
|
||||
Log(LogLevel::Debug, "near reset\n");
|
||||
NDS.JIT.ResetBlockCache();
|
||||
printf("near reset\n");
|
||||
ResetBlockCache();
|
||||
}
|
||||
if (FarSize - (FarCode - FarStart) < 1024 * 32) // guess...
|
||||
{
|
||||
Log(LogLevel::Debug, "far reset\n");
|
||||
NDS.JIT.ResetBlockCache();
|
||||
printf("far reset\n");
|
||||
ResetBlockCache();
|
||||
}
|
||||
|
||||
ConstantCycles = 0;
|
||||
|
|
@ -822,7 +843,7 @@ JitBlockEntry Compiler::CompileBlock(ARM* cpu, bool thumb, FetchedInstr instrs[]
|
|||
|
||||
if (ConstantCycles)
|
||||
ADD(32, MDisp(RCPU, offsetof(ARM, Cycles)), Imm32(ConstantCycles));
|
||||
ABI_TailCall(ARM_Ret);
|
||||
JMP((u8*)ARM_Ret, true);
|
||||
|
||||
#ifdef JIT_PROFILING_ENABLED
|
||||
CreateMethod("JIT_Block_%d_%d_%08X", (void*)res, Num, Thumb, instrs[0].Addr);
|
||||
|
|
@ -840,7 +861,7 @@ JitBlockEntry Compiler::CompileBlock(ARM* cpu, bool thumb, FetchedInstr instrs[]
|
|||
void Compiler::Comp_AddCycles_C(bool forceNonConstant)
|
||||
{
|
||||
s32 cycles = Num ?
|
||||
NDS.ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 1 : 3]
|
||||
NDS::ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 1 : 3]
|
||||
: ((R15 & 0x2) ? 0 : CurInstr.CodeCycles);
|
||||
|
||||
if ((!Thumb && CurInstr.Cond() < 0xE) || forceNonConstant)
|
||||
|
|
@ -852,7 +873,7 @@ void Compiler::Comp_AddCycles_C(bool forceNonConstant)
|
|||
void Compiler::Comp_AddCycles_CI(u32 i)
|
||||
{
|
||||
s32 cycles = (Num ?
|
||||
NDS.ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2]
|
||||
NDS::ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2]
|
||||
: ((R15 & 0x2) ? 0 : CurInstr.CodeCycles)) + i;
|
||||
|
||||
if (!Thumb && CurInstr.Cond() < 0xE)
|
||||
|
|
@ -864,7 +885,7 @@ void Compiler::Comp_AddCycles_CI(u32 i)
|
|||
void Compiler::Comp_AddCycles_CI(Gen::X64Reg i, int add)
|
||||
{
|
||||
s32 cycles = Num ?
|
||||
NDS.ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2]
|
||||
NDS::ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2]
|
||||
: ((R15 & 0x2) ? 0 : CurInstr.CodeCycles);
|
||||
|
||||
if (!Thumb && CurInstr.Cond() < 0xE)
|
||||
|
|
@ -889,7 +910,7 @@ void Compiler::Comp_AddCycles_CDI()
|
|||
|
||||
s32 cycles;
|
||||
|
||||
s32 numC = NDS.ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2];
|
||||
s32 numC = NDS::ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2];
|
||||
s32 numD = CurInstr.DataCycles;
|
||||
|
||||
if ((CurInstr.DataRegion >> 24) == 0x02) // mainRAM
|
||||
|
|
@ -934,7 +955,7 @@ void Compiler::Comp_AddCycles_CD()
|
|||
}
|
||||
else
|
||||
{
|
||||
s32 numC = NDS.ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2];
|
||||
s32 numC = NDS::ARM7MemTimings[CurInstr.CodeCycles][Thumb ? 0 : 2];
|
||||
s32 numD = CurInstr.DataCycles;
|
||||
|
||||
if ((CurInstr.DataRegion >> 4) == 0x02)
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,10 +19,9 @@
|
|||
#ifndef ARMJIT_X64_COMPILER_H
|
||||
#define ARMJIT_X64_COMPILER_H
|
||||
|
||||
#if defined(JIT_ENABLED) && defined(__x86_64__)
|
||||
|
||||
#include "../dolphin/x64Emitter.h"
|
||||
|
||||
#include "../ARMJIT.h"
|
||||
#include "../ARMJIT_Internal.h"
|
||||
#include "../ARMJIT_RegisterCache.h"
|
||||
|
||||
|
|
@ -32,12 +31,9 @@
|
|||
|
||||
#include <unordered_map>
|
||||
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT
|
||||
{
|
||||
class ARMJIT;
|
||||
class ARMJIT_Memory;
|
||||
class NDS;
|
||||
|
||||
const Gen::X64Reg RCPU = Gen::RBP;
|
||||
const Gen::X64Reg RCPSR = Gen::R15;
|
||||
|
||||
|
|
@ -83,8 +79,7 @@ struct Op2
|
|||
class Compiler : public Gen::XEmitter
|
||||
{
|
||||
public:
|
||||
explicit Compiler(melonDS::NDS& nds);
|
||||
~Compiler();
|
||||
Compiler();
|
||||
|
||||
void Reset();
|
||||
|
||||
|
|
@ -93,7 +88,7 @@ public:
|
|||
void LoadReg(int reg, Gen::X64Reg nativeReg);
|
||||
void SaveReg(int reg, Gen::X64Reg nativeReg);
|
||||
|
||||
bool CanCompile(bool thumb, u16 kind) const;
|
||||
bool CanCompile(bool thumb, u16 kind);
|
||||
|
||||
typedef void (Compiler::*CompileFunc)();
|
||||
|
||||
|
|
@ -172,7 +167,7 @@ public:
|
|||
memop_SubtractOffset = 1 << 4
|
||||
};
|
||||
void Comp_MemAccess(int rd, int rn, const Op2& op2, int size, int flags);
|
||||
s32 Comp_MemAccessBlock(int rn, Common::BitSet16 regs, bool store, bool preinc, bool decrement, bool usermode, bool skipLoadingRn);
|
||||
s32 Comp_MemAccessBlock(int rn, BitSet16 regs, bool store, bool preinc, bool decrement, bool usermode, bool skipLoadingRn);
|
||||
bool Comp_MemLoadLiteral(int size, bool signExtend, int rd, u32 addr);
|
||||
|
||||
void Comp_ArithTriOp(void (Compiler::*op)(int, const Gen::OpArg&, const Gen::OpArg&),
|
||||
|
|
@ -235,7 +230,7 @@ public:
|
|||
SetCodePtr(FarCode);
|
||||
}
|
||||
|
||||
bool IsJITFault(const u8* addr);
|
||||
bool IsJITFault(u8* addr);
|
||||
|
||||
u8* RewriteMemAccess(u8* pc);
|
||||
|
||||
|
|
@ -243,47 +238,44 @@ public:
|
|||
void CreateMethod(const char* namefmt, void* start, ...);
|
||||
#endif
|
||||
|
||||
melonDS::NDS& NDS;
|
||||
u8* FarCode {};
|
||||
u8* NearCode {};
|
||||
u32 FarSize {};
|
||||
u32 NearSize {};
|
||||
u8* FarCode;
|
||||
u8* NearCode;
|
||||
u32 FarSize;
|
||||
u32 NearSize;
|
||||
|
||||
u8* NearStart {};
|
||||
u8* FarStart {};
|
||||
u8* NearStart;
|
||||
u8* FarStart;
|
||||
|
||||
void* PatchedStoreFuncs[2][2][3][16] {};
|
||||
void* PatchedLoadFuncs[2][2][3][2][16] {};
|
||||
void* PatchedStoreFuncs[2][2][3][16];
|
||||
void* PatchedLoadFuncs[2][2][3][2][16];
|
||||
|
||||
std::unordered_map<u8*, LoadStorePatch> LoadStorePatches {};
|
||||
std::unordered_map<u8*, LoadStorePatch> LoadStorePatches;
|
||||
|
||||
u8* CodeMemBase;
|
||||
u8* ResetStart {};
|
||||
u32 CodeMemSize {};
|
||||
u8* ResetStart;
|
||||
u32 CodeMemSize;
|
||||
|
||||
bool Exit {};
|
||||
bool IrregularCycles {};
|
||||
bool Exit;
|
||||
bool IrregularCycles;
|
||||
|
||||
void* ReadBanked {};
|
||||
void* WriteBanked {};
|
||||
void* ReadBanked;
|
||||
void* WriteBanked;
|
||||
|
||||
bool CPSRDirty = false;
|
||||
|
||||
FetchedInstr CurInstr {};
|
||||
FetchedInstr CurInstr;
|
||||
|
||||
RegisterCache<Compiler, Gen::X64Reg> RegCache {};
|
||||
RegisterCache<Compiler, Gen::X64Reg> RegCache;
|
||||
|
||||
bool Thumb {};
|
||||
u32 Num {};
|
||||
u32 R15 {};
|
||||
u32 CodeRegion {};
|
||||
bool Thumb;
|
||||
u32 Num;
|
||||
u32 R15;
|
||||
u32 CodeRegion;
|
||||
|
||||
u32 ConstantCycles {};
|
||||
u32 ConstantCycles;
|
||||
|
||||
ARM* CurCPU {};
|
||||
ARM* CurCPU;
|
||||
};
|
||||
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team, RSDuck
|
||||
Copyright 2016-2022 melonDS team, RSDuck
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -17,7 +17,7 @@
|
|||
*/
|
||||
|
||||
#include "../ARM.h"
|
||||
using namespace melonDS;
|
||||
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
FILE* f = fopen("ARMJIT_Offsets.h", "w");
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -104,8 +104,3 @@ ARM_Ret:
|
|||
#endif
|
||||
|
||||
ret
|
||||
|
||||
#if !defined(__APPLE__) && !defined(WIN64)
|
||||
.section .note.GNU-stack,"",@progbits
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -17,12 +17,10 @@
|
|||
*/
|
||||
|
||||
#include "ARMJIT_Compiler.h"
|
||||
#include "../ARMJIT.h"
|
||||
#include "../NDS.h"
|
||||
|
||||
using namespace Gen;
|
||||
|
||||
namespace melonDS
|
||||
namespace ARMJIT
|
||||
{
|
||||
|
||||
template <typename T>
|
||||
|
|
@ -53,7 +51,7 @@ u8* Compiler::RewriteMemAccess(u8* pc)
|
|||
return pc + (ptrdiff_t)patch.Offset;
|
||||
}
|
||||
|
||||
Log(LogLevel::Error, "this is a JIT bug %sx\n", pc);
|
||||
printf("this is a JIT bug %sx\n", pc);
|
||||
abort();
|
||||
}
|
||||
|
||||
|
|
@ -69,9 +67,9 @@ u8* Compiler::RewriteMemAccess(u8* pc)
|
|||
|
||||
bool Compiler::Comp_MemLoadLiteral(int size, bool signExtend, int rd, u32 addr)
|
||||
{
|
||||
u32 localAddr = NDS.JIT.LocaliseCodeAddress(Num, addr);
|
||||
u32 localAddr = LocaliseCodeAddress(Num, addr);
|
||||
|
||||
int invalidLiteralIdx = NDS.JIT.InvalidLiterals.Find(localAddr);
|
||||
int invalidLiteralIdx = InvalidLiterals.Find(localAddr);
|
||||
if (invalidLiteralIdx != -1)
|
||||
{
|
||||
return false;
|
||||
|
|
@ -86,7 +84,7 @@ bool Compiler::Comp_MemLoadLiteral(int size, bool signExtend, int rd, u32 addr)
|
|||
if (size == 32)
|
||||
{
|
||||
CurCPU->DataRead32(addr & ~0x3, &val);
|
||||
val = melonDS::ROR(val, (addr & 0x3) << 3);
|
||||
val = ::ROR(val, (addr & 0x3) << 3);
|
||||
}
|
||||
else if (size == 16)
|
||||
{
|
||||
|
|
@ -119,7 +117,7 @@ void Compiler::Comp_MemAccess(int rd, int rn, const Op2& op2, int size, int flag
|
|||
if (size == 16)
|
||||
addressMask = ~1;
|
||||
|
||||
if (NDS.JIT.LiteralOptimizationsEnabled() && rn == 15 && rd != 15 && op2.IsImm && !(flags & (memop_Post|memop_Store|memop_Writeback)))
|
||||
if (LiteralOptimizations && rn == 15 && rd != 15 && op2.IsImm && !(flags & (memop_Post|memop_Store|memop_Writeback)))
|
||||
{
|
||||
u32 addr = R15 + op2.Imm * ((flags & memop_SubtractOffset) ? -1 : 1);
|
||||
|
||||
|
|
@ -136,7 +134,7 @@ void Compiler::Comp_MemAccess(int rd, int rn, const Op2& op2, int size, int flag
|
|||
Comp_AddCycles_CDI();
|
||||
}
|
||||
|
||||
bool addrIsStatic = NDS.JIT.LiteralOptimizationsEnabled()
|
||||
bool addrIsStatic = LiteralOptimizations
|
||||
&& RegCache.IsLiteral(rn) && op2.IsImm && !(flags & (memop_Writeback|memop_Post));
|
||||
u32 staticAddress;
|
||||
if (addrIsStatic)
|
||||
|
|
@ -197,10 +195,10 @@ void Compiler::Comp_MemAccess(int rd, int rn, const Op2& op2, int size, int flag
|
|||
MOV(32, rnMapped, R(finalAddr));
|
||||
|
||||
u32 expectedTarget = Num == 0
|
||||
? NDS.JIT.Memory.ClassifyAddress9(CurInstr.DataRegion)
|
||||
: NDS.JIT.Memory.ClassifyAddress7(CurInstr.DataRegion);
|
||||
? ARMJIT_Memory::ClassifyAddress9(CurInstr.DataRegion)
|
||||
: ARMJIT_Memory::ClassifyAddress7(CurInstr.DataRegion);
|
||||
|
||||
if (NDS.JIT.FastMemoryEnabled() && ((!Thumb && CurInstr.Cond() != 0xE) || NDS.JIT.Memory.IsFastmemCompatible(expectedTarget)))
|
||||
if (ARMJIT::FastMemory && ((!Thumb && CurInstr.Cond() != 0xE) || ARMJIT_Memory::IsFastmemCompatible(expectedTarget)))
|
||||
{
|
||||
if (rdMapped.IsImm())
|
||||
{
|
||||
|
|
@ -213,12 +211,12 @@ void Compiler::Comp_MemAccess(int rd, int rn, const Op2& op2, int size, int flag
|
|||
|
||||
assert(rdMapped.GetSimpleReg() >= 0 && rdMapped.GetSimpleReg() < 16);
|
||||
patch.PatchFunc = flags & memop_Store
|
||||
? PatchedStoreFuncs[NDS.ConsoleType][Num][__builtin_ctz(size) - 3][rdMapped.GetSimpleReg()]
|
||||
: PatchedLoadFuncs[NDS.ConsoleType][Num][__builtin_ctz(size) - 3][!!(flags & memop_SignExtend)][rdMapped.GetSimpleReg()];
|
||||
? PatchedStoreFuncs[NDS::ConsoleType][Num][__builtin_ctz(size) - 3][rdMapped.GetSimpleReg()]
|
||||
: PatchedLoadFuncs[NDS::ConsoleType][Num][__builtin_ctz(size) - 3][!!(flags & memop_SignExtend)][rdMapped.GetSimpleReg()];
|
||||
|
||||
assert(patch.PatchFunc != NULL);
|
||||
|
||||
MOV(64, R(RSCRATCH), ImmPtr(Num == 0 ? NDS.JIT.Memory.FastMem9Start : NDS.JIT.Memory.FastMem7Start));
|
||||
MOV(64, R(RSCRATCH), ImmPtr(Num == 0 ? ARMJIT_Memory::FastMem9Start : ARMJIT_Memory::FastMem7Start));
|
||||
|
||||
X64Reg maskedAddr = RSCRATCH3;
|
||||
if (size > 8)
|
||||
|
|
@ -269,7 +267,7 @@ void Compiler::Comp_MemAccess(int rd, int rn, const Op2& op2, int size, int flag
|
|||
|
||||
void* func = NULL;
|
||||
if (addrIsStatic)
|
||||
func = NDS.JIT.Memory.GetFuncForAddr(CurCPU, staticAddress, flags & memop_Store, size);
|
||||
func = ARMJIT_Memory::GetFuncForAddr(CurCPU, staticAddress, flags & memop_Store, size);
|
||||
|
||||
if (func)
|
||||
{
|
||||
|
|
@ -314,26 +312,26 @@ void Compiler::Comp_MemAccess(int rd, int rn, const Op2& op2, int size, int flag
|
|||
MOV(32, R(ABI_PARAM1), R(RSCRATCH3));
|
||||
if (flags & memop_Store)
|
||||
{
|
||||
switch (size | NDS.ConsoleType)
|
||||
switch (size | NDS::ConsoleType)
|
||||
{
|
||||
case 32: ABI_CallFunction(SlowWrite9<u32, 0>); break;
|
||||
case 16: ABI_CallFunction(SlowWrite9<u16, 0>); break;
|
||||
case 8: ABI_CallFunction(&SlowWrite9<u8, 0>); break;
|
||||
case 33: ABI_CallFunction(&SlowWrite9<u32, 1>); break;
|
||||
case 17: ABI_CallFunction(&SlowWrite9<u16, 1>); break;
|
||||
case 9: ABI_CallFunction(&SlowWrite9<u8, 1>); break;
|
||||
case 32: CALL((void*)&SlowWrite9<u32, 0>); break;
|
||||
case 16: CALL((void*)&SlowWrite9<u16, 0>); break;
|
||||
case 8: CALL((void*)&SlowWrite9<u8, 0>); break;
|
||||
case 33: CALL((void*)&SlowWrite9<u32, 1>); break;
|
||||
case 17: CALL((void*)&SlowWrite9<u16, 1>); break;
|
||||
case 9: CALL((void*)&SlowWrite9<u8, 1>); break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (size | NDS.ConsoleType)
|
||||
switch (size | NDS::ConsoleType)
|
||||
{
|
||||
case 32: ABI_CallFunction(&SlowRead9<u32, 0>); break;
|
||||
case 16: ABI_CallFunction(&SlowRead9<u16, 0>); break;
|
||||
case 8: ABI_CallFunction(&SlowRead9<u8, 0>); break;
|
||||
case 33: ABI_CallFunction(&SlowRead9<u32, 1>); break;
|
||||
case 17: ABI_CallFunction(&SlowRead9<u16, 1>); break;
|
||||
case 9: ABI_CallFunction(&SlowRead9<u8, 1>); break;
|
||||
case 32: CALL((void*)&SlowRead9<u32, 0>); break;
|
||||
case 16: CALL((void*)&SlowRead9<u16, 0>); break;
|
||||
case 8: CALL((void*)&SlowRead9<u8, 0>); break;
|
||||
case 33: CALL((void*)&SlowRead9<u32, 1>); break;
|
||||
case 17: CALL((void*)&SlowRead9<u16, 1>); break;
|
||||
case 9: CALL((void*)&SlowRead9<u8, 1>); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -345,26 +343,26 @@ void Compiler::Comp_MemAccess(int rd, int rn, const Op2& op2, int size, int flag
|
|||
{
|
||||
MOV(32, R(ABI_PARAM2), rdMapped);
|
||||
|
||||
switch (size | NDS.ConsoleType)
|
||||
switch (size | NDS::ConsoleType)
|
||||
{
|
||||
case 32: ABI_CallFunction(&SlowWrite7<u32, 0>); break;
|
||||
case 16: ABI_CallFunction(&SlowWrite7<u16, 0>); break;
|
||||
case 8: ABI_CallFunction(&SlowWrite7<u8, 0>); break;
|
||||
case 33: ABI_CallFunction(&SlowWrite7<u32, 1>); break;
|
||||
case 17: ABI_CallFunction(&SlowWrite7<u16, 1>); break;
|
||||
case 9: ABI_CallFunction(&SlowWrite7<u8, 1>); break;
|
||||
case 32: CALL((void*)&SlowWrite7<u32, 0>); break;
|
||||
case 16: CALL((void*)&SlowWrite7<u16, 0>); break;
|
||||
case 8: CALL((void*)&SlowWrite7<u8, 0>); break;
|
||||
case 33: CALL((void*)&SlowWrite7<u32, 1>); break;
|
||||
case 17: CALL((void*)&SlowWrite7<u16, 1>); break;
|
||||
case 9: CALL((void*)&SlowWrite7<u8, 1>); break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
switch (size | NDS.ConsoleType)
|
||||
switch (size | NDS::ConsoleType)
|
||||
{
|
||||
case 32: ABI_CallFunction(&SlowRead7<u32, 0>); break;
|
||||
case 16: ABI_CallFunction(&SlowRead7<u16, 0>); break;
|
||||
case 8: ABI_CallFunction(&SlowRead7<u8, 0>); break;
|
||||
case 33: ABI_CallFunction(&SlowRead7<u32, 1>); break;
|
||||
case 17: ABI_CallFunction(&SlowRead7<u16, 1>); break;
|
||||
case 9: ABI_CallFunction(&SlowRead7<u8, 1>); break;
|
||||
case 32: CALL((void*)&SlowRead7<u32, 0>); break;
|
||||
case 16: CALL((void*)&SlowRead7<u16, 0>); break;
|
||||
case 8: CALL((void*)&SlowRead7<u8, 0>); break;
|
||||
case 33: CALL((void*)&SlowRead7<u32, 1>); break;
|
||||
case 17: CALL((void*)&SlowRead7<u16, 1>); break;
|
||||
case 9: CALL((void*)&SlowRead7<u8, 1>); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -384,7 +382,7 @@ void Compiler::Comp_MemAccess(int rd, int rn, const Op2& op2, int size, int flag
|
|||
if (!(flags & memop_Store) && rd == 15)
|
||||
{
|
||||
if (size < 32)
|
||||
Log(LogLevel::Debug, "!!! LDR <32 bit PC %08X %x\n", R15, CurInstr.Instr);
|
||||
printf("!!! LDR <32 bit PC %08X %x\n", R15, CurInstr.Instr);
|
||||
{
|
||||
if (Num == 1)
|
||||
{
|
||||
|
|
@ -423,16 +421,16 @@ s32 Compiler::Comp_MemAccessBlock(int rn, BitSet16 regs, bool store, bool preinc
|
|||
s32 offset = (regsCount * 4) * (decrement ? -1 : 1);
|
||||
|
||||
int expectedTarget = Num == 0
|
||||
? NDS.JIT.Memory.ClassifyAddress9(CurInstr.DataRegion)
|
||||
: NDS.JIT.Memory.ClassifyAddress7(CurInstr.DataRegion);
|
||||
? ARMJIT_Memory::ClassifyAddress9(CurInstr.DataRegion)
|
||||
: ARMJIT_Memory::ClassifyAddress7(CurInstr.DataRegion);
|
||||
|
||||
if (!store)
|
||||
Comp_AddCycles_CDI();
|
||||
else
|
||||
Comp_AddCycles_CD();
|
||||
|
||||
bool compileFastPath = NDS.JIT.FastMemoryEnabled()
|
||||
&& !usermode && (CurInstr.Cond() < 0xE || NDS.JIT.Memory.IsFastmemCompatible(expectedTarget));
|
||||
bool compileFastPath = FastMemory
|
||||
&& !usermode && (CurInstr.Cond() < 0xE || ARMJIT_Memory::IsFastmemCompatible(expectedTarget));
|
||||
|
||||
// we need to make sure that the stack stays aligned to 16 bytes
|
||||
#ifdef _WIN32
|
||||
|
|
@ -455,7 +453,7 @@ s32 Compiler::Comp_MemAccessBlock(int rn, BitSet16 regs, bool store, bool preinc
|
|||
u8* fastPathStart = GetWritableCodePtr();
|
||||
u8* loadStoreAddr[16];
|
||||
|
||||
MOV(64, R(RSCRATCH2), ImmPtr(Num == 0 ? NDS.JIT.Memory.FastMem9Start : NDS.JIT.Memory.FastMem7Start));
|
||||
MOV(64, R(RSCRATCH2), ImmPtr(Num == 0 ? ARMJIT_Memory::FastMem9Start : ARMJIT_Memory::FastMem7Start));
|
||||
ADD(64, R(RSCRATCH2), R(RSCRATCH4));
|
||||
|
||||
u32 offset = 0;
|
||||
|
|
@ -524,12 +522,12 @@ s32 Compiler::Comp_MemAccessBlock(int rn, BitSet16 regs, bool store, bool preinc
|
|||
if (Num == 0)
|
||||
MOV(64, R(ABI_PARAM4), R(RCPU));
|
||||
|
||||
switch (Num * 2 | NDS.ConsoleType)
|
||||
switch (Num * 2 | NDS::ConsoleType)
|
||||
{
|
||||
case 0: ABI_CallFunction(&SlowBlockTransfer9<false, 0>); break;
|
||||
case 1: ABI_CallFunction(&SlowBlockTransfer9<false, 1>); break;
|
||||
case 2: ABI_CallFunction(&SlowBlockTransfer7<false, 0>); break;
|
||||
case 3: ABI_CallFunction(&SlowBlockTransfer7<false, 1>); break;
|
||||
case 0: CALL((void*)&SlowBlockTransfer9<false, 0>); break;
|
||||
case 1: CALL((void*)&SlowBlockTransfer9<false, 1>); break;
|
||||
case 2: CALL((void*)&SlowBlockTransfer7<false, 0>); break;
|
||||
case 3: CALL((void*)&SlowBlockTransfer7<false, 1>); break;
|
||||
}
|
||||
|
||||
PopRegs(false, false);
|
||||
|
|
@ -628,12 +626,12 @@ s32 Compiler::Comp_MemAccessBlock(int rn, BitSet16 regs, bool store, bool preinc
|
|||
if (Num == 0)
|
||||
MOV(64, R(ABI_PARAM4), R(RCPU));
|
||||
|
||||
switch (Num * 2 | NDS.ConsoleType)
|
||||
switch (Num * 2 | NDS::ConsoleType)
|
||||
{
|
||||
case 0: ABI_CallFunction(&SlowBlockTransfer9<true, 0>); break;
|
||||
case 1: ABI_CallFunction(&SlowBlockTransfer9<true, 1>); break;
|
||||
case 2: ABI_CallFunction(&SlowBlockTransfer7<true, 0>); break;
|
||||
case 3: ABI_CallFunction(&SlowBlockTransfer7<true, 1>); break;
|
||||
case 0: CALL((void*)&SlowBlockTransfer9<true, 0>); break;
|
||||
case 1: CALL((void*)&SlowBlockTransfer9<true, 1>); break;
|
||||
case 2: CALL((void*)&SlowBlockTransfer7<true, 0>); break;
|
||||
case 3: CALL((void*)&SlowBlockTransfer7<true, 1>); break;
|
||||
}
|
||||
|
||||
ADD(64, R(RSP), stackAlloc <= INT8_MAX ? Imm8(stackAlloc) : Imm32(stackAlloc));
|
||||
|
|
@ -809,7 +807,7 @@ void Compiler::T_Comp_LoadPCRel()
|
|||
{
|
||||
u32 offset = (CurInstr.Instr & 0xFF) << 2;
|
||||
u32 addr = (R15 & ~0x2) + offset;
|
||||
if (!NDS.JIT.LiteralOptimizationsEnabled() || !Comp_MemLoadLiteral(32, false, CurInstr.T_Reg(8), addr))
|
||||
if (!LiteralOptimizations || !Comp_MemLoadLiteral(32, false, CurInstr.T_Reg(8), addr))
|
||||
Comp_MemAccess(CurInstr.T_Reg(8), 15, Op2(offset), 32, 0);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team, RSDuck
|
||||
Copyright 2016-2022 melonDS team, RSDuck
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -22,7 +22,7 @@
|
|||
|
||||
#include "ARMJIT.h"
|
||||
|
||||
namespace melonDS::ARMInstrInfo
|
||||
namespace ARMInstrInfo
|
||||
{
|
||||
|
||||
#define ak(x) ((x) << 23)
|
||||
|
|
@ -315,7 +315,7 @@ const u32 T_SVC = T_BranchAlways | T_WriteR14 | tk(tk_SVC);
|
|||
#include "ARM_InstrTable.h"
|
||||
#undef INSTRFUNC_PROTO
|
||||
|
||||
Info Decode(bool thumb, u32 num, u32 instr, bool literaloptimizations)
|
||||
Info Decode(bool thumb, u32 num, u32 instr)
|
||||
{
|
||||
const u8 FlagsReadPerCond[7] = {
|
||||
flag_Z,
|
||||
|
|
@ -386,7 +386,7 @@ Info Decode(bool thumb, u32 num, u32 instr, bool literaloptimizations)
|
|||
{
|
||||
if (res.Kind == tk_LDR_PCREL)
|
||||
{
|
||||
if (!literaloptimizations)
|
||||
if (!ARMJIT::LiteralOptimizations)
|
||||
res.SrcRegs |= 1 << 15;
|
||||
res.SpecialKind = special_LoadLiteral;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -21,7 +21,7 @@
|
|||
|
||||
#include "types.h"
|
||||
|
||||
namespace melonDS::ARMInstrInfo
|
||||
namespace ARMInstrInfo
|
||||
{
|
||||
|
||||
// Instruction kinds, for faster dispatch
|
||||
|
|
@ -274,7 +274,7 @@ struct Info
|
|||
}
|
||||
};
|
||||
|
||||
Info Decode(bool thumb, u32 num, u32 instr, bool literaloptimizations);
|
||||
Info Decode(bool thumb, u32 num, u32 instr);
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
|
|||
140
src/Args.h
140
src/Args.h
|
|
@ -1,140 +0,0 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
melonDS 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.
|
||||
|
||||
melonDS 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 melonDS. If not, see http://www.gnu.org/licenses/.
|
||||
*/
|
||||
|
||||
#ifndef MELONDS_ARGS_H
|
||||
#define MELONDS_ARGS_H
|
||||
|
||||
#include <array>
|
||||
#include <optional>
|
||||
#include <memory>
|
||||
|
||||
#include "NDSCart.h"
|
||||
#include "GBACart.h"
|
||||
#include "types.h"
|
||||
#include "MemConstants.h"
|
||||
#include "DSi_NAND.h"
|
||||
#include "FATStorage.h"
|
||||
#include "FreeBIOS.h"
|
||||
#include "GPU3D_Soft.h"
|
||||
#include "SPI_Firmware.h"
|
||||
#include "SPU.h"
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
namespace NDSCart { class CartCommon; }
|
||||
namespace GBACart { class CartCommon; }
|
||||
|
||||
template<size_t N>
|
||||
constexpr std::array<u8, N> BrokenBIOS = []() constexpr {
|
||||
std::array<u8, N> broken {};
|
||||
|
||||
for (int i = 0; i < 16; i++)
|
||||
{
|
||||
broken[i*4+0] = 0xE7;
|
||||
broken[i*4+1] = 0xFF;
|
||||
broken[i*4+2] = 0xDE;
|
||||
broken[i*4+3] = 0xFF;
|
||||
}
|
||||
|
||||
return broken;
|
||||
}();
|
||||
|
||||
/// Arguments that configure the JIT.
|
||||
/// Ignored in builds that don't have the JIT included.
|
||||
struct JITArgs
|
||||
{
|
||||
unsigned MaxBlockSize = 32;
|
||||
bool LiteralOptimizations = true;
|
||||
bool BranchOptimizations = true;
|
||||
|
||||
/// Ignored in builds that have fast memory excluded
|
||||
/// (even if the JIT is otherwise available).
|
||||
/// Enabled by default, but frontends should disable this when debugging
|
||||
/// so the constants segfaults don't hinder debugging.
|
||||
bool FastMemory = true;
|
||||
};
|
||||
|
||||
using ARM9BIOSImage = std::array<u8, ARM9BIOSSize>;
|
||||
using ARM7BIOSImage = std::array<u8, ARM7BIOSSize>;
|
||||
using DSiBIOSImage = std::array<u8, DSiBIOSSize>;
|
||||
|
||||
struct GDBArgs
|
||||
{
|
||||
u16 PortARM7 = 0;
|
||||
u16 PortARM9 = 0;
|
||||
bool ARM7BreakOnStartup = false;
|
||||
bool ARM9BreakOnStartup = false;
|
||||
};
|
||||
|
||||
/// Arguments to pass into the NDS constructor.
|
||||
/// New fields here should have default values if possible.
|
||||
struct NDSArgs
|
||||
{
|
||||
/// NDS ARM9 BIOS to install.
|
||||
/// Defaults to FreeBIOS, which is not compatible with DSi mode.
|
||||
std::unique_ptr<ARM9BIOSImage> ARM9BIOS = std::make_unique<ARM9BIOSImage>(bios_arm9_bin);
|
||||
|
||||
/// NDS ARM7 BIOS to install.
|
||||
/// Defaults to FreeBIOS, which is not compatible with DSi mode.
|
||||
std::unique_ptr<ARM7BIOSImage> ARM7BIOS = std::make_unique<ARM7BIOSImage>(bios_arm7_bin);
|
||||
|
||||
/// Firmware image to install.
|
||||
/// Defaults to generated NDS firmware.
|
||||
/// Generated firmware is not compatible with DSi mode.
|
||||
melonDS::Firmware Firmware {0};
|
||||
|
||||
/// How the JIT should be configured when initializing.
|
||||
/// Defaults to enabled, with default settings.
|
||||
/// To disable the JIT, set this to std::nullopt.
|
||||
/// Ignored in builds that don't have the JIT included.
|
||||
std::optional<JITArgs> JIT = JITArgs();
|
||||
|
||||
AudioBitDepth BitDepth = AudioBitDepth::Auto;
|
||||
AudioInterpolation Interpolation = AudioInterpolation::None;
|
||||
|
||||
/// How the GDB stub should be handled.
|
||||
/// Defaults to disabled.
|
||||
/// Ignored in builds that don't have the GDB stub included.
|
||||
std::optional<GDBArgs> GDB = std::nullopt;
|
||||
|
||||
/// The 3D renderer to initialize the DS with.
|
||||
/// Defaults to the software renderer.
|
||||
/// Can be changed later at any time.
|
||||
std::unique_ptr<melonDS::Renderer3D> Renderer3D = std::make_unique<SoftRenderer>();
|
||||
};
|
||||
|
||||
/// Arguments to pass into the DSi constructor.
|
||||
/// New fields here should have default values if possible.
|
||||
/// Contains no virtual methods, so there's no vtable.
|
||||
struct DSiArgs final : public NDSArgs
|
||||
{
|
||||
std::unique_ptr<DSiBIOSImage> ARM9iBIOS = std::make_unique<DSiBIOSImage>(BrokenBIOS<DSiBIOSSize>);
|
||||
std::unique_ptr<DSiBIOSImage> ARM7iBIOS = std::make_unique<DSiBIOSImage>(BrokenBIOS<DSiBIOSSize>);
|
||||
|
||||
/// NAND image to install.
|
||||
/// Required, there is no default value.
|
||||
DSi_NAND::NANDImage NANDImage;
|
||||
|
||||
/// SD card to install.
|
||||
/// Defaults to std::nullopt, which means no SD card.
|
||||
std::optional<FATStorage> DSiSDCard;
|
||||
|
||||
bool FullBIOSBoot = false;
|
||||
};
|
||||
}
|
||||
#endif //MELONDS_ARGS_H
|
||||
|
|
@ -1,214 +1,141 @@
|
|||
project(core)
|
||||
|
||||
set (CMAKE_CXX_STANDARD 17)
|
||||
|
||||
include(FixInterfaceIncludes)
|
||||
|
||||
add_library(core STATIC
|
||||
ARCodeFile.cpp
|
||||
AREngine.cpp
|
||||
ARM.cpp
|
||||
ARM_InstrTable.h
|
||||
ARMInterpreter.cpp
|
||||
ARMInterpreter_ALU.cpp
|
||||
ARMInterpreter_Branch.cpp
|
||||
ARMInterpreter_LoadStore.cpp
|
||||
CP15.cpp
|
||||
CRC32.cpp
|
||||
DMA.cpp
|
||||
DMA_Timings.h
|
||||
DMA_Timings.cpp
|
||||
DSi.cpp
|
||||
DSi_AES.cpp
|
||||
DSi_Camera.cpp
|
||||
DSi_DSP.cpp
|
||||
DSi_I2C.cpp
|
||||
DSi_NAND.cpp
|
||||
DSi_NDMA.cpp
|
||||
DSi_NWifi.cpp
|
||||
DSi_SD.cpp
|
||||
DSi_SPI_TSC.cpp
|
||||
FATIO.cpp
|
||||
FATStorage.cpp
|
||||
FIFO.h
|
||||
GBACart.cpp
|
||||
GPU.cpp
|
||||
GPU2D.cpp
|
||||
GPU2D_Soft.cpp
|
||||
GPU3D.cpp
|
||||
GPU3D_Soft.cpp
|
||||
GPU3D_Texcache.cpp
|
||||
GPU3D_Texcache.h
|
||||
melonDLDI.h
|
||||
NDS.cpp
|
||||
NDSCart.cpp
|
||||
NDSCartR4.cpp
|
||||
Platform.h
|
||||
ROMList.h
|
||||
ROMList.cpp
|
||||
FreeBIOS.h
|
||||
FreeBIOS.cpp
|
||||
RTC.cpp
|
||||
Savestate.cpp
|
||||
SPI.cpp
|
||||
SPI_Firmware.cpp
|
||||
SPU.cpp
|
||||
types.h
|
||||
Utils.cpp
|
||||
Utils.h
|
||||
Wifi.cpp
|
||||
WifiAP.cpp
|
||||
ARCodeFile.cpp
|
||||
AREngine.cpp
|
||||
ARM.cpp
|
||||
ARM_InstrTable.h
|
||||
ARMInterpreter.cpp
|
||||
ARMInterpreter_ALU.cpp
|
||||
ARMInterpreter_Branch.cpp
|
||||
ARMInterpreter_LoadStore.cpp
|
||||
CP15.cpp
|
||||
CRC32.cpp
|
||||
DMA.cpp
|
||||
DMA_Timings.h
|
||||
DSi.cpp
|
||||
DSi_AES.cpp
|
||||
DSi_Camera.cpp
|
||||
DSi_DSP.cpp
|
||||
DSi_I2C.cpp
|
||||
DSi_NAND.cpp
|
||||
DSi_NDMA.cpp
|
||||
DSi_NWifi.cpp
|
||||
DSi_SD.cpp
|
||||
DSi_SPI_TSC.cpp
|
||||
FATStorage.cpp
|
||||
FIFO.h
|
||||
GBACart.cpp
|
||||
GPU.cpp
|
||||
GPU2D.cpp
|
||||
GPU2D_Soft.cpp
|
||||
GPU3D.cpp
|
||||
GPU3D_Soft.cpp
|
||||
melonDLDI.h
|
||||
NDS.cpp
|
||||
NDSCart.cpp
|
||||
Platform.h
|
||||
ROMList.h
|
||||
FreeBIOS.h
|
||||
RTC.cpp
|
||||
Savestate.cpp
|
||||
SPI.cpp
|
||||
SPU.cpp
|
||||
types.h
|
||||
version.h
|
||||
Wifi.cpp
|
||||
WifiAP.cpp
|
||||
|
||||
fatfs/ff.c
|
||||
fatfs/ffsystem.c
|
||||
fatfs/ffunicode.c
|
||||
fatfs/ffconf.h
|
||||
|
||||
sha1/sha1.c
|
||||
tiny-AES-c/aes.c
|
||||
xxhash/xxhash.c)
|
||||
|
||||
if (ENABLE_GDBSTUB)
|
||||
message(NOTICE "Enabling GDB stub")
|
||||
target_sources(core PRIVATE
|
||||
debug/GdbStub.cpp
|
||||
debug/GdbProto.cpp
|
||||
debug/GdbCmds.cpp
|
||||
)
|
||||
endif()
|
||||
fatfs/diskio.c
|
||||
fatfs/ff.c
|
||||
fatfs/ffsystem.c
|
||||
fatfs/ffunicode.c
|
||||
fatfs/ffconf.h
|
||||
|
||||
sha1/sha1.c
|
||||
tiny-AES-c/aes.c
|
||||
xxhash/xxhash.c
|
||||
)
|
||||
|
||||
if (ENABLE_OGLRENDERER)
|
||||
target_sources(core PRIVATE
|
||||
GPU_OpenGL.cpp
|
||||
GPU_OpenGL_shaders.h
|
||||
GPU3D_OpenGL.cpp
|
||||
GPU3D_Compute.cpp
|
||||
GPU3D_TexcacheOpenGL.cpp
|
||||
GPU3D_TexcacheOpenGL.h
|
||||
GPU3D_OpenGL_shaders.h
|
||||
OpenGLSupport.cpp)
|
||||
|
||||
target_compile_definitions(core PUBLIC OGLRENDERER_ENABLED)
|
||||
target_sources(core PRIVATE
|
||||
GPU_OpenGL.cpp
|
||||
GPU_OpenGL_shaders.h
|
||||
GPU3D_OpenGL.cpp
|
||||
GPU3D_OpenGL_shaders.h
|
||||
OpenGLSupport.cpp
|
||||
)
|
||||
endif()
|
||||
|
||||
if (ENABLE_JIT)
|
||||
enable_language(ASM)
|
||||
enable_language(ASM)
|
||||
|
||||
target_sources(core PRIVATE
|
||||
ARM_InstrInfo.cpp
|
||||
target_sources(core PRIVATE
|
||||
ARM_InstrInfo.cpp
|
||||
|
||||
ARMJIT.cpp
|
||||
ARMJIT_Memory.cpp
|
||||
ARMJIT_Global.cpp
|
||||
ARMJIT.cpp
|
||||
ARMJIT_Memory.cpp
|
||||
|
||||
dolphin/CommonFuncs.cpp)
|
||||
|
||||
if (WIN32)
|
||||
# Required for memory mapping-related functions introduced in Windows 8
|
||||
target_compile_definitions(core PRIVATE -D_WIN32_WINNT=_WIN32_WINNT_WIN8)
|
||||
target_link_libraries(core PRIVATE onecore)
|
||||
endif()
|
||||
dolphin/CommonFuncs.cpp
|
||||
)
|
||||
|
||||
if (ARCHITECTURE STREQUAL x86_64)
|
||||
target_sources(core PRIVATE
|
||||
dolphin/x64ABI.cpp
|
||||
dolphin/x64CPUDetect.cpp
|
||||
dolphin/x64Emitter.cpp
|
||||
if (ARCHITECTURE STREQUAL x86_64)
|
||||
target_sources(core PRIVATE
|
||||
dolphin/x64ABI.cpp
|
||||
dolphin/x64CPUDetect.cpp
|
||||
dolphin/x64Emitter.cpp
|
||||
|
||||
ARMJIT_x64/ARMJIT_Compiler.cpp
|
||||
ARMJIT_x64/ARMJIT_ALU.cpp
|
||||
ARMJIT_x64/ARMJIT_LoadStore.cpp
|
||||
ARMJIT_x64/ARMJIT_Branch.cpp
|
||||
ARMJIT_x64/ARMJIT_Compiler.cpp
|
||||
ARMJIT_x64/ARMJIT_ALU.cpp
|
||||
ARMJIT_x64/ARMJIT_LoadStore.cpp
|
||||
ARMJIT_x64/ARMJIT_Branch.cpp
|
||||
|
||||
ARMJIT_x64/ARMJIT_Linkage.S)
|
||||
endif()
|
||||
if (ARCHITECTURE STREQUAL ARM64)
|
||||
target_sources(core PRIVATE
|
||||
dolphin/Arm64Emitter.cpp
|
||||
dolphin/MathUtil.cpp
|
||||
ARMJIT_x64/ARMJIT_Linkage.S
|
||||
)
|
||||
endif()
|
||||
if (ARCHITECTURE STREQUAL ARM64)
|
||||
target_sources(core PRIVATE
|
||||
dolphin/Arm64Emitter.cpp
|
||||
dolphin/MathUtil.cpp
|
||||
|
||||
ARMJIT_A64/ARMJIT_Compiler.cpp
|
||||
ARMJIT_A64/ARMJIT_ALU.cpp
|
||||
ARMJIT_A64/ARMJIT_LoadStore.cpp
|
||||
ARMJIT_A64/ARMJIT_Branch.cpp
|
||||
ARMJIT_A64/ARMJIT_Compiler.cpp
|
||||
ARMJIT_A64/ARMJIT_ALU.cpp
|
||||
ARMJIT_A64/ARMJIT_LoadStore.cpp
|
||||
ARMJIT_A64/ARMJIT_Branch.cpp
|
||||
|
||||
ARMJIT_A64/ARMJIT_Linkage.S)
|
||||
endif()
|
||||
ARMJIT_A64/ARMJIT_Linkage.S
|
||||
)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
target_include_directories(core INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}")
|
||||
|
||||
set(MELONDS_VERSION_SUFFIX "$ENV{MELONDS_VERSION_SUFFIX}" CACHE STRING "Suffix to add to displayed melonDS version")
|
||||
option(MELONDS_EMBED_BUILD_INFO "Embed detailed build info into the binary" OFF)
|
||||
set(MELONDS_GIT_BRANCH "$ENV{MELONDS_GIT_BRANCH}" CACHE STRING "The Git branch used for this build")
|
||||
set(MELONDS_GIT_HASH "$ENV{MELONDS_GIT_HASH}" CACHE STRING "The hash of the Git commit")
|
||||
set(MELONDS_BUILD_PROVIDER "$ENV{MELONDS_BUILD_PROVIDER}" CACHE STRING "The name of the provider of this build")
|
||||
|
||||
if (MELONDS_EMBED_BUILD_INFO)
|
||||
target_compile_definitions(core PUBLIC MELONDS_EMBED_BUILD_INFO)
|
||||
if (NOT MELONDS_GIT_BRANCH OR NOT MELONDS_GIT_HASH OR NOT MELONDS_BUILD_PROVIDER)
|
||||
message(FATAL_ERROR "When embedding build information, all fields must be filled out. See src/CMakeLists.txt.")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/version.h.in" "${CMAKE_CURRENT_BINARY_DIR}/version.h")
|
||||
target_sources(core PUBLIC "${CMAKE_CURRENT_BINARY_DIR}/version.h")
|
||||
target_include_directories(core PUBLIC "${CMAKE_CURRENT_BINARY_DIR}")
|
||||
|
||||
set(BUILD_SHARED_LIBS OFF)
|
||||
add_subdirectory(teakra EXCLUDE_FROM_ALL)
|
||||
# Workaround for building teakra with -O0 on Windows either failing or hanging forever
|
||||
target_compile_options(teakra PRIVATE "$<$<CONFIG:DEBUG>:-Og>")
|
||||
target_link_libraries(core PRIVATE teakra)
|
||||
target_link_libraries(core teakra)
|
||||
|
||||
if (NOT MSVC)
|
||||
# MSVC has its own compiler flag syntax; if we ever support it,
|
||||
# be sure to add equivalent flags here.
|
||||
|
||||
target_compile_options(core PUBLIC -fwrapv)
|
||||
if (ENABLE_OGLRENDERER)
|
||||
find_package(PkgConfig REQUIRED)
|
||||
pkg_check_modules(EPOXY REQUIRED epoxy)
|
||||
|
||||
target_compile_options(core PRIVATE "$<$<COMPILE_LANGUAGE:CXX>:-Wno-invalid-offsetof>")
|
||||
# These warnings are excessive, and are only triggered in the ARMJIT code
|
||||
# (which is fundamentally non-portable, so this is fine)
|
||||
endif()
|
||||
|
||||
find_library(m MATH_LIBRARY)
|
||||
|
||||
if (MATH_LIBRARY)
|
||||
target_link_libraries(core PRIVATE ${MATH_LIBRARY})
|
||||
endif()
|
||||
|
||||
if (ENABLE_JIT)
|
||||
target_compile_definitions(core PUBLIC JIT_ENABLED)
|
||||
|
||||
if (ENABLE_JIT_PROFILING)
|
||||
include(../cmake/FindVTune.cmake)
|
||||
add_definitions(-DJIT_PROFILING_ENABLED)
|
||||
target_include_directories(core PRIVATE ${EPOXY_INCLUDE_DIRS})
|
||||
if (WIN32)
|
||||
target_link_libraries(core ole32 comctl32 ws2_32 ${EPOXY_LIBRARIES})
|
||||
elseif (APPLE)
|
||||
target_link_libraries(core ${EPOXY_LIBRARIES})
|
||||
else()
|
||||
target_link_libraries(core rt ${EPOXY_LIBRARIES})
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if (WIN32)
|
||||
target_link_libraries(core PRIVATE ole32 comctl32 wsock32 ws2_32)
|
||||
target_compile_definitions(core PUBLIC WIN32_LEAN_AND_MEAN NOMINMAX)
|
||||
elseif(NOT APPLE AND NOT HAIKU)
|
||||
check_library_exists(rt shm_open "" NEED_LIBRT)
|
||||
if (NEED_LIBRT)
|
||||
target_link_libraries(core PRIVATE rt)
|
||||
endif()
|
||||
elseif(HAIKU)
|
||||
target_link_libraries(core PRIVATE network)
|
||||
else()
|
||||
if (WIN32)
|
||||
target_link_libraries(core ole32 comctl32 ws2_32)
|
||||
elseif (APPLE)
|
||||
target_link_libraries(core)
|
||||
else()
|
||||
target_link_libraries(core rt)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if (ENABLE_JIT_PROFILING)
|
||||
target_include_directories(core PRIVATE "${VTUNE_INCLUDE_DIR}")
|
||||
target_link_libraries(core PRIVATE "${VTUNE_LIBRARY}")
|
||||
target_link_libraries(core jitprofiling)
|
||||
endif()
|
||||
|
||||
#if(CMAKE_BUILD_TYPE MATCHES "Debug")
|
||||
# set(
|
||||
# CMAKE_C_FLAGS
|
||||
# "${CMAKE_C_FLAGS} -fsanitize=undefined -fsanitize=address"
|
||||
# )
|
||||
# target_link_options(core
|
||||
# BEFORE PUBLIC -fsanitize=undefined PUBLIC -fsanitize=address
|
||||
# )
|
||||
#endif()
|
||||
|
||||
|
|
|
|||
118
src/CP15.cpp
118
src/CP15.cpp
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -21,14 +21,11 @@
|
|||
#include "NDS.h"
|
||||
#include "DSi.h"
|
||||
#include "ARM.h"
|
||||
#include "Platform.h"
|
||||
#include "ARMJIT_Memory.h"
|
||||
#include "ARMJIT.h"
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
using Platform::Log;
|
||||
using Platform::LogLevel;
|
||||
#ifdef JIT_ENABLED
|
||||
#include "ARMJIT.h"
|
||||
#include "ARMJIT_Memory.h"
|
||||
#endif
|
||||
|
||||
// access timing for cached regions
|
||||
// this would be an average between cache hits and cache misses
|
||||
|
|
@ -44,7 +41,6 @@ void ARMv5::CP15Reset()
|
|||
CP15Control = 0x2078; // dunno
|
||||
|
||||
RNGSeed = 44203;
|
||||
TraceProcessID = 0;
|
||||
|
||||
DTCMSetting = 0;
|
||||
ITCMSetting = 0;
|
||||
|
|
@ -125,7 +121,9 @@ void ARMv5::UpdateDTCMSetting()
|
|||
|
||||
if (newDTCMBase != DTCMBase || newDTCMMask != DTCMMask)
|
||||
{
|
||||
NDS.JIT.Memory.RemapDTCM(newDTCMBase, newDTCMSize);
|
||||
#ifdef JIT_ENABLED
|
||||
ARMJIT_Memory::RemapDTCM(newDTCMBase, newDTCMSize);
|
||||
#endif
|
||||
DTCMBase = newDTCMBase;
|
||||
DTCMMask = newDTCMMask;
|
||||
}
|
||||
|
|
@ -136,9 +134,6 @@ void ARMv5::UpdateITCMSetting()
|
|||
if (CP15Control & (1<<18))
|
||||
{
|
||||
ITCMSize = 0x200 << ((ITCMSetting >> 1) & 0x1F);
|
||||
#ifdef JIT_ENABLED
|
||||
FastBlockLookupSize = 0;
|
||||
#endif
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -187,14 +182,10 @@ void ARMv5::UpdatePURegion(u32 n)
|
|||
return;
|
||||
}
|
||||
|
||||
// notes:
|
||||
// * min size of a pu region is 4KiB (12 bits)
|
||||
// * size is calculated as size + 1, but the 12 lsb of address space are ignored, therefore we need it as size + 1 - 12, or size - 11
|
||||
// * pu regions are aligned based on their size
|
||||
u32 size = std::max((int)((rgn>>1) & 0x1F) - 11, 0); // obtain the size, subtract 11 and clamp to a min of 0.
|
||||
u32 start = ((rgn >> 12) >> size) << size; // determine the start offset, and use shifts to force alignment with a multiple of the size.
|
||||
u32 end = start + (1<<size); // add 1 left shifted by size to start to determine end point
|
||||
// dont need to bounds check the end point because the force alignment inherently prevents it from breaking
|
||||
u32 start = rgn >> 12;
|
||||
u32 sz = 2 << ((rgn >> 1) & 0x1F);
|
||||
u32 end = start + (sz >> 12);
|
||||
// TODO: check alignment of start
|
||||
|
||||
u8 usermask = 0;
|
||||
u8 privmask = 0;
|
||||
|
|
@ -207,7 +198,7 @@ void ARMv5::UpdatePURegion(u32 n)
|
|||
case 3: privmask |= 0x03; usermask |= 0x03; break;
|
||||
case 5: privmask |= 0x01; break;
|
||||
case 6: privmask |= 0x01; usermask |= 0x01; break;
|
||||
default: Log(LogLevel::Warn, "!! BAD DATARW VALUE %d\n", datarw&0xF);
|
||||
default: printf("!! BAD DATARW VALUE %d\n", datarw&0xF);
|
||||
}
|
||||
|
||||
switch (coderw)
|
||||
|
|
@ -218,7 +209,7 @@ void ARMv5::UpdatePURegion(u32 n)
|
|||
case 3: privmask |= 0x04; usermask |= 0x04; break;
|
||||
case 5: privmask |= 0x04; break;
|
||||
case 6: privmask |= 0x04; usermask |= 0x04; break;
|
||||
default: Log(LogLevel::Warn, "!! BAD CODERW VALUE %d\n", datarw&0xF);
|
||||
default: printf("!! BAD CODERW VALUE %d\n", datarw&0xF);
|
||||
}
|
||||
|
||||
if (datacache & 0x1)
|
||||
|
|
@ -239,17 +230,8 @@ void ARMv5::UpdatePURegion(u32 n)
|
|||
usermask |= 0x40;
|
||||
}
|
||||
|
||||
Log(
|
||||
LogLevel::Debug,
|
||||
"PU region %d: %08X-%08X, user=%02X priv=%02X, %08X/%08X\n",
|
||||
n,
|
||||
start << 12,
|
||||
(end << 12) - 1,
|
||||
usermask,
|
||||
privmask,
|
||||
PU_DataRW,
|
||||
PU_CodeRW
|
||||
);
|
||||
printf("PU region %d: %08X-%08X, user=%02X priv=%02X\n", n, start<<12, end<<12, usermask, privmask);
|
||||
printf("%08X/%08X\n", PU_DataRW, PU_CodeRW);
|
||||
|
||||
for (u32 i = start; i < end; i++)
|
||||
{
|
||||
|
|
@ -300,7 +282,7 @@ void ARMv5::UpdateRegionTimings(u32 addrstart, u32 addrend)
|
|||
for (u32 i = addrstart; i < addrend; i++)
|
||||
{
|
||||
u8 pu = PU_Map[i];
|
||||
u8* bustimings = NDS.ARM9MemTimings[i >> 2];
|
||||
u8* bustimings = NDS::ARM9MemTimings[i >> 2];
|
||||
|
||||
if (pu & 0x40)
|
||||
{
|
||||
|
|
@ -308,7 +290,7 @@ void ARMv5::UpdateRegionTimings(u32 addrstart, u32 addrend)
|
|||
}
|
||||
else
|
||||
{
|
||||
MemTimings[i][0] = bustimings[2] << NDS.ARM9ClockShift;
|
||||
MemTimings[i][0] = bustimings[2] << NDS::ARM9ClockShift;
|
||||
}
|
||||
|
||||
if (pu & 0x10)
|
||||
|
|
@ -319,9 +301,9 @@ void ARMv5::UpdateRegionTimings(u32 addrstart, u32 addrend)
|
|||
}
|
||||
else
|
||||
{
|
||||
MemTimings[i][1] = bustimings[0] << NDS.ARM9ClockShift;
|
||||
MemTimings[i][2] = bustimings[2] << NDS.ARM9ClockShift;
|
||||
MemTimings[i][3] = bustimings[3] << NDS.ARM9ClockShift;
|
||||
MemTimings[i][1] = bustimings[0] << NDS::ARM9ClockShift;
|
||||
MemTimings[i][2] = bustimings[2] << NDS::ARM9ClockShift;
|
||||
MemTimings[i][3] = bustimings[3] << NDS::ARM9ClockShift;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -393,14 +375,14 @@ void ARMv5::ICacheLookup(u32 addr)
|
|||
else
|
||||
{
|
||||
for (int i = 0; i < 32; i+=4)
|
||||
*(u32*)&ptr[i] = NDS.ARM9Read32(addr+i);
|
||||
*(u32*)&ptr[i] = NDS::ARM9Read32(addr+i);
|
||||
}
|
||||
|
||||
ICacheTags[line] = tag;
|
||||
|
||||
// ouch :/
|
||||
//printf("cache miss %08X: %d/%d\n", addr, NDS::ARM9MemTimings[addr >> 14][2], NDS::ARM9MemTimings[addr >> 14][3]);
|
||||
CodeCycles = (NDS.ARM9MemTimings[addr >> 14][2] + (NDS.ARM9MemTimings[addr >> 14][3] * 7)) << NDS.ARM9ClockShift;
|
||||
CodeCycles = (NDS::ARM9MemTimings[addr >> 14][2] + (NDS::ARM9MemTimings[addr >> 14][3] * 7)) << NDS::ARM9ClockShift;
|
||||
CurICacheLine = ptr;
|
||||
}
|
||||
|
||||
|
|
@ -458,7 +440,7 @@ void ARMv5::CP15Write(u32 id, u32 val)
|
|||
{
|
||||
UpdatePURegions((old & 0x1) != (val & 0x1));
|
||||
}
|
||||
if (val & (1<<7)) Log(LogLevel::Warn, "!!!! ARM9 BIG ENDIAN MODE. VERY BAD. SHIT GONNA ASPLODE NOW\n");
|
||||
if (val & (1<<7)) printf("!!!! ARM9 BIG ENDIAN MODE. VERY BAD. SHIT GONNA ASPLODE NOW\n");
|
||||
if (val & (1<<13)) ExceptionBase = 0xFFFF0000;
|
||||
else ExceptionBase = 0x00000000;
|
||||
}
|
||||
|
|
@ -579,21 +561,11 @@ void ARMv5::CP15Write(u32 id, u32 val)
|
|||
case 0x661:
|
||||
case 0x670:
|
||||
case 0x671:
|
||||
char log_output[1024];
|
||||
PU_Region[(id >> 4) & 0xF] = val;
|
||||
|
||||
std::snprintf(log_output,
|
||||
sizeof(log_output),
|
||||
"PU: region %d = %08X : %s, start: %08X size: %02X\n",
|
||||
(id >> 4) & 0xF,
|
||||
val,
|
||||
val & 1 ? "enabled" : "disabled",
|
||||
val & 0xFFFFF000,
|
||||
(val & 0x3E) >> 1
|
||||
);
|
||||
Log(LogLevel::Debug, "%s", log_output);
|
||||
// Some implementations of Log imply a newline, so we build up the line before printing it
|
||||
|
||||
printf("PU: region %d = %08X : ", (id>>4)&0xF, val);
|
||||
printf("%s, ", val&1 ? "enabled":"disabled");
|
||||
printf("%08X-", val&0xFFFFF000);
|
||||
printf("%08X\n", (val&0xFFFFF000)+(2<<((val&0x3E)>>1)));
|
||||
// TODO: smarter region update for this?
|
||||
UpdatePURegions(true);
|
||||
return;
|
||||
|
|
@ -614,7 +586,7 @@ void ARMv5::CP15Write(u32 id, u32 val)
|
|||
//Halt(255);
|
||||
return;
|
||||
case 0x752:
|
||||
Log(LogLevel::Warn, "CP15: ICACHE INVALIDATE WEIRD. %08X\n", val);
|
||||
printf("CP15: ICACHE INVALIDATE WEIRD. %08X\n", val);
|
||||
//Halt(255);
|
||||
return;
|
||||
|
||||
|
|
@ -644,10 +616,6 @@ void ARMv5::CP15Write(u32 id, u32 val)
|
|||
UpdateITCMSetting();
|
||||
return;
|
||||
|
||||
case 0xD01:
|
||||
TraceProcessID = val;
|
||||
return;
|
||||
|
||||
case 0xF00:
|
||||
//printf("cache debug index register %08X\n", val);
|
||||
return;
|
||||
|
|
@ -674,10 +642,10 @@ void ARMv5::CP15Write(u32 id, u32 val)
|
|||
return;
|
||||
|
||||
if ((id & 0xF00) != 0x700)
|
||||
Log(LogLevel::Debug, "unknown CP15 write op %03X %08X\n", id, val);
|
||||
printf("unknown CP15 write op %03X %08X\n", id, val);
|
||||
}
|
||||
|
||||
u32 ARMv5::CP15Read(u32 id) const
|
||||
u32 ARMv5::CP15Read(u32 id)
|
||||
{
|
||||
//printf("CP15 read op %03X %08X\n", id, NDS::ARM9->R[15]);
|
||||
|
||||
|
|
@ -765,15 +733,12 @@ u32 ARMv5::CP15Read(u32 id) const
|
|||
return DTCMSetting;
|
||||
case 0x911:
|
||||
return ITCMSetting;
|
||||
|
||||
case 0xD01:
|
||||
return TraceProcessID;
|
||||
}
|
||||
|
||||
if ((id & 0xF00) == 0xF00) // test/debug shit?
|
||||
return 0;
|
||||
|
||||
Log(LogLevel::Debug, "unknown CP15 read op %03X\n", id);
|
||||
printf("unknown CP15 read op %03X\n", id);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -935,7 +900,9 @@ void ARMv5::DataWrite8(u32 addr, u8 val)
|
|||
{
|
||||
DataCycles = 1;
|
||||
*(u8*)&ITCM[addr & (ITCMPhysicalSize - 1)] = val;
|
||||
NDS.JIT.CheckAndInvalidate<0, ARMJIT_Memory::memregion_ITCM>(addr);
|
||||
#ifdef JIT_ENABLED
|
||||
ARMJIT::CheckAndInvalidate<0, ARMJIT_Memory::memregion_ITCM>(addr);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
if ((addr & DTCMMask) == DTCMBase)
|
||||
|
|
@ -965,7 +932,9 @@ void ARMv5::DataWrite16(u32 addr, u16 val)
|
|||
{
|
||||
DataCycles = 1;
|
||||
*(u16*)&ITCM[addr & (ITCMPhysicalSize - 1)] = val;
|
||||
NDS.JIT.CheckAndInvalidate<0, ARMJIT_Memory::memregion_ITCM>(addr);
|
||||
#ifdef JIT_ENABLED
|
||||
ARMJIT::CheckAndInvalidate<0, ARMJIT_Memory::memregion_ITCM>(addr);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
if ((addr & DTCMMask) == DTCMBase)
|
||||
|
|
@ -995,7 +964,9 @@ void ARMv5::DataWrite32(u32 addr, u32 val)
|
|||
{
|
||||
DataCycles = 1;
|
||||
*(u32*)&ITCM[addr & (ITCMPhysicalSize - 1)] = val;
|
||||
NDS.JIT.CheckAndInvalidate<0, ARMJIT_Memory::memregion_ITCM>(addr);
|
||||
#ifdef JIT_ENABLED
|
||||
ARMJIT::CheckAndInvalidate<0, ARMJIT_Memory::memregion_ITCM>(addr);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
if ((addr & DTCMMask) == DTCMBase)
|
||||
|
|
@ -1018,7 +989,7 @@ void ARMv5::DataWrite32S(u32 addr, u32 val)
|
|||
DataCycles += 1;
|
||||
*(u32*)&ITCM[addr & (ITCMPhysicalSize - 1)] = val;
|
||||
#ifdef JIT_ENABLED
|
||||
NDS.JIT.CheckAndInvalidate<0, ARMJIT_Memory::memregion_ITCM>(addr);
|
||||
ARMJIT::CheckAndInvalidate<0, ARMJIT_Memory::memregion_ITCM>(addr);
|
||||
#endif
|
||||
return;
|
||||
}
|
||||
|
|
@ -1033,7 +1004,7 @@ void ARMv5::DataWrite32S(u32 addr, u32 val)
|
|||
DataCycles += MemTimings[addr >> 12][3];
|
||||
}
|
||||
|
||||
void ARMv5::GetCodeMemRegion(u32 addr, MemRegion* region)
|
||||
void ARMv5::GetCodeMemRegion(u32 addr, NDS::MemRegion* region)
|
||||
{
|
||||
/*if (addr < ITCMSize)
|
||||
{
|
||||
|
|
@ -1042,7 +1013,6 @@ void ARMv5::GetCodeMemRegion(u32 addr, MemRegion* region)
|
|||
return;
|
||||
}*/
|
||||
|
||||
NDS.ARM9GetMemRegion(addr, false, &CodeMem);
|
||||
GetMemRegion(addr, false, &CodeMem);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -20,9 +20,10 @@
|
|||
|
||||
// http://www.codeproject.com/KB/recipes/crc32_large.aspx
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
constexpr u32 _reflect(u32 refl, char ch)
|
||||
u32 crctable[256];
|
||||
bool tableinited = false;
|
||||
|
||||
u32 _reflect(u32 refl, char ch)
|
||||
{
|
||||
u32 value = 0;
|
||||
|
||||
|
|
@ -36,33 +37,33 @@ constexpr u32 _reflect(u32 refl, char ch)
|
|||
return value;
|
||||
}
|
||||
|
||||
constexpr auto GetCRC32Table()
|
||||
void _inittable()
|
||||
{
|
||||
std::array<u32, 256> Crc32Table { 0 };
|
||||
u32 polynomial = 0x04C11DB7;
|
||||
|
||||
for (int i = 0; i < 0x100; i++)
|
||||
{
|
||||
Crc32Table[i] = _reflect(i, 8) << 24;
|
||||
crctable[i] = _reflect(i, 8) << 24;
|
||||
|
||||
for (int j = 0; j < 8; j++)
|
||||
Crc32Table[i] = (Crc32Table[i] << 1) ^ (Crc32Table[i] & (1 << 31) ? polynomial : 0);
|
||||
crctable[i] = (crctable[i] << 1) ^ (crctable[i] & (1 << 31) ? polynomial : 0);
|
||||
|
||||
Crc32Table[i] = _reflect(Crc32Table[i], 32);
|
||||
crctable[i] = _reflect(crctable[i], 32);
|
||||
}
|
||||
return Crc32Table;
|
||||
}
|
||||
|
||||
u32 CRC32(const u8 *data, int len, u32 start)
|
||||
u32 CRC32(u8 *data, int len, u32 start)
|
||||
{
|
||||
auto Crc32Table = GetCRC32Table();
|
||||
if (!tableinited)
|
||||
{
|
||||
_inittable();
|
||||
tableinited = true;
|
||||
}
|
||||
|
||||
u32 crc = start ^ 0xFFFFFFFF;
|
||||
|
||||
while (len--)
|
||||
crc = (crc >> 8) ^ Crc32Table[(crc & 0xFF) ^ *data++];
|
||||
crc = (crc >> 8) ^ crctable[(crc & 0xFF) ^ *data++];
|
||||
|
||||
return (crc ^ 0xFFFFFFFF);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,13 +19,8 @@
|
|||
#ifndef CRC32_H
|
||||
#define CRC32_H
|
||||
|
||||
#include <array>
|
||||
|
||||
#include "types.h"
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
u32 CRC32(const u8* data, int len, u32 start=0);
|
||||
}
|
||||
u32 CRC32(u8* data, int len, u32 start=0);
|
||||
|
||||
#endif // CRC32_H
|
||||
|
|
|
|||
185
src/DMA.cpp
185
src/DMA.cpp
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -21,14 +21,9 @@
|
|||
#include "DSi.h"
|
||||
#include "DMA.h"
|
||||
#include "GPU.h"
|
||||
#include "GPU3D.h"
|
||||
#include "DMA_Timings.h"
|
||||
#include "Platform.h"
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
using Platform::Log;
|
||||
using Platform::LogLevel;
|
||||
|
||||
|
||||
// DMA TIMINGS
|
||||
//
|
||||
|
|
@ -50,17 +45,21 @@ using Platform::LogLevel;
|
|||
// TODO: timings are nonseq when address is fixed/decrementing
|
||||
|
||||
|
||||
DMA::DMA(u32 cpu, u32 num, melonDS::NDS& nds) :
|
||||
CPU(cpu),
|
||||
Num(num),
|
||||
NDS(nds)
|
||||
DMA::DMA(u32 cpu, u32 num)
|
||||
{
|
||||
CPU = cpu;
|
||||
Num = num;
|
||||
|
||||
if (cpu == 0)
|
||||
CountMask = 0x001FFFFF;
|
||||
else
|
||||
CountMask = (num==3 ? 0x0000FFFF : 0x00003FFF);
|
||||
}
|
||||
|
||||
DMA::~DMA()
|
||||
{
|
||||
}
|
||||
|
||||
void DMA::Reset()
|
||||
{
|
||||
SrcAddr = 0;
|
||||
|
|
@ -78,10 +77,8 @@ void DMA::Reset()
|
|||
Stall = false;
|
||||
|
||||
Running = false;
|
||||
Executing = false;
|
||||
InProgress = false;
|
||||
MRAMBurstCount = 0;
|
||||
MRAMBurstTable = DMATiming::MRAMDummy;
|
||||
}
|
||||
|
||||
void DMA::DoSavestate(Savestate* file)
|
||||
|
|
@ -106,10 +103,6 @@ void DMA::DoSavestate(Savestate* file)
|
|||
file->Bool32(&InProgress);
|
||||
file->Bool32(&IsGXFIFODMA);
|
||||
file->Var32(&MRAMBurstCount);
|
||||
file->Bool32(&Executing);
|
||||
file->Bool32(&Stall);
|
||||
|
||||
file->VarArray(MRAMBurstTable.data(), sizeof(MRAMBurstTable));
|
||||
}
|
||||
|
||||
void DMA::WriteCnt(u32 val)
|
||||
|
|
@ -146,10 +139,10 @@ void DMA::WriteCnt(u32 val)
|
|||
if ((StartMode & 0x7) == 0)
|
||||
Start();
|
||||
else if (StartMode == 0x07)
|
||||
NDS.GPU.GPU3D.CheckFIFODMA();
|
||||
GPU3D::CheckFIFODMA();
|
||||
|
||||
if (StartMode==0x06 || StartMode==0x13)
|
||||
Log(LogLevel::Warn, "UNIMPLEMENTED ARM%d DMA%d START MODE %02X, %08X->%08X\n", CPU?7:9, Num, StartMode, SrcAddr, DstAddr);
|
||||
printf("UNIMPLEMENTED ARM%d DMA%d START MODE %02X, %08X->%08X\n", CPU?7:9, Num, StartMode, SrcAddr, DstAddr);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -193,7 +186,7 @@ void DMA::Start()
|
|||
MRAMBurstTable = DMATiming::MRAMDummy;
|
||||
|
||||
InProgress = true;
|
||||
NDS.StopCPU(CPU, 1<<Num);
|
||||
NDS::StopCPU(CPU, 1<<Num);
|
||||
}
|
||||
|
||||
u32 DMA::UnitTimings9_16(bool burststart)
|
||||
|
|
@ -201,18 +194,18 @@ u32 DMA::UnitTimings9_16(bool burststart)
|
|||
u32 src_id = CurSrcAddr >> 14;
|
||||
u32 dst_id = CurDstAddr >> 14;
|
||||
|
||||
u32 src_rgn = NDS.ARM9Regions[src_id];
|
||||
u32 dst_rgn = NDS.ARM9Regions[dst_id];
|
||||
u32 src_rgn = NDS::ARM9Regions[src_id];
|
||||
u32 dst_rgn = NDS::ARM9Regions[dst_id];
|
||||
|
||||
u32 src_n, src_s, dst_n, dst_s;
|
||||
src_n = NDS.ARM9MemTimings[src_id][4];
|
||||
src_s = NDS.ARM9MemTimings[src_id][5];
|
||||
dst_n = NDS.ARM9MemTimings[dst_id][4];
|
||||
dst_s = NDS.ARM9MemTimings[dst_id][5];
|
||||
src_n = NDS::ARM9MemTimings[src_id][4];
|
||||
src_s = NDS::ARM9MemTimings[src_id][5];
|
||||
dst_n = NDS::ARM9MemTimings[dst_id][4];
|
||||
dst_s = NDS::ARM9MemTimings[dst_id][5];
|
||||
|
||||
if (src_rgn == Mem9_MainRAM)
|
||||
if (src_rgn == NDS::Mem9_MainRAM)
|
||||
{
|
||||
if (dst_rgn == Mem9_MainRAM)
|
||||
if (dst_rgn == NDS::Mem9_MainRAM)
|
||||
return 16;
|
||||
|
||||
if (SrcAddrInc > 0)
|
||||
|
|
@ -221,7 +214,7 @@ u32 DMA::UnitTimings9_16(bool burststart)
|
|||
{
|
||||
MRAMBurstCount = 0;
|
||||
|
||||
if (dst_rgn == Mem9_GBAROM)
|
||||
if (dst_rgn == NDS::Mem9_GBAROM)
|
||||
{
|
||||
if (dst_s == 4)
|
||||
MRAMBurstTable = DMATiming::MRAMRead16Bursts[1];
|
||||
|
|
@ -242,7 +235,7 @@ u32 DMA::UnitTimings9_16(bool burststart)
|
|||
(burststart ? dst_n : dst_s);
|
||||
}
|
||||
}
|
||||
else if (dst_rgn == Mem9_MainRAM)
|
||||
else if (dst_rgn == NDS::Mem9_MainRAM)
|
||||
{
|
||||
if (DstAddrInc > 0)
|
||||
{
|
||||
|
|
@ -250,7 +243,7 @@ u32 DMA::UnitTimings9_16(bool burststart)
|
|||
{
|
||||
MRAMBurstCount = 0;
|
||||
|
||||
if (src_rgn == Mem9_GBAROM)
|
||||
if (src_rgn == NDS::Mem9_GBAROM)
|
||||
{
|
||||
if (src_s == 4)
|
||||
MRAMBurstTable = DMATiming::MRAMWrite16Bursts[1];
|
||||
|
|
@ -287,18 +280,18 @@ u32 DMA::UnitTimings9_32(bool burststart)
|
|||
u32 src_id = CurSrcAddr >> 14;
|
||||
u32 dst_id = CurDstAddr >> 14;
|
||||
|
||||
u32 src_rgn = NDS.ARM9Regions[src_id];
|
||||
u32 dst_rgn = NDS.ARM9Regions[dst_id];
|
||||
u32 src_rgn = NDS::ARM9Regions[src_id];
|
||||
u32 dst_rgn = NDS::ARM9Regions[dst_id];
|
||||
|
||||
u32 src_n, src_s, dst_n, dst_s;
|
||||
src_n = NDS.ARM9MemTimings[src_id][6];
|
||||
src_s = NDS.ARM9MemTimings[src_id][7];
|
||||
dst_n = NDS.ARM9MemTimings[dst_id][6];
|
||||
dst_s = NDS.ARM9MemTimings[dst_id][7];
|
||||
src_n = NDS::ARM9MemTimings[src_id][6];
|
||||
src_s = NDS::ARM9MemTimings[src_id][7];
|
||||
dst_n = NDS::ARM9MemTimings[dst_id][6];
|
||||
dst_s = NDS::ARM9MemTimings[dst_id][7];
|
||||
|
||||
if (src_rgn == Mem9_MainRAM)
|
||||
if (src_rgn == NDS::Mem9_MainRAM)
|
||||
{
|
||||
if (dst_rgn == Mem9_MainRAM)
|
||||
if (dst_rgn == NDS::Mem9_MainRAM)
|
||||
return 18;
|
||||
|
||||
if (SrcAddrInc > 0)
|
||||
|
|
@ -307,7 +300,7 @@ u32 DMA::UnitTimings9_32(bool burststart)
|
|||
{
|
||||
MRAMBurstCount = 0;
|
||||
|
||||
if (dst_rgn == Mem9_GBAROM)
|
||||
if (dst_rgn == NDS::Mem9_GBAROM)
|
||||
{
|
||||
if (dst_s == 8)
|
||||
MRAMBurstTable = DMATiming::MRAMRead32Bursts[2];
|
||||
|
|
@ -330,7 +323,7 @@ u32 DMA::UnitTimings9_32(bool burststart)
|
|||
(burststart ? dst_n : dst_s);
|
||||
}
|
||||
}
|
||||
else if (dst_rgn == Mem9_MainRAM)
|
||||
else if (dst_rgn == NDS::Mem9_MainRAM)
|
||||
{
|
||||
if (DstAddrInc > 0)
|
||||
{
|
||||
|
|
@ -338,7 +331,7 @@ u32 DMA::UnitTimings9_32(bool burststart)
|
|||
{
|
||||
MRAMBurstCount = 0;
|
||||
|
||||
if (src_rgn == Mem9_GBAROM)
|
||||
if (src_rgn == NDS::Mem9_GBAROM)
|
||||
{
|
||||
if (src_s == 8)
|
||||
MRAMBurstTable = DMATiming::MRAMWrite32Bursts[2];
|
||||
|
|
@ -379,18 +372,18 @@ u32 DMA::UnitTimings7_16(bool burststart)
|
|||
u32 src_id = CurSrcAddr >> 15;
|
||||
u32 dst_id = CurDstAddr >> 15;
|
||||
|
||||
u32 src_rgn = NDS.ARM7Regions[src_id];
|
||||
u32 dst_rgn = NDS.ARM7Regions[dst_id];
|
||||
u32 src_rgn = NDS::ARM7Regions[src_id];
|
||||
u32 dst_rgn = NDS::ARM7Regions[dst_id];
|
||||
|
||||
u32 src_n, src_s, dst_n, dst_s;
|
||||
src_n = NDS.ARM7MemTimings[src_id][0];
|
||||
src_s = NDS.ARM7MemTimings[src_id][1];
|
||||
dst_n = NDS.ARM7MemTimings[dst_id][0];
|
||||
dst_s = NDS.ARM7MemTimings[dst_id][1];
|
||||
src_n = NDS::ARM7MemTimings[src_id][0];
|
||||
src_s = NDS::ARM7MemTimings[src_id][1];
|
||||
dst_n = NDS::ARM7MemTimings[dst_id][0];
|
||||
dst_s = NDS::ARM7MemTimings[dst_id][1];
|
||||
|
||||
if (src_rgn == Mem7_MainRAM)
|
||||
if (src_rgn == NDS::Mem7_MainRAM)
|
||||
{
|
||||
if (dst_rgn == Mem7_MainRAM)
|
||||
if (dst_rgn == NDS::Mem7_MainRAM)
|
||||
return 16;
|
||||
|
||||
if (SrcAddrInc > 0)
|
||||
|
|
@ -399,7 +392,7 @@ u32 DMA::UnitTimings7_16(bool burststart)
|
|||
{
|
||||
MRAMBurstCount = 0;
|
||||
|
||||
if (dst_rgn == Mem7_GBAROM || dst_rgn == Mem7_Wifi0 || dst_rgn == Mem7_Wifi1)
|
||||
if (dst_rgn == NDS::Mem7_GBAROM || dst_rgn == NDS::Mem7_Wifi0 || dst_rgn == NDS::Mem7_Wifi1)
|
||||
{
|
||||
if (dst_s == 4)
|
||||
MRAMBurstTable = DMATiming::MRAMRead16Bursts[1];
|
||||
|
|
@ -420,7 +413,7 @@ u32 DMA::UnitTimings7_16(bool burststart)
|
|||
(burststart ? dst_n : dst_s);
|
||||
}
|
||||
}
|
||||
else if (dst_rgn == Mem7_MainRAM)
|
||||
else if (dst_rgn == NDS::Mem7_MainRAM)
|
||||
{
|
||||
if (DstAddrInc > 0)
|
||||
{
|
||||
|
|
@ -428,7 +421,7 @@ u32 DMA::UnitTimings7_16(bool burststart)
|
|||
{
|
||||
MRAMBurstCount = 0;
|
||||
|
||||
if (src_rgn == Mem7_GBAROM || src_rgn == Mem7_Wifi0 || src_rgn == Mem7_Wifi1)
|
||||
if (src_rgn == NDS::Mem7_GBAROM || src_rgn == NDS::Mem7_Wifi0 || src_rgn == NDS::Mem7_Wifi1)
|
||||
{
|
||||
if (src_s == 4)
|
||||
MRAMBurstTable = DMATiming::MRAMWrite16Bursts[1];
|
||||
|
|
@ -465,18 +458,18 @@ u32 DMA::UnitTimings7_32(bool burststart)
|
|||
u32 src_id = CurSrcAddr >> 15;
|
||||
u32 dst_id = CurDstAddr >> 15;
|
||||
|
||||
u32 src_rgn = NDS.ARM7Regions[src_id];
|
||||
u32 dst_rgn = NDS.ARM7Regions[dst_id];
|
||||
u32 src_rgn = NDS::ARM7Regions[src_id];
|
||||
u32 dst_rgn = NDS::ARM7Regions[dst_id];
|
||||
|
||||
u32 src_n, src_s, dst_n, dst_s;
|
||||
src_n = NDS.ARM7MemTimings[src_id][2];
|
||||
src_s = NDS.ARM7MemTimings[src_id][3];
|
||||
dst_n = NDS.ARM7MemTimings[dst_id][2];
|
||||
dst_s = NDS.ARM7MemTimings[dst_id][3];
|
||||
src_n = NDS::ARM7MemTimings[src_id][2];
|
||||
src_s = NDS::ARM7MemTimings[src_id][3];
|
||||
dst_n = NDS::ARM7MemTimings[dst_id][2];
|
||||
dst_s = NDS::ARM7MemTimings[dst_id][3];
|
||||
|
||||
if (src_rgn == Mem7_MainRAM)
|
||||
if (src_rgn == NDS::Mem7_MainRAM)
|
||||
{
|
||||
if (dst_rgn == Mem7_MainRAM)
|
||||
if (dst_rgn == NDS::Mem7_MainRAM)
|
||||
return 18;
|
||||
|
||||
if (SrcAddrInc > 0)
|
||||
|
|
@ -485,7 +478,7 @@ u32 DMA::UnitTimings7_32(bool burststart)
|
|||
{
|
||||
MRAMBurstCount = 0;
|
||||
|
||||
if (dst_rgn == Mem7_GBAROM || dst_rgn == Mem7_Wifi0 || dst_rgn == Mem7_Wifi1)
|
||||
if (dst_rgn == NDS::Mem7_GBAROM || dst_rgn == NDS::Mem7_Wifi0 || dst_rgn == NDS::Mem7_Wifi1)
|
||||
{
|
||||
if (dst_s == 8)
|
||||
MRAMBurstTable = DMATiming::MRAMRead32Bursts[2];
|
||||
|
|
@ -508,7 +501,7 @@ u32 DMA::UnitTimings7_32(bool burststart)
|
|||
(burststart ? dst_n : dst_s);
|
||||
}
|
||||
}
|
||||
else if (dst_rgn == Mem7_MainRAM)
|
||||
else if (dst_rgn == NDS::Mem7_MainRAM)
|
||||
{
|
||||
if (DstAddrInc > 0)
|
||||
{
|
||||
|
|
@ -516,7 +509,7 @@ u32 DMA::UnitTimings7_32(bool burststart)
|
|||
{
|
||||
MRAMBurstCount = 0;
|
||||
|
||||
if (src_rgn == Mem7_GBAROM || src_rgn == Mem7_Wifi0 || src_rgn == Mem7_Wifi1)
|
||||
if (src_rgn == NDS::Mem7_GBAROM || src_rgn == NDS::Mem7_Wifi0 || src_rgn == NDS::Mem7_Wifi1)
|
||||
{
|
||||
if (src_s == 8)
|
||||
MRAMBurstTable = DMATiming::MRAMWrite32Bursts[2];
|
||||
|
|
@ -550,9 +543,10 @@ u32 DMA::UnitTimings7_32(bool burststart)
|
|||
}
|
||||
}
|
||||
|
||||
template <int ConsoleType>
|
||||
void DMA::Run9()
|
||||
{
|
||||
if (NDS.ARM9Timestamp >= NDS.ARM9Target) return;
|
||||
if (NDS::ARM9Timestamp >= NDS::ARM9Target) return;
|
||||
|
||||
Executing = true;
|
||||
|
||||
|
|
@ -564,34 +558,40 @@ void DMA::Run9()
|
|||
{
|
||||
while (IterCount > 0 && !Stall)
|
||||
{
|
||||
NDS.ARM9Timestamp += (UnitTimings9_16(burststart) << NDS.ARM9ClockShift);
|
||||
NDS::ARM9Timestamp += (UnitTimings9_16(burststart) << NDS::ARM9ClockShift);
|
||||
burststart = false;
|
||||
|
||||
NDS.ARM9Write16(CurDstAddr, NDS.ARM9Read16(CurSrcAddr));
|
||||
if (ConsoleType == 1)
|
||||
DSi::ARM9Write16(CurDstAddr, DSi::ARM9Read16(CurSrcAddr));
|
||||
else
|
||||
NDS::ARM9Write16(CurDstAddr, NDS::ARM9Read16(CurSrcAddr));
|
||||
|
||||
CurSrcAddr += SrcAddrInc<<1;
|
||||
CurDstAddr += DstAddrInc<<1;
|
||||
IterCount--;
|
||||
RemCount--;
|
||||
|
||||
if (NDS.ARM9Timestamp >= NDS.ARM9Target) break;
|
||||
if (NDS::ARM9Timestamp >= NDS::ARM9Target) break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (IterCount > 0 && !Stall)
|
||||
{
|
||||
NDS.ARM9Timestamp += (UnitTimings9_32(burststart) << NDS.ARM9ClockShift);
|
||||
NDS::ARM9Timestamp += (UnitTimings9_32(burststart) << NDS::ARM9ClockShift);
|
||||
burststart = false;
|
||||
|
||||
NDS.ARM9Write32(CurDstAddr, NDS.ARM9Read32(CurSrcAddr));
|
||||
if (ConsoleType == 1)
|
||||
DSi::ARM9Write32(CurDstAddr, DSi::ARM9Read32(CurSrcAddr));
|
||||
else
|
||||
NDS::ARM9Write32(CurDstAddr, NDS::ARM9Read32(CurSrcAddr));
|
||||
|
||||
CurSrcAddr += SrcAddrInc<<2;
|
||||
CurDstAddr += DstAddrInc<<2;
|
||||
IterCount--;
|
||||
RemCount--;
|
||||
|
||||
if (NDS.ARM9Timestamp >= NDS.ARM9Target) break;
|
||||
if (NDS::ARM9Timestamp >= NDS::ARM9Target) break;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -603,10 +603,10 @@ void DMA::Run9()
|
|||
if (IterCount == 0)
|
||||
{
|
||||
Running = 0;
|
||||
NDS.ResumeCPU(0, 1<<Num);
|
||||
NDS::ResumeCPU(0, 1<<Num);
|
||||
|
||||
if (StartMode == 0x07)
|
||||
NDS.GPU.GPU3D.CheckFIFODMA();
|
||||
GPU3D::CheckFIFODMA();
|
||||
}
|
||||
|
||||
return;
|
||||
|
|
@ -616,16 +616,17 @@ void DMA::Run9()
|
|||
Cnt &= ~(1<<31);
|
||||
|
||||
if (Cnt & (1<<30))
|
||||
NDS.SetIRQ(0, IRQ_DMA0 + Num);
|
||||
NDS::SetIRQ(0, NDS::IRQ_DMA0 + Num);
|
||||
|
||||
Running = 0;
|
||||
InProgress = false;
|
||||
NDS.ResumeCPU(0, 1<<Num);
|
||||
NDS::ResumeCPU(0, 1<<Num);
|
||||
}
|
||||
|
||||
template <int ConsoleType>
|
||||
void DMA::Run7()
|
||||
{
|
||||
if (NDS.ARM7Timestamp >= NDS.ARM7Target) return;
|
||||
if (NDS::ARM7Timestamp >= NDS::ARM7Target) return;
|
||||
|
||||
Executing = true;
|
||||
|
||||
|
|
@ -637,34 +638,40 @@ void DMA::Run7()
|
|||
{
|
||||
while (IterCount > 0 && !Stall)
|
||||
{
|
||||
NDS.ARM7Timestamp += UnitTimings7_16(burststart);
|
||||
NDS::ARM7Timestamp += UnitTimings7_16(burststart);
|
||||
burststart = false;
|
||||
|
||||
NDS.ARM7Write16(CurDstAddr, NDS.ARM7Read16(CurSrcAddr));
|
||||
if (ConsoleType == 1)
|
||||
DSi::ARM7Write16(CurDstAddr, DSi::ARM7Read16(CurSrcAddr));
|
||||
else
|
||||
NDS::ARM7Write16(CurDstAddr, NDS::ARM7Read16(CurSrcAddr));
|
||||
|
||||
CurSrcAddr += SrcAddrInc<<1;
|
||||
CurDstAddr += DstAddrInc<<1;
|
||||
IterCount--;
|
||||
RemCount--;
|
||||
|
||||
if (NDS.ARM7Timestamp >= NDS.ARM7Target) break;
|
||||
if (NDS::ARM7Timestamp >= NDS::ARM7Target) break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (IterCount > 0 && !Stall)
|
||||
{
|
||||
NDS.ARM7Timestamp += UnitTimings7_32(burststart);
|
||||
NDS::ARM7Timestamp += UnitTimings7_32(burststart);
|
||||
burststart = false;
|
||||
|
||||
NDS.ARM7Write32(CurDstAddr, NDS.ARM7Read32(CurSrcAddr));
|
||||
if (ConsoleType == 1)
|
||||
DSi::ARM7Write32(CurDstAddr, DSi::ARM7Read32(CurSrcAddr));
|
||||
else
|
||||
NDS::ARM7Write32(CurDstAddr, NDS::ARM7Read32(CurSrcAddr));
|
||||
|
||||
CurSrcAddr += SrcAddrInc<<2;
|
||||
CurDstAddr += DstAddrInc<<2;
|
||||
IterCount--;
|
||||
RemCount--;
|
||||
|
||||
if (NDS.ARM7Timestamp >= NDS.ARM7Target) break;
|
||||
if (NDS::ARM7Timestamp >= NDS::ARM7Target) break;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -676,7 +683,7 @@ void DMA::Run7()
|
|||
if (IterCount == 0)
|
||||
{
|
||||
Running = 0;
|
||||
NDS.ResumeCPU(1, 1<<Num);
|
||||
NDS::ResumeCPU(1, 1<<Num);
|
||||
}
|
||||
|
||||
return;
|
||||
|
|
@ -686,18 +693,20 @@ void DMA::Run7()
|
|||
Cnt &= ~(1<<31);
|
||||
|
||||
if (Cnt & (1<<30))
|
||||
NDS.SetIRQ(1, IRQ_DMA0 + Num);
|
||||
NDS::SetIRQ(1, NDS::IRQ_DMA0 + Num);
|
||||
|
||||
Running = 0;
|
||||
InProgress = false;
|
||||
NDS.ResumeCPU(1, 1<<Num);
|
||||
NDS::ResumeCPU(1, 1<<Num);
|
||||
}
|
||||
|
||||
template <int ConsoleType>
|
||||
void DMA::Run()
|
||||
{
|
||||
if (!Running) return;
|
||||
if (CPU == 0) return Run9();
|
||||
else return Run7();
|
||||
if (CPU == 0) return Run9<ConsoleType>();
|
||||
else return Run7<ConsoleType>();
|
||||
}
|
||||
|
||||
}
|
||||
template void DMA::Run<0>();
|
||||
template void DMA::Run<1>();
|
||||
|
|
|
|||
61
src/DMA.h
61
src/DMA.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,19 +19,13 @@
|
|||
#ifndef DMA_H
|
||||
#define DMA_H
|
||||
|
||||
#include <array>
|
||||
#include "types.h"
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
class NDS;
|
||||
class Savestate;
|
||||
|
||||
class DMA
|
||||
{
|
||||
public:
|
||||
DMA(u32 cpu, u32 num, NDS& nds);
|
||||
~DMA() = default;
|
||||
DMA(u32 cpu, u32 num);
|
||||
~DMA();
|
||||
|
||||
void Reset();
|
||||
|
||||
|
|
@ -45,16 +39,20 @@ public:
|
|||
u32 UnitTimings7_16(bool burststart);
|
||||
u32 UnitTimings7_32(bool burststart);
|
||||
|
||||
template <int ConsoleType>
|
||||
void Run();
|
||||
|
||||
template <int ConsoleType>
|
||||
void Run9();
|
||||
template <int ConsoleType>
|
||||
void Run7();
|
||||
|
||||
bool IsInMode(u32 mode) const noexcept
|
||||
bool IsInMode(u32 mode)
|
||||
{
|
||||
return ((mode == StartMode) && (Cnt & 0x80000000));
|
||||
}
|
||||
|
||||
bool IsRunning() const noexcept { return Running!=0; }
|
||||
bool IsRunning() { return Running!=0; }
|
||||
|
||||
void StartIfNeeded(u32 mode)
|
||||
{
|
||||
|
|
@ -73,35 +71,32 @@ public:
|
|||
if (Executing) Stall = true;
|
||||
}
|
||||
|
||||
u32 SrcAddr {};
|
||||
u32 DstAddr {};
|
||||
u32 Cnt {};
|
||||
u32 SrcAddr;
|
||||
u32 DstAddr;
|
||||
u32 Cnt;
|
||||
|
||||
private:
|
||||
melonDS::NDS& NDS;
|
||||
u32 CPU {};
|
||||
u32 Num {};
|
||||
u32 CPU, Num;
|
||||
|
||||
u32 StartMode {};
|
||||
u32 CurSrcAddr {};
|
||||
u32 CurDstAddr {};
|
||||
u32 RemCount {};
|
||||
u32 IterCount {};
|
||||
s32 SrcAddrInc {};
|
||||
s32 DstAddrInc {};
|
||||
u32 CountMask {};
|
||||
u32 StartMode;
|
||||
u32 CurSrcAddr;
|
||||
u32 CurDstAddr;
|
||||
u32 RemCount;
|
||||
u32 IterCount;
|
||||
s32 SrcAddrInc;
|
||||
s32 DstAddrInc;
|
||||
u32 CountMask;
|
||||
|
||||
u32 Running {};
|
||||
bool InProgress {};
|
||||
u32 Running;
|
||||
bool InProgress;
|
||||
|
||||
bool Executing {};
|
||||
bool Stall {};
|
||||
bool Executing;
|
||||
bool Stall;
|
||||
|
||||
bool IsGXFIFODMA {};
|
||||
bool IsGXFIFODMA;
|
||||
|
||||
u32 MRAMBurstCount {};
|
||||
std::array<u8, 256> MRAMBurstTable;
|
||||
u32 MRAMBurstCount;
|
||||
u8* MRAMBurstTable;
|
||||
};
|
||||
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,243 +0,0 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
melonDS 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.
|
||||
|
||||
melonDS 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 melonDS. If not, see http://www.gnu.org/licenses/.
|
||||
*/
|
||||
|
||||
#include "DMA_Timings.h"
|
||||
#include "types.h"
|
||||
|
||||
namespace melonDS::DMATiming
|
||||
{
|
||||
|
||||
// DMA timing tables
|
||||
//
|
||||
// DMA timings on the DS are normally straightforward, except in one case: when
|
||||
// main RAM is involved.
|
||||
// Main RAM to main RAM is the easy case: 16c/unit in 16bit mode, 18c/unit in 32bit
|
||||
// mode.
|
||||
// It gets more complicated when transferring from main RAM to somewhere else, or
|
||||
// vice versa: main RAM supports burst accesses, but the rules dictating how long
|
||||
// bursts can be are weird and inconsistent. Main RAM also supports parallel
|
||||
// memory operations, to some extent.
|
||||
// I haven't figured out the full logic behind it, let alone how to emulate it
|
||||
// efficiently, so for now we will use these tables.
|
||||
// A zero denotes the end of a burst pattern.
|
||||
//
|
||||
// Note: burst patterns only apply when the main RAM address is incrementing.
|
||||
// A fixed or decrementing address results in nonsequential accesses.
|
||||
//
|
||||
// Note about GBA slot/wifi timings: these take into account the sequential timing
|
||||
// setting. Timings are such that the nonseq setting only matters for the first
|
||||
// access, and minor edge cases (like the last of a 0x20000-byte block).
|
||||
|
||||
extern const std::array<u8, 256> MRAMDummy = {0};
|
||||
|
||||
extern const std::array<u8, 256> MRAMRead16Bursts[] =
|
||||
{
|
||||
// main RAM to regular 16bit or 32bit bus (similar)
|
||||
{7, 3, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
7, 3, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
7, 3,
|
||||
0},
|
||||
// main RAM to GBA/wifi, seq=4
|
||||
{8, 6, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5,
|
||||
0},
|
||||
// main RAM to GBA/wifi, seq=6
|
||||
{10, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8,
|
||||
0},
|
||||
};
|
||||
|
||||
extern const std::array<u8, 256> MRAMRead32Bursts[] =
|
||||
{
|
||||
// main RAM to regular 16bit bus
|
||||
{9, 4, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 9,
|
||||
0},
|
||||
// main RAM to regular 32bit bus
|
||||
{9, 3, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2,
|
||||
0},
|
||||
// main RAM to GBA/wifi, seq=4
|
||||
{14, 10, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9,
|
||||
13, 10, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9,
|
||||
13, 10, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9,
|
||||
13, 10, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9,
|
||||
13, 10, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9,
|
||||
13,
|
||||
0},
|
||||
// main RAM to GBA/wifi, seq=6
|
||||
{18, 14, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
17, 14, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
17, 14, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
17, 14, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
17, 14, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
17,
|
||||
0},
|
||||
};
|
||||
|
||||
extern const std::array<u8, 256> MRAMWrite16Bursts[] =
|
||||
{
|
||||
// regular 16bit or 32bit bus to main RAM (similar)
|
||||
{8, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
0},
|
||||
// GBA/wifi to main RAM, seq=4
|
||||
{10, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5,
|
||||
0},
|
||||
// GBA/wifi to main RAM, seq=6
|
||||
{9, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7,
|
||||
0},
|
||||
};
|
||||
|
||||
extern const std::array<u8, 256> MRAMWrite32Bursts[4] =
|
||||
{
|
||||
// regular 16bit bus to main RAM
|
||||
{9, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
0},
|
||||
// regular 32bit bus to main RAM
|
||||
{9, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
0},
|
||||
// GBA/wifi to main RAM, seq=4
|
||||
{15, 10, 10, 10, 10, 10, 10, 10, 10, 10,
|
||||
10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
|
||||
10, 10, 10, 10,
|
||||
0},
|
||||
// GBA/wifi to main RAM, seq=6
|
||||
{16, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14,
|
||||
0},
|
||||
};
|
||||
|
||||
}
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,10 +19,7 @@
|
|||
#ifndef DMA_TIMINGS_H
|
||||
#define DMA_TIMINGS_H
|
||||
|
||||
#include <array>
|
||||
#include "types.h"
|
||||
|
||||
namespace melonDS::DMATiming
|
||||
namespace DMATiming
|
||||
{
|
||||
|
||||
// DMA timing tables
|
||||
|
|
@ -46,15 +43,202 @@ namespace melonDS::DMATiming
|
|||
// setting. Timings are such that the nonseq setting only matters for the first
|
||||
// access, and minor edge cases (like the last of a 0x20000-byte block).
|
||||
|
||||
extern const std::array<u8, 256> MRAMDummy;
|
||||
u8 MRAMDummy[1] = {0};
|
||||
|
||||
extern const std::array<u8, 256> MRAMRead16Bursts[3];
|
||||
u8 MRAMRead16Bursts[][256] =
|
||||
{
|
||||
// main RAM to regular 16bit or 32bit bus (similar)
|
||||
{7, 3, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
7, 3, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
7, 3,
|
||||
0},
|
||||
// main RAM to GBA/wifi, seq=4
|
||||
{8, 6, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5,
|
||||
0},
|
||||
// main RAM to GBA/wifi, seq=6
|
||||
{10, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7,
|
||||
12, 8,
|
||||
0},
|
||||
};
|
||||
|
||||
extern const std::array<u8, 256> MRAMRead32Bursts[4];
|
||||
u8 MRAMRead32Bursts[][256] =
|
||||
{
|
||||
// main RAM to regular 16bit bus
|
||||
{9, 4, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 9,
|
||||
0},
|
||||
// main RAM to regular 32bit bus
|
||||
{9, 3, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2,
|
||||
0},
|
||||
// main RAM to GBA/wifi, seq=4
|
||||
{14, 10, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9,
|
||||
13, 10, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9,
|
||||
13, 10, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9,
|
||||
13, 10, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9,
|
||||
13, 10, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
|
||||
9, 9, 9, 9, 9, 9, 9,
|
||||
13,
|
||||
0},
|
||||
// main RAM to GBA/wifi, seq=6
|
||||
{18, 14, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
17, 14, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
17, 14, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
17, 14, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
17, 14, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
13, 13, 13, 13, 13, 13, 13, 13, 13,
|
||||
17,
|
||||
0},
|
||||
};
|
||||
|
||||
extern const std::array<u8, 256> MRAMWrite16Bursts[3];
|
||||
u8 MRAMWrite16Bursts[][256] =
|
||||
{
|
||||
// regular 16bit or 32bit bus to main RAM (similar)
|
||||
{8, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
|
||||
0},
|
||||
// GBA/wifi to main RAM, seq=4
|
||||
{10, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
|
||||
5, 5, 5, 5, 5, 5, 5, 5,
|
||||
0},
|
||||
// GBA/wifi to main RAM, seq=6
|
||||
{9, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
|
||||
7, 7, 7, 7, 7,
|
||||
0},
|
||||
};
|
||||
|
||||
extern const std::array<u8, 256> MRAMWrite32Bursts[4];
|
||||
u8 MRAMWrite32Bursts[][256] =
|
||||
{
|
||||
// regular 16bit bus to main RAM
|
||||
{9, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
||||
0},
|
||||
// regular 32bit bus to main RAM
|
||||
{9, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
|
||||
0},
|
||||
// GBA/wifi to main RAM, seq=4
|
||||
{15, 10, 10, 10, 10, 10, 10, 10, 10, 10,
|
||||
10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
|
||||
10, 10, 10, 10,
|
||||
0},
|
||||
// GBA/wifi to main RAM, seq=6
|
||||
{16, 14, 14, 14, 14, 14, 14, 14, 14, 14,
|
||||
14, 14, 14, 14, 14, 14, 14, 14,
|
||||
0},
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
2075
src/DSi.cpp
2075
src/DSi.cpp
File diff suppressed because it is too large
Load Diff
245
src/DSi.h
245
src/DSi.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -20,168 +20,95 @@
|
|||
#define DSI_H
|
||||
|
||||
#include "NDS.h"
|
||||
#include "DSi_NDMA.h"
|
||||
#include "DSi_SD.h"
|
||||
#include "DSi_DSP.h"
|
||||
#include "DSi_AES.h"
|
||||
#include "DSi_Camera.h"
|
||||
#include "DSi_NAND.h"
|
||||
|
||||
namespace melonDS
|
||||
namespace DSi
|
||||
{
|
||||
class DSi_I2CHost;
|
||||
class DSi_CamModule;
|
||||
class DSi_AES;
|
||||
class DSi_DSP;
|
||||
class DSiArgs;
|
||||
|
||||
namespace DSi_NAND
|
||||
{
|
||||
class NANDImage;
|
||||
extern u16 SCFG_BIOS;
|
||||
extern u16 SCFG_Clock9;
|
||||
extern u32 SCFG_EXT[2];
|
||||
|
||||
|
||||
extern u8 ARM9iBIOS[0x10000];
|
||||
extern u8 ARM7iBIOS[0x10000];
|
||||
|
||||
extern u8 eMMC_CID[16];
|
||||
extern u64 ConsoleID;
|
||||
|
||||
extern DSi_SDHost* SDMMC;
|
||||
extern DSi_SDHost* SDIO;
|
||||
|
||||
const u32 NWRAMSize = 0x40000;
|
||||
|
||||
extern u8* NWRAM_A;
|
||||
extern u8* NWRAM_B;
|
||||
extern u8* NWRAM_C;
|
||||
|
||||
extern u8* NWRAMMap_A[2][4];
|
||||
extern u8* NWRAMMap_B[3][8];
|
||||
extern u8* NWRAMMap_C[3][8];
|
||||
|
||||
extern u32 NWRAMStart[2][3];
|
||||
extern u32 NWRAMEnd[2][3];
|
||||
extern u32 NWRAMMask[2][3];
|
||||
|
||||
bool Init();
|
||||
void DeInit();
|
||||
void Reset();
|
||||
|
||||
void DoSavestate(Savestate* file);
|
||||
|
||||
void SetupDirectBoot();
|
||||
void SoftReset();
|
||||
|
||||
bool LoadBIOS();
|
||||
bool LoadNAND();
|
||||
|
||||
void RunNDMAs(u32 cpu);
|
||||
void StallNDMAs();
|
||||
bool NDMAsInMode(u32 cpu, u32 mode);
|
||||
bool NDMAsRunning(u32 cpu);
|
||||
void CheckNDMAs(u32 cpu, u32 mode);
|
||||
void StopNDMAs(u32 cpu, u32 mode);
|
||||
|
||||
void MapNWRAM_A(u32 num, u8 val);
|
||||
void MapNWRAM_B(u32 num, u8 val);
|
||||
void MapNWRAM_C(u32 num, u8 val);
|
||||
void MapNWRAMRange(u32 cpu, u32 num, u32 val);
|
||||
|
||||
u8 ARM9Read8(u32 addr);
|
||||
u16 ARM9Read16(u32 addr);
|
||||
u32 ARM9Read32(u32 addr);
|
||||
void ARM9Write8(u32 addr, u8 val);
|
||||
void ARM9Write16(u32 addr, u16 val);
|
||||
void ARM9Write32(u32 addr, u32 val);
|
||||
|
||||
bool ARM9GetMemRegion(u32 addr, bool write, NDS::MemRegion* region);
|
||||
|
||||
u8 ARM7Read8(u32 addr);
|
||||
u16 ARM7Read16(u32 addr);
|
||||
u32 ARM7Read32(u32 addr);
|
||||
void ARM7Write8(u32 addr, u8 val);
|
||||
void ARM7Write16(u32 addr, u16 val);
|
||||
void ARM7Write32(u32 addr, u32 val);
|
||||
|
||||
bool ARM7GetMemRegion(u32 addr, bool write, NDS::MemRegion* region);
|
||||
|
||||
u8 ARM9IORead8(u32 addr);
|
||||
u16 ARM9IORead16(u32 addr);
|
||||
u32 ARM9IORead32(u32 addr);
|
||||
void ARM9IOWrite8(u32 addr, u8 val);
|
||||
void ARM9IOWrite16(u32 addr, u16 val);
|
||||
void ARM9IOWrite32(u32 addr, u32 val);
|
||||
|
||||
u8 ARM7IORead8(u32 addr);
|
||||
u16 ARM7IORead16(u32 addr);
|
||||
u32 ARM7IORead32(u32 addr);
|
||||
void ARM7IOWrite8(u32 addr, u8 val);
|
||||
void ARM7IOWrite16(u32 addr, u16 val);
|
||||
void ARM7IOWrite32(u32 addr, u32 val);
|
||||
|
||||
}
|
||||
|
||||
class DSi final : public NDS
|
||||
{
|
||||
protected:
|
||||
void DoSavestateExtra(Savestate* file) override;
|
||||
public:
|
||||
u16 SCFG_BIOS;
|
||||
u16 SCFG_Clock9;
|
||||
u32 SCFG_EXT[2];
|
||||
|
||||
std::array<u8, DSiBIOSSize> ARM9iBIOS;
|
||||
std::array<u8, DSiBIOSSize> ARM7iBIOS;
|
||||
DSi_SDHost SDMMC;
|
||||
DSi_SDHost SDIO;
|
||||
|
||||
const u32 NWRAMSize = 0x40000;
|
||||
|
||||
u8* NWRAM_A;
|
||||
u8* NWRAM_B;
|
||||
u8* NWRAM_C;
|
||||
|
||||
u8* NWRAMMap_A[2][4];
|
||||
u8* NWRAMMap_B[3][8];
|
||||
u8* NWRAMMap_C[3][8];
|
||||
|
||||
u32 NWRAMStart[2][3];
|
||||
u32 NWRAMEnd[2][3];
|
||||
u32 NWRAMMask[2][3];
|
||||
|
||||
DSi_I2CHost I2C;
|
||||
DSi_CamModule CamModule;
|
||||
DSi_AES AES;
|
||||
DSi_DSP DSP;
|
||||
|
||||
void Reset() override;
|
||||
void Stop(Platform::StopReason reason) override;
|
||||
|
||||
bool DoSavestate(Savestate* file);
|
||||
|
||||
void SetCartInserted(bool inserted);
|
||||
|
||||
void SetupDirectBoot() override;
|
||||
void SoftReset();
|
||||
|
||||
bool LoadNAND();
|
||||
|
||||
void RunNDMAs(u32 cpu);
|
||||
void StallNDMAs();
|
||||
bool NDMAsInMode(u32 cpu, u32 mode) const;
|
||||
bool NDMAsRunning(u32 cpu) const;
|
||||
void CheckNDMAs(u32 cpu, u32 mode);
|
||||
void StopNDMAs(u32 cpu, u32 mode);
|
||||
|
||||
void MapNWRAM_A(u32 num, u8 val);
|
||||
void MapNWRAM_B(u32 num, u8 val);
|
||||
void MapNWRAM_C(u32 num, u8 val);
|
||||
void MapNWRAMRange(u32 cpu, u32 num, u32 val);
|
||||
|
||||
u8 ARM9Read8(u32 addr) override;
|
||||
u16 ARM9Read16(u32 addr) override;
|
||||
u32 ARM9Read32(u32 addr) override;
|
||||
void ARM9Write8(u32 addr, u8 val) override;
|
||||
void ARM9Write16(u32 addr, u16 val) override;
|
||||
void ARM9Write32(u32 addr, u32 val) override;
|
||||
|
||||
bool ARM9GetMemRegion(u32 addr, bool write, MemRegion* region) override;
|
||||
|
||||
u8 ARM7Read8(u32 addr) override;
|
||||
u16 ARM7Read16(u32 addr) override;
|
||||
u32 ARM7Read32(u32 addr) override;
|
||||
void ARM7Write8(u32 addr, u8 val) override;
|
||||
void ARM7Write16(u32 addr, u16 val) override;
|
||||
void ARM7Write32(u32 addr, u32 val) override;
|
||||
|
||||
bool ARM7GetMemRegion(u32 addr, bool write, MemRegion* region) override;
|
||||
|
||||
u8 ARM9IORead8(u32 addr) override;
|
||||
u16 ARM9IORead16(u32 addr) override;
|
||||
u32 ARM9IORead32(u32 addr) override;
|
||||
void ARM9IOWrite8(u32 addr, u8 val) override;
|
||||
void ARM9IOWrite16(u32 addr, u16 val) override;
|
||||
void ARM9IOWrite32(u32 addr, u32 val) override;
|
||||
|
||||
u8 ARM7IORead8(u32 addr) override;
|
||||
u16 ARM7IORead16(u32 addr) override;
|
||||
u32 ARM7IORead32(u32 addr) override;
|
||||
void ARM7IOWrite8(u32 addr, u8 val) override;
|
||||
void ARM7IOWrite16(u32 addr, u16 val) override;
|
||||
void ARM7IOWrite32(u32 addr, u32 val) override;
|
||||
|
||||
public:
|
||||
DSi(DSiArgs&& args, void* userdata = nullptr) noexcept;
|
||||
//DSi() noexcept;
|
||||
~DSi() noexcept override;
|
||||
DSi(const DSi&) = delete;
|
||||
DSi& operator=(const DSi&) = delete;
|
||||
DSi(DSi&&) = delete;
|
||||
DSi& operator=(DSi&&) = delete;
|
||||
void SetNDSCart(std::unique_ptr<NDSCart::CartCommon>&& cart) override;
|
||||
std::unique_ptr<NDSCart::CartCommon> EjectCart() override;
|
||||
bool NeedsDirectBoot() const override
|
||||
{
|
||||
// for now, DSi mode requires original BIOS/NAND
|
||||
return false;
|
||||
}
|
||||
|
||||
[[nodiscard]] const DSi_NAND::NANDImage& GetNAND() const noexcept { return *SDMMC.GetNAND(); }
|
||||
[[nodiscard]] DSi_NAND::NANDImage& GetNAND() noexcept { return *SDMMC.GetNAND(); }
|
||||
void SetNAND(DSi_NAND::NANDImage&& nand) noexcept { SDMMC.SetNAND(std::move(nand)); }
|
||||
u64 GetConsoleID() const noexcept { return SDMMC.GetNAND()->GetConsoleID(); }
|
||||
|
||||
[[nodiscard]] const FATStorage* GetSDCard() const noexcept { return SDMMC.GetSDCard(); }
|
||||
void SetSDCard(FATStorage&& sdcard) noexcept { SDMMC.SetSDCard(std::move(sdcard)); }
|
||||
void SetSDCard(std::optional<FATStorage>&& sdcard) noexcept { SDMMC.SetSDCard(std::move(sdcard)); }
|
||||
|
||||
void CamInputFrame(int cam, const u32* data, int width, int height, bool rgb) override;
|
||||
bool DMAsInMode(u32 cpu, u32 mode) const override;
|
||||
bool DMAsRunning(u32 cpu) const override;
|
||||
void StopDMAs(u32 cpu, u32 mode) override;
|
||||
void CheckDMAs(u32 cpu, u32 mode) override;
|
||||
u16 SCFG_Clock7;
|
||||
u32 SCFG_MC;
|
||||
u16 SCFG_RST;
|
||||
u32 MBK[2][9];
|
||||
u32 NDMACnt[2];
|
||||
std::array<DSi_NDMA, 8> NDMAs;
|
||||
// FIXME: these currently have no effect (and aren't stored in a savestate)
|
||||
// ... not that they matter all that much
|
||||
u8 GPIO_Data;
|
||||
u8 GPIO_Dir;
|
||||
u8 GPIO_IEdgeSel;
|
||||
u8 GPIO_IE;
|
||||
u8 GPIO_WiFi;
|
||||
|
||||
bool GetFullBIOSBoot() const noexcept { return FullBIOSBoot; }
|
||||
void SetFullBIOSBoot(bool full) noexcept { FullBIOSBoot = full; }
|
||||
private:
|
||||
bool FullBIOSBoot;
|
||||
void Set_SCFG_Clock9(u16 val);
|
||||
void Set_SCFG_MC(u32 val);
|
||||
void DecryptModcryptArea(u32 offset, u32 size, const u8* iv);
|
||||
void ApplyNewRAMSize(u32 size);
|
||||
};
|
||||
|
||||
}
|
||||
#endif // DSI_H
|
||||
|
|
|
|||
|
|
@ -0,0 +1,17 @@
|
|||
/*
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
melonDS 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.
|
||||
|
||||
melonDS 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 melonDS. If not, see http://www.gnu.org/licenses/.
|
||||
*/
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -16,29 +16,9 @@
|
|||
with melonDS. If not, see http://www.gnu.org/licenses/.
|
||||
*/
|
||||
|
||||
#ifndef ARMJIT_GLOBAL_H
|
||||
#define ARMJIT_GLOBAL_H
|
||||
#ifndef DSICRYPTO_H
|
||||
#define DSICRYPTO_H
|
||||
|
||||
#include "types.h"
|
||||
//
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
|
||||
namespace ARMJIT_Global
|
||||
{
|
||||
|
||||
static constexpr size_t CodeMemorySliceSize = 1024*1024*32;
|
||||
|
||||
void Init();
|
||||
void DeInit();
|
||||
|
||||
void* AllocateCodeMem();
|
||||
void FreeCodeMem(void* codeMem);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif // DSICRYPTO_H
|
||||
188
src/DSi_AES.cpp
188
src/DSi_AES.cpp
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -19,15 +19,69 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include "DSi.h"
|
||||
#include "DSi_NAND.h"
|
||||
#include "DSi_AES.h"
|
||||
#include "FIFO.h"
|
||||
#include "tiny-AES-c/aes.hpp"
|
||||
#include "Platform.h"
|
||||
|
||||
namespace melonDS
|
||||
{
|
||||
using Platform::Log;
|
||||
using Platform::LogLevel;
|
||||
|
||||
namespace DSi_AES
|
||||
{
|
||||
|
||||
u32 Cnt;
|
||||
|
||||
u32 BlkCnt;
|
||||
u32 RemExtra;
|
||||
u32 RemBlocks;
|
||||
|
||||
bool OutputFlush;
|
||||
|
||||
u32 InputDMASize, OutputDMASize;
|
||||
u32 AESMode;
|
||||
|
||||
FIFO<u32, 16> InputFIFO;
|
||||
FIFO<u32, 16> OutputFIFO;
|
||||
|
||||
u8 IV[16];
|
||||
|
||||
u8 MAC[16];
|
||||
|
||||
u8 KeyNormal[4][16];
|
||||
u8 KeyX[4][16];
|
||||
u8 KeyY[4][16];
|
||||
|
||||
u8 CurKey[16];
|
||||
u8 CurMAC[16];
|
||||
|
||||
// output MAC for CCM encrypt
|
||||
u8 OutputMAC[16];
|
||||
bool OutputMACDue;
|
||||
|
||||
AES_ctx Ctx;
|
||||
|
||||
|
||||
void Swap16(u8* dst, u8* src)
|
||||
{
|
||||
for (int i = 0; i < 16; i++)
|
||||
dst[i] = src[15-i];
|
||||
}
|
||||
|
||||
void ROL16(u8* val, u32 n)
|
||||
{
|
||||
u32 n_coarse = n >> 3;
|
||||
u32 n_fine = n & 7;
|
||||
u8 tmp[16];
|
||||
|
||||
for (u32 i = 0; i < 16; i++)
|
||||
{
|
||||
tmp[i] = val[(i - n_coarse) & 0xF];
|
||||
}
|
||||
|
||||
for (u32 i = 0; i < 16; i++)
|
||||
{
|
||||
val[i] = (tmp[i] << n_fine) | (tmp[(i - 1) & 0xF] >> (8-n_fine));
|
||||
}
|
||||
}
|
||||
|
||||
#define _printhex(str, size) { for (int z = 0; z < (size); z++) printf("%02X", (str)[z]); printf("\n"); }
|
||||
#define _printhex2(str, size) { for (int z = 0; z < (size); z++) printf("%02X", (str)[z]); }
|
||||
|
|
@ -36,17 +90,19 @@ using Platform::LogLevel;
|
|||
#define _printhex2R(str, size) { for (int z = 0; z < (size); z++) printf("%02X", (str)[((size)-1)-z]); }
|
||||
|
||||
|
||||
DSi_AES::DSi_AES(melonDS::DSi& dsi) : DSi(dsi)
|
||||
bool Init()
|
||||
{
|
||||
const u8 zero[16] = {0};
|
||||
AES_init_ctx_iv(&Ctx, zero, zero);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
DSi_AES::~DSi_AES()
|
||||
void DeInit()
|
||||
{
|
||||
}
|
||||
|
||||
void DSi_AES::Reset()
|
||||
void Reset()
|
||||
{
|
||||
Cnt = 0;
|
||||
|
||||
|
|
@ -78,7 +134,6 @@ void DSi_AES::Reset()
|
|||
OutputMACDue = false;
|
||||
|
||||
// initialize keys
|
||||
u64 consoleid = DSi.SDMMC.GetNAND()->GetConsoleID();
|
||||
|
||||
// slot 0: modcrypt
|
||||
*(u32*)&KeyX[0][0] = 0x746E694E;
|
||||
|
|
@ -87,20 +142,20 @@ void DSi_AES::Reset()
|
|||
// slot 1: 'Tad'/dev.kp
|
||||
*(u32*)&KeyX[1][0] = 0x4E00004A;
|
||||
*(u32*)&KeyX[1][4] = 0x4A00004E;
|
||||
*(u32*)&KeyX[1][8] = (u32)(consoleid >> 32) ^ 0xC80C4B72;
|
||||
*(u32*)&KeyX[1][12] = (u32)consoleid;
|
||||
*(u32*)&KeyX[1][8] = (u32)(DSi::ConsoleID >> 32) ^ 0xC80C4B72;
|
||||
*(u32*)&KeyX[1][12] = (u32)DSi::ConsoleID;
|
||||
|
||||
// slot 3: console-unique eMMC crypto
|
||||
*(u32*)&KeyX[3][0] = (u32)consoleid;
|
||||
*(u32*)&KeyX[3][4] = (u32)consoleid ^ 0x24EE6906;
|
||||
*(u32*)&KeyX[3][8] = (u32)(consoleid >> 32) ^ 0xE65B601D;
|
||||
*(u32*)&KeyX[3][12] = (u32)(consoleid >> 32);
|
||||
*(u32*)&KeyX[3][0] = (u32)DSi::ConsoleID;
|
||||
*(u32*)&KeyX[3][4] = (u32)DSi::ConsoleID ^ 0x24EE6906;
|
||||
*(u32*)&KeyX[3][8] = (u32)(DSi::ConsoleID >> 32) ^ 0xE65B601D;
|
||||
*(u32*)&KeyX[3][12] = (u32)(DSi::ConsoleID >> 32);
|
||||
*(u32*)&KeyY[3][0] = 0x0AB9DC76;
|
||||
*(u32*)&KeyY[3][4] = 0xBD4DC4D3;
|
||||
*(u32*)&KeyY[3][8] = 0x202DDD1D;
|
||||
}
|
||||
|
||||
void DSi_AES::DoSavestate(Savestate* file)
|
||||
void DoSavestate(Savestate* file)
|
||||
{
|
||||
file->Section("AESi");
|
||||
|
||||
|
|
@ -138,7 +193,7 @@ void DSi_AES::DoSavestate(Savestate* file)
|
|||
}
|
||||
|
||||
|
||||
void DSi_AES::ProcessBlock_CCM_Extra()
|
||||
void ProcessBlock_CCM_Extra()
|
||||
{
|
||||
u8 data[16];
|
||||
u8 data_rev[16];
|
||||
|
|
@ -148,13 +203,13 @@ void DSi_AES::ProcessBlock_CCM_Extra()
|
|||
*(u32*)&data[8] = InputFIFO.Read();
|
||||
*(u32*)&data[12] = InputFIFO.Read();
|
||||
|
||||
Bswap128(data_rev, data);
|
||||
Swap16(data_rev, data);
|
||||
|
||||
for (int i = 0; i < 16; i++) CurMAC[i] ^= data_rev[i];
|
||||
AES_ECB_encrypt(&Ctx, CurMAC);
|
||||
}
|
||||
|
||||
void DSi_AES::ProcessBlock_CCM_Decrypt()
|
||||
void ProcessBlock_CCM_Decrypt()
|
||||
{
|
||||
u8 data[16];
|
||||
u8 data_rev[16];
|
||||
|
|
@ -166,13 +221,13 @@ void DSi_AES::ProcessBlock_CCM_Decrypt()
|
|||
|
||||
//printf("AES-CCM: "); _printhex2(data, 16);
|
||||
|
||||
Bswap128(data_rev, data);
|
||||
Swap16(data_rev, data);
|
||||
|
||||
AES_CTR_xcrypt_buffer(&Ctx, data_rev, 16);
|
||||
for (int i = 0; i < 16; i++) CurMAC[i] ^= data_rev[i];
|
||||
AES_ECB_encrypt(&Ctx, CurMAC);
|
||||
|
||||
Bswap128(data, data_rev);
|
||||
Swap16(data, data_rev);
|
||||
|
||||
//printf(" -> "); _printhex2(data, 16);
|
||||
|
||||
|
|
@ -182,7 +237,7 @@ void DSi_AES::ProcessBlock_CCM_Decrypt()
|
|||
OutputFIFO.Write(*(u32*)&data[12]);
|
||||
}
|
||||
|
||||
void DSi_AES::ProcessBlock_CCM_Encrypt()
|
||||
void ProcessBlock_CCM_Encrypt()
|
||||
{
|
||||
u8 data[16];
|
||||
u8 data_rev[16];
|
||||
|
|
@ -194,13 +249,13 @@ void DSi_AES::ProcessBlock_CCM_Encrypt()
|
|||
|
||||
//printf("AES-CCM: "); _printhex2(data, 16);
|
||||
|
||||
Bswap128(data_rev, data);
|
||||
Swap16(data_rev, data);
|
||||
|
||||
for (int i = 0; i < 16; i++) CurMAC[i] ^= data_rev[i];
|
||||
AES_CTR_xcrypt_buffer(&Ctx, data_rev, 16);
|
||||
AES_ECB_encrypt(&Ctx, CurMAC);
|
||||
|
||||
Bswap128(data, data_rev);
|
||||
Swap16(data, data_rev);
|
||||
|
||||
//printf(" -> "); _printhex2(data, 16);
|
||||
|
||||
|
|
@ -210,7 +265,7 @@ void DSi_AES::ProcessBlock_CCM_Encrypt()
|
|||
OutputFIFO.Write(*(u32*)&data[12]);
|
||||
}
|
||||
|
||||
void DSi_AES::ProcessBlock_CTR()
|
||||
void ProcessBlock_CTR()
|
||||
{
|
||||
u8 data[16];
|
||||
u8 data_rev[16];
|
||||
|
|
@ -222,9 +277,9 @@ void DSi_AES::ProcessBlock_CTR()
|
|||
|
||||
//printf("AES-CTR: "); _printhex2(data, 16);
|
||||
|
||||
Bswap128(data_rev, data);
|
||||
Swap16(data_rev, data);
|
||||
AES_CTR_xcrypt_buffer(&Ctx, data_rev, 16);
|
||||
Bswap128(data, data_rev);
|
||||
Swap16(data, data_rev);
|
||||
|
||||
//printf(" -> "); _printhex(data, 16);
|
||||
|
||||
|
|
@ -235,7 +290,7 @@ void DSi_AES::ProcessBlock_CTR()
|
|||
}
|
||||
|
||||
|
||||
u32 DSi_AES::ReadCnt() const
|
||||
u32 ReadCnt()
|
||||
{
|
||||
u32 ret = Cnt;
|
||||
|
||||
|
|
@ -245,7 +300,7 @@ u32 DSi_AES::ReadCnt() const
|
|||
return ret;
|
||||
}
|
||||
|
||||
void DSi_AES::WriteCnt(u32 val)
|
||||
void WriteCnt(u32 val)
|
||||
{
|
||||
u32 oldcnt = Cnt;
|
||||
Cnt = val & 0xFC1FF000;
|
||||
|
|
@ -277,15 +332,15 @@ void DSi_AES::WriteCnt(u32 val)
|
|||
|
||||
OutputMACDue = false;
|
||||
|
||||
if (AESMode == 0 && (!(val & (1<<20)))) Log(LogLevel::Debug, "AES: CCM-DECRYPT MAC FROM WRFIFO, TODO\n");
|
||||
if (AESMode == 0 && (!(val & (1<<20)))) printf("AES: CCM-DECRYPT MAC FROM WRFIFO, TODO\n");
|
||||
|
||||
if ((RemBlocks > 0) || (RemExtra > 0))
|
||||
{
|
||||
u8 key[16];
|
||||
u8 iv[16];
|
||||
|
||||
Bswap128(key, CurKey);
|
||||
Bswap128(iv, IV);
|
||||
Swap16(key, CurKey);
|
||||
Swap16(iv, IV);
|
||||
|
||||
if (AESMode < 2)
|
||||
{
|
||||
|
|
@ -313,7 +368,7 @@ void DSi_AES::WriteCnt(u32 val)
|
|||
AES_init_ctx_iv(&Ctx, key, iv);
|
||||
}
|
||||
|
||||
DSi.CheckNDMAs(1, 0x2A);
|
||||
DSi::CheckNDMAs(1, 0x2A);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -328,14 +383,14 @@ void DSi_AES::WriteCnt(u32 val)
|
|||
// val, AESMode, (val >> 26) & 0x3, InputDMASize, OutputDMASize, RemBlocks, BlkCnt);
|
||||
}
|
||||
|
||||
void DSi_AES::WriteBlkCnt(u32 val)
|
||||
void WriteBlkCnt(u32 val)
|
||||
{
|
||||
BlkCnt = val;
|
||||
}
|
||||
|
||||
u32 DSi_AES::ReadOutputFIFO()
|
||||
u32 ReadOutputFIFO()
|
||||
{
|
||||
if (OutputFIFO.IsEmpty()) Log(LogLevel::Warn, "!!! AES OUTPUT FIFO EMPTY\n");
|
||||
if (OutputFIFO.IsEmpty()) printf("!!! AES OUTPUT FIFO EMPTY\n");
|
||||
|
||||
u32 ret = OutputFIFO.Read();
|
||||
|
||||
|
|
@ -347,9 +402,9 @@ u32 DSi_AES::ReadOutputFIFO()
|
|||
else
|
||||
{
|
||||
if (OutputFIFO.Level() > 0)
|
||||
DSi.CheckNDMAs(1, 0x2B);
|
||||
DSi::CheckNDMAs(1, 0x2B);
|
||||
else
|
||||
DSi.StopNDMAs(1, 0x2B);
|
||||
DSi::StopNDMAs(1, 0x2B);
|
||||
|
||||
if (OutputMACDue && OutputFIFO.Level() <= 12)
|
||||
{
|
||||
|
|
@ -364,11 +419,11 @@ u32 DSi_AES::ReadOutputFIFO()
|
|||
return ret;
|
||||
}
|
||||
|
||||
void DSi_AES::WriteInputFIFO(u32 val)
|
||||
void WriteInputFIFO(u32 val)
|
||||
{
|
||||
// TODO: add some delay to processing
|
||||
|
||||
if (InputFIFO.IsFull()) Log(LogLevel::Warn, "!!! AES INPUT FIFO FULL\n");
|
||||
if (InputFIFO.IsFull()) printf("!!! AES INPUT FIFO FULL\n");
|
||||
|
||||
InputFIFO.Write(val);
|
||||
|
||||
|
|
@ -377,29 +432,29 @@ void DSi_AES::WriteInputFIFO(u32 val)
|
|||
Update();
|
||||
}
|
||||
|
||||
void DSi_AES::CheckInputDMA()
|
||||
void CheckInputDMA()
|
||||
{
|
||||
if (RemBlocks == 0 && RemExtra == 0) return;
|
||||
|
||||
if (InputFIFO.Level() <= InputDMASize)
|
||||
{
|
||||
// trigger input DMA
|
||||
DSi.CheckNDMAs(1, 0x2A);
|
||||
DSi::CheckNDMAs(1, 0x2A);
|
||||
}
|
||||
|
||||
Update();
|
||||
}
|
||||
|
||||
void DSi_AES::CheckOutputDMA()
|
||||
void CheckOutputDMA()
|
||||
{
|
||||
if (OutputFIFO.Level() >= OutputDMASize)
|
||||
{
|
||||
// trigger output DMA
|
||||
DSi.CheckNDMAs(1, 0x2B);
|
||||
DSi::CheckNDMAs(1, 0x2B);
|
||||
}
|
||||
}
|
||||
|
||||
void DSi_AES::Update()
|
||||
void Update()
|
||||
{
|
||||
if (RemExtra > 0)
|
||||
{
|
||||
|
|
@ -453,7 +508,7 @@ void DSi_AES::Update()
|
|||
Ctx.Iv[15] = 0x00;
|
||||
AES_CTR_xcrypt_buffer(&Ctx, CurMAC, 16);
|
||||
|
||||
Bswap128(OutputMAC, CurMAC);
|
||||
Swap16(OutputMAC, CurMAC);
|
||||
|
||||
if (OutputFIFO.Level() <= 12)
|
||||
{
|
||||
|
|
@ -475,19 +530,19 @@ void DSi_AES::Update()
|
|||
}
|
||||
|
||||
Cnt &= ~(1<<31);
|
||||
if (Cnt & (1<<30)) DSi.SetIRQ2(IRQ2_DSi_AES);
|
||||
DSi.StopNDMAs(1, 0x2A);
|
||||
if (Cnt & (1<<30)) NDS::SetIRQ2(NDS::IRQ2_DSi_AES);
|
||||
DSi::StopNDMAs(1, 0x2A);
|
||||
|
||||
if (!OutputFIFO.IsEmpty())
|
||||
DSi.CheckNDMAs(1, 0x2B);
|
||||
DSi::CheckNDMAs(1, 0x2B);
|
||||
else
|
||||
DSi.StopNDMAs(1, 0x2B);
|
||||
DSi::StopNDMAs(1, 0x2B);
|
||||
OutputFlush = false;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void DSi_AES::WriteIV(u32 offset, u32 val, u32 mask)
|
||||
void WriteIV(u32 offset, u32 val, u32 mask)
|
||||
{
|
||||
u32 old = *(u32*)&IV[offset];
|
||||
|
||||
|
|
@ -496,7 +551,7 @@ void DSi_AES::WriteIV(u32 offset, u32 val, u32 mask)
|
|||
//printf("AES: IV: "); _printhex(IV, 16);
|
||||
}
|
||||
|
||||
void DSi_AES::WriteMAC(u32 offset, u32 val, u32 mask)
|
||||
void WriteMAC(u32 offset, u32 val, u32 mask)
|
||||
{
|
||||
u32 old = *(u32*)&MAC[offset];
|
||||
|
||||
|
|
@ -505,24 +560,7 @@ void DSi_AES::WriteMAC(u32 offset, u32 val, u32 mask)
|
|||
//printf("AES: MAC: "); _printhex(MAC, 16);
|
||||
}
|
||||
|
||||
void DSi_AES::ROL16(u8* val, u32 n)
|
||||
{
|
||||
u32 n_coarse = n >> 3;
|
||||
u32 n_fine = n & 7;
|
||||
u8 tmp[16];
|
||||
|
||||
for (u32 i = 0; i < 16; i++)
|
||||
{
|
||||
tmp[i] = val[(i - n_coarse) & 0xF];
|
||||
}
|
||||
|
||||
for (u32 i = 0; i < 16; i++)
|
||||
{
|
||||
val[i] = (tmp[i] << n_fine) | (tmp[(i - 1) & 0xF] >> (8-n_fine));
|
||||
}
|
||||
}
|
||||
|
||||
void DSi_AES::DeriveNormalKey(u8* keyX, u8* keyY, u8* normalkey)
|
||||
void DeriveNormalKey(u8* keyX, u8* keyY, u8* normalkey)
|
||||
{
|
||||
const u8 key_const[16] = {0xFF, 0xFE, 0xFB, 0x4E, 0x29, 0x59, 0x02, 0x58, 0x2A, 0x68, 0x0F, 0x5F, 0x1A, 0x4F, 0x3E, 0x79};
|
||||
u8 tmp[16];
|
||||
|
|
@ -543,7 +581,7 @@ void DSi_AES::DeriveNormalKey(u8* keyX, u8* keyY, u8* normalkey)
|
|||
memcpy(normalkey, tmp, 16);
|
||||
}
|
||||
|
||||
void DSi_AES::WriteKeyNormal(u32 slot, u32 offset, u32 val, u32 mask)
|
||||
void WriteKeyNormal(u32 slot, u32 offset, u32 val, u32 mask)
|
||||
{
|
||||
u32 old = *(u32*)&KeyNormal[slot][offset];
|
||||
|
||||
|
|
@ -552,7 +590,7 @@ void DSi_AES::WriteKeyNormal(u32 slot, u32 offset, u32 val, u32 mask)
|
|||
//printf("KeyNormal(%d): ", slot); _printhex(KeyNormal[slot], 16);
|
||||
}
|
||||
|
||||
void DSi_AES::WriteKeyX(u32 slot, u32 offset, u32 val, u32 mask)
|
||||
void WriteKeyX(u32 slot, u32 offset, u32 val, u32 mask)
|
||||
{
|
||||
u32 old = *(u32*)&KeyX[slot][offset];
|
||||
|
||||
|
|
@ -561,7 +599,7 @@ void DSi_AES::WriteKeyX(u32 slot, u32 offset, u32 val, u32 mask)
|
|||
//printf("KeyX(%d): ", slot); _printhex(KeyX[slot], 16);
|
||||
}
|
||||
|
||||
void DSi_AES::WriteKeyY(u32 slot, u32 offset, u32 val, u32 mask)
|
||||
void WriteKeyY(u32 slot, u32 offset, u32 val, u32 mask)
|
||||
{
|
||||
u32 old = *(u32*)&KeyY[slot][offset];
|
||||
|
||||
|
|
@ -575,4 +613,4 @@ void DSi_AES::WriteKeyY(u32 slot, u32 offset, u32 val, u32 mask)
|
|||
}
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
|
|
|||
106
src/DSi_AES.h
106
src/DSi_AES.h
|
|
@ -1,5 +1,5 @@
|
|||
/*
|
||||
Copyright 2016-2024 melonDS team
|
||||
Copyright 2016-2022 melonDS team
|
||||
|
||||
This file is part of melonDS.
|
||||
|
||||
|
|
@ -20,97 +20,37 @@
|
|||
#define DSI_AES_H
|
||||
|
||||
#include "types.h"
|
||||
#include "Savestate.h"
|
||||
#include "FIFO.h"
|
||||
#include "tiny-AES-c/aes.hpp"
|
||||
|
||||
namespace melonDS
|
||||
namespace DSi_AES
|
||||
{
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wattributes"
|
||||
#if defined(__GNUC__) && (__GNUC__ >= 11) && defined(__SIZEOF_INT128__) // gcc 11.*
|
||||
// NOTE: Yes, the compiler does *not* recognize this code pattern, so it is indeed an optimization.
|
||||
__attribute((always_inline)) static void Bswap128(void* Dst, const void* Src)
|
||||
{
|
||||
*(__int128*)Dst = __builtin_bswap128(*(__int128*)Src);
|
||||
}
|
||||
#else
|
||||
__attribute((always_inline)) static void Bswap128(void* Dst, const void* Src)
|
||||
{
|
||||
for (int i = 0; i < 16; ++i)
|
||||
{
|
||||
((u8*)Dst)[i] = ((u8*)Src)[15 - i];
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#pragma GCC diagnostic pop
|
||||
|
||||
class DSi;
|
||||
class DSi_AES
|
||||
{
|
||||
public:
|
||||
DSi_AES(melonDS::DSi& dsi);
|
||||
~DSi_AES();
|
||||
void Reset();
|
||||
void DoSavestate(Savestate* file);
|
||||
extern u32 Cnt;
|
||||
|
||||
u32 ReadCnt() const;
|
||||
void WriteCnt(u32 val);
|
||||
void WriteBlkCnt(u32 val);
|
||||
bool Init();
|
||||
void DeInit();
|
||||
void Reset();
|
||||
|
||||
u32 ReadOutputFIFO();
|
||||
void WriteInputFIFO(u32 val);
|
||||
void CheckInputDMA();
|
||||
void CheckOutputDMA();
|
||||
void Update();
|
||||
void DoSavestate(Savestate* file);
|
||||
|
||||
void WriteIV(u32 offset, u32 val, u32 mask);
|
||||
void WriteMAC(u32 offset, u32 val, u32 mask);
|
||||
void WriteKeyNormal(u32 slot, u32 offset, u32 val, u32 mask);
|
||||
void WriteKeyX(u32 slot, u32 offset, u32 val, u32 mask);
|
||||
void WriteKeyY(u32 slot, u32 offset, u32 val, u32 mask);
|
||||
u32 ReadCnt();
|
||||
void WriteCnt(u32 val);
|
||||
void WriteBlkCnt(u32 val);
|
||||
|
||||
static void ROL16(u8* val, u32 n);
|
||||
static void DeriveNormalKey(u8* keyX, u8* keyY, u8* normalkey);
|
||||
u32 ReadOutputFIFO();
|
||||
void WriteInputFIFO(u32 val);
|
||||
void CheckInputDMA();
|
||||
void CheckOutputDMA();
|
||||
void Update();
|
||||
|
||||
private:
|
||||
melonDS::DSi& DSi;
|
||||
u32 Cnt;
|
||||
void WriteIV(u32 offset, u32 val, u32 mask);
|
||||
void WriteMAC(u32 offset, u32 val, u32 mask);
|
||||
void WriteKeyNormal(u32 slot, u32 offset, u32 val, u32 mask);
|
||||
void WriteKeyX(u32 slot, u32 offset, u32 val, u32 mask);
|
||||
void WriteKeyY(u32 slot, u32 offset, u32 val, u32 mask);
|
||||
|
||||
u32 BlkCnt;
|
||||
u32 RemExtra;
|
||||
u32 RemBlocks;
|
||||
|
||||
bool OutputFlush;
|
||||
|
||||
u32 InputDMASize, OutputDMASize;
|
||||
u32 AESMode;
|
||||
|
||||
FIFO<u32, 16> InputFIFO;
|
||||
FIFO<u32, 16> OutputFIFO;
|
||||
|
||||
u8 IV[16];
|
||||
|
||||
u8 MAC[16];
|
||||
|
||||
u8 KeyNormal[4][16];
|
||||
u8 KeyX[4][16];
|
||||
u8 KeyY[4][16];
|
||||
|
||||
u8 CurKey[16];
|
||||
u8 CurMAC[16];
|
||||
|
||||
// output MAC for CCM encrypt
|
||||
u8 OutputMAC[16];
|
||||
bool OutputMACDue;
|
||||
|
||||
AES_ctx Ctx;
|
||||
|
||||
void ProcessBlock_CCM_Extra();
|
||||
void ProcessBlock_CCM_Decrypt();
|
||||
void ProcessBlock_CCM_Encrypt();
|
||||
void ProcessBlock_CTR();
|
||||
};
|
||||
void Swap16(u8* dst, u8* src);
|
||||
void DeriveNormalKey(u8* keyX, u8* keyY, u8* normalkey);
|
||||
|
||||
}
|
||||
|
||||
#endif // DSI_AES_H
|
||||
|
|
|
|||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue