citra-emu
/
citra-canary
Archived
1
0
Fork 0
Code

move push out of class body and add u8 u16 bool specializations

This commit is contained in:
Lectem 2016-12-30 15:54:40 +01:00
parent 501e23ce59
commit fb70c9683c
4 changed files with 114 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/core/hle/ipc.h
View File

@ -10,7 +10,8 @@
namespace Kernel {
static const int kCommandHeaderOffset = 0x80; ///< Offset into command buffer of header
/// Offset into command buffer of header
static const int kCommandHeaderOffset = 0x80;
/**
* Returns a pointer to the command buffer in the current thread's TLS
@ -26,8 +27,8 @@ inline u32* GetCommandBuffer(const int offset = 0) {
offset);
}
static const int kStaticBuffersOffset =
0x100; ///< Offset into static buffers, relative to command buffer header
/// Offset into static buffers, relative to command buffer header
static const int kStaticBuffersOffset = 0x100;
/**
* Returns a pointer to the static buffers area in the current thread's TLS

152
src/core/hle/ipc_helpers.h
View File

@ -62,14 +62,8 @@ public:
template <typename T>
void Push(T value);
void Push(u32 value) {
cmdbuf[index++] = value;
}
template <typename First, typename... Other>
void Push(const First& first_value, const Other&... other_values) {
Push(first_value);
Push(other_values...);
}
void Push(const First& first_value, const Other&... other_values);
/**
* @brief Copies the content of the given trivially copyable class to the buffer as a normal
@ -77,59 +71,96 @@ public:
* @note: The input class must be correctly packed/padded to fit hardware layout.
*/
template <typename T>
void PushRaw(const T& value) {
static_assert(std::is_trivially_copyable<T>(), "Raw types should be trivially copyable");
std::memcpy(cmdbuf + index, &value, sizeof(T));
index += (sizeof(T) + 3) / 4; // round up to word length
}
void PushRaw(const T& value);
// TODO : ensure that translate params are added after all regular params
template <typename... H>
void PushCopyHandles(H... handles) {
Push(CopyHandleDesc(sizeof...(H)));
Push(static_cast<Kernel::Handle>(handles)...);
}
void PushCopyHandles(H... handles);
template <typename... H>
void PushMoveHandles(H... handles) {
Push(MoveHandleDesc(sizeof...(H)));
Push(static_cast<Kernel::Handle>(handles)...);
}
void PushMoveHandles(H... handles);
void PushCurrentPIDHandle() {
Push(CallingPidDesc());
Push(u32(0));
}
void PushCurrentPIDHandle();
void PushStaticBuffer(VAddr buffer_vaddr, u32 size, u8 buffer_id) {
Push(StaticBufferDesc(size, buffer_id));
Push(buffer_vaddr);
}
void PushStaticBuffer(VAddr buffer_vaddr, u32 size, u8 buffer_id);
void PushMappedBuffer(VAddr buffer_vaddr, u32 size, MappedBufferPermissions perms) {
Push(MappedBufferDesc(size, perms));
Push(buffer_vaddr);
}
void PushMappedBuffer(VAddr buffer_vaddr, u32 size, MappedBufferPermissions perms);
};
/// Push ///
template <>
inline void RequestBuilder::Push<u32>(u32 value) {
Push(value);
inline void RequestBuilder::Push(u32 value) {
cmdbuf[index++] = value;
}
template <typename T>
void RequestBuilder::PushRaw(const T& value) {
static_assert(std::is_trivially_copyable<T>(), "Raw types should be trivially copyable");
std::memcpy(cmdbuf + index, &value, sizeof(T));
index += (sizeof(T) + 3) / 4; // round up to word length
}
template <>
inline void RequestBuilder::Push<u64>(u64 value) {
inline void RequestBuilder::Push(u8 value) {
PushRaw(value);
}
template <>
inline void RequestBuilder::Push(u16 value) {
PushRaw(value);
}
template <>
inline void RequestBuilder::Push(u64 value) {
Push(static_cast<u32>(value));
Push(static_cast<u32>(value >> 32));
}
template <>
inline void RequestBuilder::Push<ResultCode>(ResultCode value) {
inline void RequestBuilder::Push(bool value) {
Push(u8(value));
}
template <>
inline void RequestBuilder::Push(ResultCode value) {
Push(value.raw);
}
template <typename First, typename... Other>
void RequestBuilder::Push(const First& first_value, const Other&... other_values) {
Push(first_value);
Push(other_values...);
}
template <typename... H>
inline void RequestBuilder::PushCopyHandles(H... handles) {
Push(CopyHandleDesc(sizeof...(H)));
Push(static_cast<Kernel::Handle>(handles)...);
}
template <typename... H>
inline void RequestBuilder::PushMoveHandles(H... handles) {
Push(MoveHandleDesc(sizeof...(H)));
Push(static_cast<Kernel::Handle>(handles)...);
}
inline void RequestBuilder::PushCurrentPIDHandle() {
Push(CallingPidDesc());
Push(u32(0));
}
inline void RequestBuilder::PushStaticBuffer(VAddr buffer_vaddr, u32 size, u8 buffer_id) {
Push(StaticBufferDesc(size, buffer_id));
Push(buffer_vaddr);
}
inline void RequestBuilder::PushMappedBuffer(VAddr buffer_vaddr, u32 size,
MappedBufferPermissions perms) {
Push(MappedBufferDesc(size, perms));
Push(buffer_vaddr);
}
class RequestParser : public RequestHelperBase {
public:
RequestParser(u32* command_buffer, Header command_header)
@ -197,24 +228,60 @@ public:
*/
template <typename T>
void PopRaw(T& value);
/**
* @brief Reads the next normal parameters as a struct, by copying it into a new value
* @note: The output class must be correctly packed/padded to fit hardware layout.
*/
template <typename T>
T PopRaw();
};
/// Pop ///
template <>
inline u32 RequestParser::Pop<u32>() {
inline u32 RequestParser::Pop() {
return cmdbuf[index++];
}
template <typename T>
void RequestParser::PopRaw(T& value) {
static_assert(std::is_trivially_copyable<T>(), "Raw types should be trivially copyable");
std::memcpy(&value, cmdbuf + index, sizeof(T));
index += (sizeof(T) + 3) / 4; // round up to word length
}
template <typename T>
T RequestParser::PopRaw() {
T value;
PopRaw(value);
return value;
}
template <>
inline u64 RequestParser::Pop<u64>() {
inline u8 RequestParser::Pop() {
return PopRaw<u8>();
}
template <>
inline u16 RequestParser::Pop() {
return PopRaw<u16>();
}
template <>
inline u64 RequestParser::Pop() {
const u64 lsw = Pop<u32>();
const u64 msw = Pop<u32>();
return msw << 32 | lsw;
}
template <>
inline ResultCode RequestParser::Pop<ResultCode>() {
inline bool RequestParser::Pop() {
return Pop<u8>() != 0; // != 0 to remove warning C4800
}
template <>
inline ResultCode RequestParser::Pop() {
return ResultCode{Pop<u32>()};
}
@ -277,11 +344,4 @@ inline VAddr RequestParser::PopMappedBuffer(size_t* data_size,
return Pop<VAddr>();
}
template <typename T>
void RequestParser::PopRaw(T& value) {
static_assert(std::is_trivially_copyable<T>(), "Raw types should be trivially copyable");
std::memcpy(&value, cmdbuf + index, sizeof(T));
index += (sizeof(T) + 3) / 4; // round up to word length
}
} // namespace IPC

2
src/core/hle/service/ptm/ptm.cpp
View File

@ -101,7 +101,7 @@ void CheckNew3DS(IPC::RequestBuilder& rb) {
}
rb.Push(RESULT_SUCCESS);
rb.Push(u32(is_new_3ds ? 1 : 0));
rb.Push(is_new_3ds);
LOG_WARNING(Service_PTM, "(STUBBED) called isNew3DS = 0x%08x", static_cast<u32>(is_new_3ds));
}

8
src/core/hle/service/y2r_u.cpp
View File

@ -189,11 +189,9 @@ static void SetSpacialDithering(Interface* self) {
* 2 : u8, 0 = Disabled, 1 = Enabled
*/
static void GetSpacialDithering(Interface* self) {
u32* cmd_buff = Kernel::GetCommandBuffer();
cmd_buff[0] = IPC::MakeHeader(0xA, 2, 0);
cmd_buff[1] = RESULT_SUCCESS.raw;
cmd_buff[2] = spacial_dithering_enabled;
IPC::RequestBuilder rb(Kernel::GetCommandBuffer(), 0xA, 2, 0);
rb.Push(RESULT_SUCCESS);
rb.Push(bool(spacial_dithering_enabled));
LOG_WARNING(Service_Y2R, "(STUBBED) called");
}