| Age | Commit message (Collapse) | Author |
|---|
|
shader/memory: Implement STG and global memory flushing
|
|
yuzu/configure_hotkey: Minor changes
|
|
common/{lz4_compression, zstd_compression}: Add missing header guards
|
|
Previously we were building with MBCS, which is pretty undesirable. We
want the application to be Unicode-aware in general.
Currently, we make the command line variant of yuzu use ANSI variants of
the non-standard getopt functions that we link in for Windows, given we
only have an ANSI option-set.
We should really replace getopt with a library that we make all build
types of yuzu link in, but this will have to do for the time being.
|
|
Makes the dependency on the system instance explicit within VMManager's
interface.
|
|
This detects when a GPU Memory Block is not continous within host cpu
memory.
|
|
iterators.
|
|
|
|
|
|
|
|
Use ReadBlockUnsafe on TIC and TSC reading as memory is never flushed
from host GPU there.
|
|
|
|
|
|
service: Update service function tables
|
|
kernel/svc: Implement svcMapProcessCodeMemory/svcUnmapProcessCodeMemory
|
|
kernel/thread: Remove BoostPriority()
|
|
|
|
|
|
Operations done before the main half float operation (like HAdd) were
managing a packed value instead of the unpacked one. Adding an unpacked
operation allows us to drop the per-operand MetaHalfArithmetic entry,
simplifying the code overall.
|
|
GLSL decompilation for HMergeH0 was wrong. This addresses that issue.
|
|
|
|
|
|
|
|
Using static here might be faster at runtime, but it adds a heap
allocation called before main.
|
|
Corrects encodings for I2F, F2F, I2I and F2I
Implements Immediate variants of all four conversion types.
Add assertions to unimplemented stuffs.
|
|
This is a compile definition introduced in Qt 4.8 for reducing the total
potential number of strings created when performing string
concatenation. This allows for less memory churn.
This can be read about here:
https://blog.qt.io/blog/2011/06/13/string-concatenation-with-qstringbuilder/
For a change that isn't source-compatible, we only had one occurrence
that actually need to have its type clarified, which is pretty good, as
far as transitioning goes.
|
|
Allows the handle to be seen alongside the entry point.
|
|
|
|
|
|
These two files were missing the #pragma once directive.
|
|
|
|
This is a holdover from Citra that currently remains unused, so it can
be removed from the Thread interface.
|
|
This member variable is entirely unused. It was only set but never
actually utilized. Given that, we can remove it to get rid of noise in
the thread interface.
|
|
|
|
|
|
ldr: Minor amendments to IPC-related parameters
|
|
Set Pixel Format to Z32 if its R32F and depth compare enabled, and Implement format ZF32_X24S8
|
|
Add a toggle to force 30FPS mode
|
|
fsp_srv: Minor cleanup related changes
|
|
gl_shader_manager: Move code to source file and minor clean up
|
|
Frontend: Migrate to QOpenGLWindow and support shared contexts
|
|
ui_settings: Rename game directory variables
|
|
Essentially performs the inverse of svcMapProcessCodeMemory. This unmaps
the aliasing region first, then restores the general traits of the
aliased memory.
What this entails, is:
- Restoring Read/Write permissions to the VMA.
- Restoring its memory state to reflect it as a general heap memory region.
- Clearing the memory attributes on the region.
|
|
This is utilized for mapping code modules into memory. Notably, the
ldr service would call this in order to map objects into memory.
|
|
common/scope_exit: Replace std::move with std::forward in ScopeExit()
|
|
common/swap: Minor cleanup and improvements to byte swapping functions
|
|
|
|
Uses arithmetic that can be identified more trivially by compilers for
optimizations. e.g. Rather than shifting the halves of the value and
then swapping and combining them, we can swap them in place.
e.g. for the original swap32 code on x86-64, clang 8.0 would generate:
mov ecx, edi
rol cx, 8
shl ecx, 16
shr edi, 16
rol di, 8
movzx eax, di
or eax, ecx
ret
while GCC 8.3 would generate the ideal:
mov eax, edi
bswap eax
ret
now both generate the same optimal output.
MSVC used to generate the following with the old code:
mov eax, ecx
rol cx, 8
shr eax, 16
rol ax, 8
movzx ecx, cx
movzx eax, ax
shl ecx, 16
or eax, ecx
ret 0
Now MSVC also generates a similar, but equally optimal result as clang/GCC:
bswap ecx
mov eax, ecx
ret 0
====
In the swap64 case, for the original code, clang 8.0 would generate:
mov eax, edi
bswap eax
shl rax, 32
shr rdi, 32
bswap edi
or rax, rdi
ret
(almost there, but still missing the mark)
while, again, GCC 8.3 would generate the more ideal:
mov rax, rdi
bswap rax
ret
now clang also generates the optimal sequence for this fallback as well.
This is a case where MSVC unfortunately falls short, despite the new
code, this one still generates a doozy of an output.
mov r8, rcx
mov r9, rcx
mov rax, 71776119061217280
mov rdx, r8
and r9, rax
and edx, 65280
mov rax, rcx
shr rax, 16
or r9, rax
mov rax, rcx
shr r9, 16
mov rcx, 280375465082880
and rax, rcx
mov rcx, 1095216660480
or r9, rax
mov rax, r8
and rax, rcx
shr r9, 16
or r9, rax
mov rcx, r8
mov rax, r8
shr r9, 8
shl rax, 16
and ecx, 16711680
or rdx, rax
mov eax, -16777216
and rax, r8
shl rdx, 16
or rdx, rcx
shl rdx, 16
or rax, rdx
shl rax, 8
or rax, r9
ret 0
which is pretty unfortunate.
|
|
This gives us significantly more control over where in the
initialization process we start execution of the main process.
Previously we were running the main process before the CPU or GPU
threads were initialized (not good). This amends execution to start
after all of our threads are properly set up.
|
|
Initially required due to the split codepath with how the initial main
process instance was initialized. We used to initialize the process
like:
Init() {
main_process = Process::Create(...);
kernel.MakeCurrentProcess(main_process.get());
}
Load() {
const auto load_result = loader.Load(*kernel.GetCurrentProcess());
if (load_result != Loader::ResultStatus::Success) {
// Handle error here.
}
...
}
which presented a problem.
Setting a created process as the main process would set the page table
for that process as the main page table. This is fine... until we get to
the part that the page table can have its size changed in the Load()
function via NPDM metadata, which can dictate either a 32-bit, 36-bit,
or 39-bit usable address space.
Now that we have full control over the process' creation in load, we can
simply set the initial process as the main process after all the loading
is done, reflecting the potential page table changes without any
special-casing behavior.
We can also remove the cache flushing within LoadModule(), as execution
wouldn't have even begun yet during all usages of this function, now
that we have the initialization order cleaned up.
|
