summaryrefslogtreecommitdiff
path: root/src/core/hle/function_wrappers.h
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/hle/function_wrappers.h')
-rw-r--r--src/core/hle/function_wrappers.h103
1 files changed, 68 insertions, 35 deletions
diff --git a/src/core/hle/function_wrappers.h b/src/core/hle/function_wrappers.h
index 8839ce482..d5d989c29 100644
--- a/src/core/hle/function_wrappers.h
+++ b/src/core/hle/function_wrappers.h
@@ -7,14 +7,14 @@
7#include "common/common_types.h" 7#include "common/common_types.h"
8 8
9#include "core/arm/arm_interface.h" 9#include "core/arm/arm_interface.h"
10#include "core/memory.h"
11#include "core/hle/hle.h" 10#include "core/hle/hle.h"
12#include "core/hle/result.h" 11#include "core/hle/result.h"
13#include "core/hle/svc.h" 12#include "core/hle/svc.h"
13#include "core/memory.h"
14 14
15namespace HLE { 15namespace HLE {
16 16
17#define PARAM(n) Core::g_app_core->GetReg(n) 17#define PARAM(n) Core::g_app_core->GetReg(n)
18 18
19/// An invalid result code that is meant to be overwritten when a thread resumes from waiting 19/// An invalid result code that is meant to be overwritten when a thread resumes from waiting
20static const ResultCode RESULT_INVALID(0xDEADC0DE); 20static const ResultCode RESULT_INVALID(0xDEADC0DE);
@@ -40,28 +40,33 @@ static inline void FuncReturn64(u64 res) {
40//////////////////////////////////////////////////////////////////////////////////////////////////// 40////////////////////////////////////////////////////////////////////////////////////////////////////
41// Function wrappers that return type ResultCode 41// Function wrappers that return type ResultCode
42 42
43template<ResultCode func(u32, u32, u32, u32)> void Wrap() { 43template <ResultCode func(u32, u32, u32, u32)>
44void Wrap() {
44 FuncReturn(func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)).raw); 45 FuncReturn(func(PARAM(0), PARAM(1), PARAM(2), PARAM(3)).raw);
45} 46}
46 47
47template<ResultCode func(u32*, u32, u32, u32, u32, u32)> void Wrap(){ 48template <ResultCode func(u32*, u32, u32, u32, u32, u32)>
49void Wrap() {
48 u32 param_1 = 0; 50 u32 param_1 = 0;
49 u32 retval = func(&param_1, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)).raw; 51 u32 retval = func(&param_1, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)).raw;
50 Core::g_app_core->SetReg(1, param_1); 52 Core::g_app_core->SetReg(1, param_1);
51 FuncReturn(retval); 53 FuncReturn(retval);
52} 54}
53 55
54template<ResultCode func(u32*, s32, u32, u32, u32, s32)> void Wrap() { 56template <ResultCode func(u32*, s32, u32, u32, u32, s32)>
57void Wrap() {
55 u32 param_1 = 0; 58 u32 param_1 = 0;
56 u32 retval = func(&param_1, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)).raw; 59 u32 retval = func(&param_1, PARAM(0), PARAM(1), PARAM(2), PARAM(3), PARAM(4)).raw;
57 Core::g_app_core->SetReg(1, param_1); 60 Core::g_app_core->SetReg(1, param_1);
58 FuncReturn(retval); 61 FuncReturn(retval);
59} 62}
60 63
61template<ResultCode func(s32*, u32*, s32, bool, s64)> void Wrap() { 64template <ResultCode func(s32*, u32*, s32, bool, s64)>
65void Wrap() {
62 s32 param_1 = 0; 66 s32 param_1 = 0;
63 s32 retval = func(&param_1, (Handle*)Memory::GetPointer(PARAM(1)), (s32)PARAM(2), 67 s32 retval = func(&param_1, (Handle*)Memory::GetPointer(PARAM(1)), (s32)PARAM(2),
64 (PARAM(3) != 0), (((s64)PARAM(4) << 32) | PARAM(0))).raw; 68 (PARAM(3) != 0), (((s64)PARAM(4) << 32) | PARAM(0)))
69 .raw;
65 70
66 if (retval != RESULT_INVALID.raw) { 71 if (retval != RESULT_INVALID.raw) {
67 Core::g_app_core->SetReg(1, (u32)param_1); 72 Core::g_app_core->SetReg(1, (u32)param_1);
@@ -69,18 +74,22 @@ template<ResultCode func(s32*, u32*, s32, bool, s64)> void Wrap() {
69 } 74 }
70} 75}
71 76
72template<ResultCode func(u32, u32, u32, u32, s64)> void Wrap() { 77template <ResultCode func(u32, u32, u32, u32, s64)>
73 FuncReturn(func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), (((s64)PARAM(5) << 32) | PARAM(4))).raw); 78void Wrap() {
79 FuncReturn(
80 func(PARAM(0), PARAM(1), PARAM(2), PARAM(3), (((s64)PARAM(5) << 32) | PARAM(4))).raw);
74} 81}
75 82
76template<ResultCode func(u32*)> void Wrap(){ 83template <ResultCode func(u32*)>
84void Wrap() {
77 u32 param_1 = 0; 85 u32 param_1 = 0;
78 u32 retval = func(&param_1).raw; 86 u32 retval = func(&param_1).raw;
79 Core::g_app_core->SetReg(1, param_1); 87 Core::g_app_core->SetReg(1, param_1);
80 FuncReturn(retval); 88 FuncReturn(retval);
81} 89}
82 90
83template<ResultCode func(u32, s64)> void Wrap() { 91template <ResultCode func(u32, s64)>
92void Wrap() {
84 s32 retval = func(PARAM(0), (((s64)PARAM(3) << 32) | PARAM(2))).raw; 93 s32 retval = func(PARAM(0), (((s64)PARAM(3) << 32) | PARAM(2))).raw;
85 94
86 if (retval != RESULT_INVALID.raw) { 95 if (retval != RESULT_INVALID.raw) {
@@ -88,7 +97,8 @@ template<ResultCode func(u32, s64)> void Wrap() {
88 } 97 }
89} 98}
90 99
91template<ResultCode func(MemoryInfo*, PageInfo*, u32)> void Wrap() { 100template <ResultCode func(MemoryInfo*, PageInfo*, u32)>
101void Wrap() {
92 MemoryInfo memory_info = {}; 102 MemoryInfo memory_info = {};
93 PageInfo page_info = {}; 103 PageInfo page_info = {};
94 u32 retval = func(&memory_info, &page_info, PARAM(2)).raw; 104 u32 retval = func(&memory_info, &page_info, PARAM(2)).raw;
@@ -100,7 +110,8 @@ template<ResultCode func(MemoryInfo*, PageInfo*, u32)> void Wrap() {
100 FuncReturn(retval); 110 FuncReturn(retval);
101} 111}
102 112
103template<ResultCode func(MemoryInfo*, PageInfo*, Handle, u32)> void Wrap() { 113template <ResultCode func(MemoryInfo*, PageInfo*, Handle, u32)>
114void Wrap() {
104 MemoryInfo memory_info = {}; 115 MemoryInfo memory_info = {};
105 PageInfo page_info = {}; 116 PageInfo page_info = {};
106 u32 retval = func(&memory_info, &page_info, PARAM(2), PARAM(3)).raw; 117 u32 retval = func(&memory_info, &page_info, PARAM(2), PARAM(3)).raw;
@@ -112,55 +123,65 @@ template<ResultCode func(MemoryInfo*, PageInfo*, Handle, u32)> void Wrap() {
112 FuncReturn(retval); 123 FuncReturn(retval);
113} 124}
114 125
115template<ResultCode func(s32*, u32)> void Wrap(){ 126template <ResultCode func(s32*, u32)>
127void Wrap() {
116 s32 param_1 = 0; 128 s32 param_1 = 0;
117 u32 retval = func(&param_1, PARAM(1)).raw; 129 u32 retval = func(&param_1, PARAM(1)).raw;
118 Core::g_app_core->SetReg(1, param_1); 130 Core::g_app_core->SetReg(1, param_1);
119 FuncReturn(retval); 131 FuncReturn(retval);
120} 132}
121 133
122template<ResultCode func(u32, s32)> void Wrap() { 134template <ResultCode func(u32, s32)>
135void Wrap() {
123 FuncReturn(func(PARAM(0), (s32)PARAM(1)).raw); 136 FuncReturn(func(PARAM(0), (s32)PARAM(1)).raw);
124} 137}
125 138
126template<ResultCode func(u32*, u32)> void Wrap(){ 139template <ResultCode func(u32*, u32)>
140void Wrap() {
127 u32 param_1 = 0; 141 u32 param_1 = 0;
128 u32 retval = func(&param_1, PARAM(1)).raw; 142 u32 retval = func(&param_1, PARAM(1)).raw;
129 Core::g_app_core->SetReg(1, param_1); 143 Core::g_app_core->SetReg(1, param_1);
130 FuncReturn(retval); 144 FuncReturn(retval);
131} 145}
132 146
133template<ResultCode func(u32)> void Wrap() { 147template <ResultCode func(u32)>
148void Wrap() {
134 FuncReturn(func(PARAM(0)).raw); 149 FuncReturn(func(PARAM(0)).raw);
135} 150}
136 151
137template<ResultCode func(s64*, u32, u32*, u32)> void Wrap(){ 152template <ResultCode func(s64*, u32, u32*, u32)>
138 FuncReturn(func((s64*)Memory::GetPointer(PARAM(0)), PARAM(1), (u32*)Memory::GetPointer(PARAM(2)), 153void Wrap() {
139 (s32)PARAM(3)).raw); 154 FuncReturn(func((s64*)Memory::GetPointer(PARAM(0)), PARAM(1),
155 (u32*)Memory::GetPointer(PARAM(2)), (s32)PARAM(3))
156 .raw);
140} 157}
141 158
142template<ResultCode func(u32*, const char*)> void Wrap() { 159template <ResultCode func(u32*, const char*)>
160void Wrap() {
143 u32 param_1 = 0; 161 u32 param_1 = 0;
144 u32 retval = func(&param_1, (char*)Memory::GetPointer(PARAM(1))).raw; 162 u32 retval = func(&param_1, (char*)Memory::GetPointer(PARAM(1))).raw;
145 Core::g_app_core->SetReg(1, param_1); 163 Core::g_app_core->SetReg(1, param_1);
146 FuncReturn(retval); 164 FuncReturn(retval);
147} 165}
148 166
149template<ResultCode func(u32*, s32, s32)> void Wrap() { 167template <ResultCode func(u32*, s32, s32)>
168void Wrap() {
150 u32 param_1 = 0; 169 u32 param_1 = 0;
151 u32 retval = func(&param_1, PARAM(1), PARAM(2)).raw; 170 u32 retval = func(&param_1, PARAM(1), PARAM(2)).raw;
152 Core::g_app_core->SetReg(1, param_1); 171 Core::g_app_core->SetReg(1, param_1);
153 FuncReturn(retval); 172 FuncReturn(retval);
154} 173}
155 174
156template<ResultCode func(s32*, u32, s32)> void Wrap() { 175template <ResultCode func(s32*, u32, s32)>
176void Wrap() {
157 s32 param_1 = 0; 177 s32 param_1 = 0;
158 u32 retval = func(&param_1, PARAM(1), PARAM(2)).raw; 178 u32 retval = func(&param_1, PARAM(1), PARAM(2)).raw;
159 Core::g_app_core->SetReg(1, param_1); 179 Core::g_app_core->SetReg(1, param_1);
160 FuncReturn(retval); 180 FuncReturn(retval);
161} 181}
162 182
163template<ResultCode func(s64*, u32, s32)> void Wrap() { 183template <ResultCode func(s64*, u32, s32)>
184void Wrap() {
164 s64 param_1 = 0; 185 s64 param_1 = 0;
165 u32 retval = func(&param_1, PARAM(1), PARAM(2)).raw; 186 u32 retval = func(&param_1, PARAM(1), PARAM(2)).raw;
166 Core::g_app_core->SetReg(1, (u32)param_1); 187 Core::g_app_core->SetReg(1, (u32)param_1);
@@ -168,7 +189,8 @@ template<ResultCode func(s64*, u32, s32)> void Wrap() {
168 FuncReturn(retval); 189 FuncReturn(retval);
169} 190}
170 191
171template<ResultCode func(u32*, u32, u32, u32, u32)> void Wrap() { 192template <ResultCode func(u32*, u32, u32, u32, u32)>
193void Wrap() {
172 u32 param_1 = 0; 194 u32 param_1 = 0;
173 // The last parameter is passed in R0 instead of R4 195 // The last parameter is passed in R0 instead of R4
174 u32 retval = func(&param_1, PARAM(1), PARAM(2), PARAM(3), PARAM(0)).raw; 196 u32 retval = func(&param_1, PARAM(1), PARAM(2), PARAM(3), PARAM(0)).raw;
@@ -176,13 +198,15 @@ template<ResultCode func(u32*, u32, u32, u32, u32)> void Wrap() {
176 FuncReturn(retval); 198 FuncReturn(retval);
177} 199}
178 200
179template<ResultCode func(u32, s64, s64)> void Wrap() { 201template <ResultCode func(u32, s64, s64)>
202void Wrap() {
180 s64 param1 = ((u64)PARAM(3) << 32) | PARAM(2); 203 s64 param1 = ((u64)PARAM(3) << 32) | PARAM(2);
181 s64 param2 = ((u64)PARAM(4) << 32) | PARAM(1); 204 s64 param2 = ((u64)PARAM(4) << 32) | PARAM(1);
182 FuncReturn(func(PARAM(0), param1, param2).raw); 205 FuncReturn(func(PARAM(0), param1, param2).raw);
183} 206}
184 207
185template<ResultCode func(s64*, Handle, u32)> void Wrap() { 208template <ResultCode func(s64*, Handle, u32)>
209void Wrap() {
186 s64 param_1 = 0; 210 s64 param_1 = 0;
187 u32 retval = func(&param_1, PARAM(1), PARAM(2)).raw; 211 u32 retval = func(&param_1, PARAM(1), PARAM(2)).raw;
188 Core::g_app_core->SetReg(1, (u32)param_1); 212 Core::g_app_core->SetReg(1, (u32)param_1);
@@ -190,14 +214,18 @@ template<ResultCode func(s64*, Handle, u32)> void Wrap() {
190 FuncReturn(retval); 214 FuncReturn(retval);
191} 215}
192 216
193template<ResultCode func(Handle, u32)> void Wrap() { 217template <ResultCode func(Handle, u32)>
218void Wrap() {
194 FuncReturn(func(PARAM(0), PARAM(1)).raw); 219 FuncReturn(func(PARAM(0), PARAM(1)).raw);
195} 220}
196 221
197template<ResultCode func(Handle*, Handle*, const char*, u32)> void Wrap() { 222template <ResultCode func(Handle*, Handle*, const char*, u32)>
223void Wrap() {
198 Handle param_1 = 0; 224 Handle param_1 = 0;
199 Handle param_2 = 0; 225 Handle param_2 = 0;
200 u32 retval = func(&param_1, &param_2, reinterpret_cast<const char*>(Memory::GetPointer(PARAM(2))), PARAM(3)).raw; 226 u32 retval = func(&param_1, &param_2,
227 reinterpret_cast<const char*>(Memory::GetPointer(PARAM(2))), PARAM(3))
228 .raw;
201 // The first out parameter is moved into R2 and the second is moved into R1. 229 // The first out parameter is moved into R2 and the second is moved into R1.
202 Core::g_app_core->SetReg(1, param_2); 230 Core::g_app_core->SetReg(1, param_2);
203 Core::g_app_core->SetReg(2, param_1); 231 Core::g_app_core->SetReg(2, param_1);
@@ -207,29 +235,34 @@ template<ResultCode func(Handle*, Handle*, const char*, u32)> void Wrap() {
207//////////////////////////////////////////////////////////////////////////////////////////////////// 235////////////////////////////////////////////////////////////////////////////////////////////////////
208// Function wrappers that return type u32 236// Function wrappers that return type u32
209 237
210template<u32 func()> void Wrap() { 238template <u32 func()>
239void Wrap() {
211 FuncReturn(func()); 240 FuncReturn(func());
212} 241}
213 242
214//////////////////////////////////////////////////////////////////////////////////////////////////// 243////////////////////////////////////////////////////////////////////////////////////////////////////
215// Function wrappers that return type s64 244// Function wrappers that return type s64
216 245
217template<s64 func()> void Wrap() { 246template <s64 func()>
247void Wrap() {
218 FuncReturn64(func()); 248 FuncReturn64(func());
219} 249}
220 250
221//////////////////////////////////////////////////////////////////////////////////////////////////// 251////////////////////////////////////////////////////////////////////////////////////////////////////
222/// Function wrappers that return type void 252/// Function wrappers that return type void
223 253
224template<void func(s64)> void Wrap() { 254template <void func(s64)>
255void Wrap() {
225 func(((s64)PARAM(1) << 32) | PARAM(0)); 256 func(((s64)PARAM(1) << 32) | PARAM(0));
226} 257}
227 258
228template<void func(const char*)> void Wrap() { 259template <void func(const char*)>
260void Wrap() {
229 func((char*)Memory::GetPointer(PARAM(0))); 261 func((char*)Memory::GetPointer(PARAM(0)));
230} 262}
231 263
232template<void func(u8)> void Wrap() { 264template <void func(u8)>
265void Wrap() {
233 func((u8)PARAM(0)); 266 func((u8)PARAM(0));
234} 267}
235 268
HIC SVNT DRACONES