| Age | Commit message (Collapse) | Author |
|---|
|
Instead, we can just expose functions that return the queryable state
instead of letting anything modify it.
|
|
svc: Log parameters in SetMemoryAttribute()
|
|
core_timing: Split off utility functions into core_timing_util
|
|
The loop's induction variable was signed, but we were comparing against
an unsigned variable.
|
|
Provides slightly more context than only logging out the address value.
|
|
mutex: Pass SharedPtr to GetHighestPriorityMutexWaitingThread() by reference
|
|
|
|
The pointed to thread's members are simply observed in this case, so we
don't need to copy it here.
|
|
|
|
This is just an unused hold-over from citra, so we can get rid of this
to trim off an exposed global, among other things.
|
|
This is a holdover from citra that's essentially unused.
|
|
kernel.
|
|
CPU: Save and restore the TPIDR_EL0 system register on every context switch
|
|
Note that there's currently a dynarmic bug preventing this register from being written.
|
|
Makes the thread status strongly typed, so implicit conversions can't
happen. It also makes it easier to catch mistakes at compile time.
|
|
hle_ipc: Introduce generic WriteBuffer overload for multiple container types
|
|
svc: Correct always true assertion case in SetThreadCoreMask
|
|
This introduces a slightly more generic variant of WriteBuffer().
Notably, this variant doesn't constrain the arguments to only accepting
std::vector instances. It accepts whatever adheres to the
ContiguousContainer concept in the C++ standard library.
This essentially means, std::array, std::string, and std::vector can be
used directly with this interface. The interface no longer forces you to
solely use containers that dynamically allocate.
To ensure our overloads play nice with one another, we only enable the
container-based WriteBuffer if the argument is not a pointer, otherwise
we fall back to the pointer-based one.
|
|
The reason this would never be true is that ideal_processor is a u8 and
THREADPROCESSORID_DEFAULT is an s32. In this case, it boils down to how
arithmetic conversions are performed before performing the comparison.
If an unsigned value has a lesser conversion rank (aka smaller size)
than the signed type being compared, then the unsigned value is promoted
to the signed value (i.e. u8 -> s32 happens before the comparison). No
sign-extension occurs here either.
An alternative phrasing:
Say we have a variable named core and it's given a value of -2.
u8 core = -2;
This becomes 254 due to the lack of sign. During integral promotion to
the signed type, this still remains as 254, and therefore the condition
will always be true, because no matter what value the u8 is given it
will never be -2 in terms of 32 bits.
Now, if one type was a s32 and one was a u32, this would be entirely
different, since they have the same bit width (and the signed type would
be converted to unsigned instead of the other way around) but would
still have its representation preserved in terms of bits, allowing the
comparison to be false in some cases, as opposed to being true all the
time.
---
We also get rid of two signed/unsigned comparison warnings while we're
at it.
|
|
WriteBuffer() overloads
Previously, the buffer_index parameter was unused, causing all writes to
use the buffer index of zero, which is not necessarily what is wanted
all the time.
Thankfully, all current usages don't use a buffer index other than zero,
so this just prevents a bug before it has a chance to spring.
|
|
address_arbiter: Correct assignment within an assertion statement in WakeThreads()
|
|
core/memory, core/hle/kernel: Use std::move where applicable
|
|
vm_manager: Add missing commas to string literal array elements in GetMemoryStateName()
|
|
WakeThreads()
This was introduced within 4f81bc4e1bd12e4df7410c6790ba818d8dbba9c0, and
considering there's no comment indicating that this is intentional, this
is very likely a bug.
|
|
GetMemoryStateName()
Without these, this would perform concatenation, which is definitely not
what we want here.
|
|
Avoids pointless copies
|
|
This would result in a lot of allocations and related object
construction, just to toss it all away immediately after the call.
These are definitely not intentional, and it was intended that all of
these should have been accessing the static function GetInstance()
through the name itself, not constructed instances.
|
|
scheduler: Clear exclusive state when switching contexts
|
|
svc:: Fix bug in svcWaitForAddress
|
|
|
|
|
|
|
|
|
|
|
|
|
|
svc: Fully implement svcSignalToAddress and svcWaitForAddress
|
|
prevent yuzu crash, if games, like Axiom Verge, trying to read 0 bytes from file
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
svc: Add a stub for UserExceptionContextAddr.
|
|
|
|
already have an assigned lock owner.
This situation may happen like so:
Thread 1 with low priority calls WaitProcessWideKey with timeout.
Thread 2 with high priority calls WaitProcessWideKey without timeout.
Thread 3 calls SignalProcessWideKey
- Thread 2 acquires the lock and awakens.
- Thread 1 can't acquire the lock and is put to sleep with the lock owner being Thread 2.
Thread 1's timeout expires, with the lock owner still being set to Thread 2.
|
