1 /*
2 * Software MMU support
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
16 *
17 */
18
19 /*
20 * Generate inline load/store functions for all MMU modes (typically
21 * at least _user and _kernel) as well as _data versions, for all data
22 * sizes.
23 *
24 * Used by target op helpers.
25 *
26 * MMU mode suffixes are defined in target cpu.h.
27 */
28 #ifndef CPU_LDST_H
29 #define CPU_LDST_H
30
31 #if defined(CONFIG_USER_ONLY)
32 /* All direct uses of g2h and h2g need to go away for usermode softmmu. */
33 #define g2h(x) ((void *)((unsigned long)(target_ulong)(x) + GUEST_BASE))
34
35 #if HOST_LONG_BITS <= TARGET_VIRT_ADDR_SPACE_BITS
36 #define h2g_valid(x) 1
37 #else
38 #define h2g_valid(x) ({ \
39 unsigned long __guest = (unsigned long)(x) - GUEST_BASE; \
40 (__guest < (1ul << TARGET_VIRT_ADDR_SPACE_BITS)) && \
41 (!RESERVED_VA || (__guest < RESERVED_VA)); \
42 })
43 #endif
44
45 #define h2g_nocheck(x) ({ \
46 unsigned long __ret = (unsigned long)(x) - GUEST_BASE; \
47 (abi_ulong)__ret; \
48 })
49
50 #define h2g(x) ({ \
51 /* Check if given address fits target address space */ \
52 assert(h2g_valid(x)); \
53 h2g_nocheck(x); \
54 })
55
56 #define saddr(x) g2h(x)
57 #define laddr(x) g2h(x)
58
59 #else /* !CONFIG_USER_ONLY */
60 /* NOTE: we use double casts if pointers and target_ulong have
61 different sizes */
62 #define saddr(x) (uint8_t *)(intptr_t)(x)
63 #define laddr(x) (uint8_t *)(intptr_t)(x)
64 #endif
65
66 #define ldub_raw(p) ldub_p(laddr((p)))
67 #define ldsb_raw(p) ldsb_p(laddr((p)))
68 #define lduw_raw(p) lduw_p(laddr((p)))
69 #define ldsw_raw(p) ldsw_p(laddr((p)))
70 #define ldl_raw(p) ldl_p(laddr((p)))
71 #define ldq_raw(p) ldq_p(laddr((p)))
72 #define ldfl_raw(p) ldfl_p(laddr((p)))
73 #define ldfq_raw(p) ldfq_p(laddr((p)))
74 #define stb_raw(p, v) stb_p(saddr((p)), v)
75 #define stw_raw(p, v) stw_p(saddr((p)), v)
76 #define stl_raw(p, v) stl_p(saddr((p)), v)
77 #define stq_raw(p, v) stq_p(saddr((p)), v)
78 #define stfl_raw(p, v) stfl_p(saddr((p)), v)
79 #define stfq_raw(p, v) stfq_p(saddr((p)), v)
80
81
82 #if defined(CONFIG_USER_ONLY)
83
84 /* if user mode, no other memory access functions */
85 #define ldub(p) ldub_raw(p)
86 #define ldsb(p) ldsb_raw(p)
87 #define lduw(p) lduw_raw(p)
88 #define ldsw(p) ldsw_raw(p)
89 #define ldl(p) ldl_raw(p)
90 #define ldq(p) ldq_raw(p)
91 #define ldfl(p) ldfl_raw(p)
92 #define ldfq(p) ldfq_raw(p)
93 #define stb(p, v) stb_raw(p, v)
94 #define stw(p, v) stw_raw(p, v)
95 #define stl(p, v) stl_raw(p, v)
96 #define stq(p, v) stq_raw(p, v)
97 #define stfl(p, v) stfl_raw(p, v)
98 #define stfq(p, v) stfq_raw(p, v)
99
100 #define cpu_ldub_code(env1, p) ldub_raw(p)
101 #define cpu_ldsb_code(env1, p) ldsb_raw(p)
102 #define cpu_lduw_code(env1, p) lduw_raw(p)
103 #define cpu_ldsw_code(env1, p) ldsw_raw(p)
104 #define cpu_ldl_code(env1, p) ldl_raw(p)
105 #define cpu_ldq_code(env1, p) ldq_raw(p)
106
107 #define cpu_ldub_data(env, addr) ldub_raw(addr)
108 #define cpu_lduw_data(env, addr) lduw_raw(addr)
109 #define cpu_ldsw_data(env, addr) ldsw_raw(addr)
110 #define cpu_ldl_data(env, addr) ldl_raw(addr)
111 #define cpu_ldq_data(env, addr) ldq_raw(addr)
112
113 #define cpu_stb_data(env, addr, data) stb_raw(addr, data)
114 #define cpu_stw_data(env, addr, data) stw_raw(addr, data)
115 #define cpu_stl_data(env, addr, data) stl_raw(addr, data)
116 #define cpu_stq_data(env, addr, data) stq_raw(addr, data)
117
118 #define cpu_ldub_kernel(env, addr) ldub_raw(addr)
119 #define cpu_lduw_kernel(env, addr) lduw_raw(addr)
120 #define cpu_ldsw_kernel(env, addr) ldsw_raw(addr)
121 #define cpu_ldl_kernel(env, addr) ldl_raw(addr)
122 #define cpu_ldq_kernel(env, addr) ldq_raw(addr)
123
124 #define cpu_stb_kernel(env, addr, data) stb_raw(addr, data)
125 #define cpu_stw_kernel(env, addr, data) stw_raw(addr, data)
126 #define cpu_stl_kernel(env, addr, data) stl_raw(addr, data)
127 #define cpu_stq_kernel(env, addr, data) stq_raw(addr, data)
128
129 #define ldub_kernel(p) ldub_raw(p)
130 #define ldsb_kernel(p) ldsb_raw(p)
131 #define lduw_kernel(p) lduw_raw(p)
132 #define ldsw_kernel(p) ldsw_raw(p)
133 #define ldl_kernel(p) ldl_raw(p)
134 #define ldq_kernel(p) ldq_raw(p)
135 #define ldfl_kernel(p) ldfl_raw(p)
136 #define ldfq_kernel(p) ldfq_raw(p)
137 #define stb_kernel(p, v) stb_raw(p, v)
138 #define stw_kernel(p, v) stw_raw(p, v)
139 #define stl_kernel(p, v) stl_raw(p, v)
140 #define stq_kernel(p, v) stq_raw(p, v)
141 #define stfl_kernel(p, v) stfl_raw(p, v)
142 #define stfq_kernel(p, vt) stfq_raw(p, v)
143
144 #define cpu_ldub_data(env, addr) ldub_raw(addr)
145 #define cpu_lduw_data(env, addr) lduw_raw(addr)
146 #define cpu_ldl_data(env, addr) ldl_raw(addr)
147
148 #define cpu_stb_data(env, addr, data) stb_raw(addr, data)
149 #define cpu_stw_data(env, addr, data) stw_raw(addr, data)
150 #define cpu_stl_data(env, addr, data) stl_raw(addr, data)
151
152 #else
153
154 /* XXX: find something cleaner.
155 * Furthermore, this is false for 64 bits targets
156 */
157 #define ldul_user ldl_user
158 #define ldul_kernel ldl_kernel
159 #define ldul_hypv ldl_hypv
160 #define ldul_executive ldl_executive
161 #define ldul_supervisor ldl_supervisor
162
163 /* The memory helpers for tcg-generated code need tcg_target_long etc. */
164 #include "tcg.h"
165
166 uint8_t helper_ldb_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
167 uint16_t helper_ldw_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
168 uint32_t helper_ldl_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
169 uint64_t helper_ldq_mmu(CPUArchState *env, target_ulong addr, int mmu_idx);
170
171 void helper_stb_mmu(CPUArchState *env, target_ulong addr,
172 uint8_t val, int mmu_idx);
173 void helper_stw_mmu(CPUArchState *env, target_ulong addr,
174 uint16_t val, int mmu_idx);
175 void helper_stl_mmu(CPUArchState *env, target_ulong addr,
176 uint32_t val, int mmu_idx);
177 void helper_stq_mmu(CPUArchState *env, target_ulong addr,
178 uint64_t val, int mmu_idx);
179
180 uint8_t helper_ldb_cmmu(CPUArchState *env, target_ulong addr, int mmu_idx);
181 uint16_t helper_ldw_cmmu(CPUArchState *env, target_ulong addr, int mmu_idx);
182 uint32_t helper_ldl_cmmu(CPUArchState *env, target_ulong addr, int mmu_idx);
183 uint64_t helper_ldq_cmmu(CPUArchState *env, target_ulong addr, int mmu_idx);
184
185 #define CPU_MMU_INDEX 0
186 #define MEMSUFFIX MMU_MODE0_SUFFIX
187 #define DATA_SIZE 1
188 #include "exec/cpu_ldst_template.h"
189
190 #define DATA_SIZE 2
191 #include "exec/cpu_ldst_template.h"
192
193 #define DATA_SIZE 4
194 #include "exec/cpu_ldst_template.h"
195
196 #define DATA_SIZE 8
197 #include "exec/cpu_ldst_template.h"
198 #undef CPU_MMU_INDEX
199 #undef MEMSUFFIX
200
201 #define CPU_MMU_INDEX 1
202 #define MEMSUFFIX MMU_MODE1_SUFFIX
203 #define DATA_SIZE 1
204 #include "exec/cpu_ldst_template.h"
205
206 #define DATA_SIZE 2
207 #include "exec/cpu_ldst_template.h"
208
209 #define DATA_SIZE 4
210 #include "exec/cpu_ldst_template.h"
211
212 #define DATA_SIZE 8
213 #include "exec/cpu_ldst_template.h"
214 #undef CPU_MMU_INDEX
215 #undef MEMSUFFIX
216
217 #if (NB_MMU_MODES >= 3)
218
219 #define CPU_MMU_INDEX 2
220 #define MEMSUFFIX MMU_MODE2_SUFFIX
221 #define DATA_SIZE 1
222 #include "exec/cpu_ldst_template.h"
223
224 #define DATA_SIZE 2
225 #include "exec/cpu_ldst_template.h"
226
227 #define DATA_SIZE 4
228 #include "exec/cpu_ldst_template.h"
229
230 #define DATA_SIZE 8
231 #include "exec/cpu_ldst_template.h"
232 #undef CPU_MMU_INDEX
233 #undef MEMSUFFIX
234 #endif /* (NB_MMU_MODES >= 3) */
235
236 #if (NB_MMU_MODES >= 4)
237
238 #define CPU_MMU_INDEX 3
239 #define MEMSUFFIX MMU_MODE3_SUFFIX
240 #define DATA_SIZE 1
241 #include "exec/cpu_ldst_template.h"
242
243 #define DATA_SIZE 2
244 #include "exec/cpu_ldst_template.h"
245
246 #define DATA_SIZE 4
247 #include "exec/cpu_ldst_template.h"
248
249 #define DATA_SIZE 8
250 #include "exec/cpu_ldst_template.h"
251 #undef CPU_MMU_INDEX
252 #undef MEMSUFFIX
253 #endif /* (NB_MMU_MODES >= 4) */
254
255 #if (NB_MMU_MODES >= 5)
256
257 #define CPU_MMU_INDEX 4
258 #define MEMSUFFIX MMU_MODE4_SUFFIX
259 #define DATA_SIZE 1
260 #include "exec/cpu_ldst_template.h"
261
262 #define DATA_SIZE 2
263 #include "exec/cpu_ldst_template.h"
264
265 #define DATA_SIZE 4
266 #include "exec/cpu_ldst_template.h"
267
268 #define DATA_SIZE 8
269 #include "exec/cpu_ldst_template.h"
270 #undef CPU_MMU_INDEX
271 #undef MEMSUFFIX
272 #endif /* (NB_MMU_MODES >= 5) */
273
274 #if (NB_MMU_MODES >= 6)
275
276 #define CPU_MMU_INDEX 5
277 #define MEMSUFFIX MMU_MODE5_SUFFIX
278 #define DATA_SIZE 1
279 #include "exec/cpu_ldst_template.h"
280
281 #define DATA_SIZE 2
282 #include "exec/cpu_ldst_template.h"
283
284 #define DATA_SIZE 4
285 #include "exec/cpu_ldst_template.h"
286
287 #define DATA_SIZE 8
288 #include "exec/cpu_ldst_template.h"
289 #undef CPU_MMU_INDEX
290 #undef MEMSUFFIX
291 #endif /* (NB_MMU_MODES >= 6) */
292
293 #if (NB_MMU_MODES > 6)
294 #error "NB_MMU_MODES > 6 is not supported for now"
295 #endif /* (NB_MMU_MODES > 6) */
296
297 /* these access are slower, they must be as rare as possible */
298 #define CPU_MMU_INDEX (cpu_mmu_index(env))
299 #define MEMSUFFIX _data
300 #define DATA_SIZE 1
301 #include "exec/cpu_ldst_template.h"
302
303 #define DATA_SIZE 2
304 #include "exec/cpu_ldst_template.h"
305
306 #define DATA_SIZE 4
307 #include "exec/cpu_ldst_template.h"
308
309 #define DATA_SIZE 8
310 #include "exec/cpu_ldst_template.h"
311 #undef CPU_MMU_INDEX
312 #undef MEMSUFFIX
313
314 #define ldub(p) ldub_data(p)
315 #define ldsb(p) ldsb_data(p)
316 #define lduw(p) lduw_data(p)
317 #define ldsw(p) ldsw_data(p)
318 #define ldl(p) ldl_data(p)
319 #define ldq(p) ldq_data(p)
320
321 #define stb(p, v) stb_data(p, v)
322 #define stw(p, v) stw_data(p, v)
323 #define stl(p, v) stl_data(p, v)
324 #define stq(p, v) stq_data(p, v)
325
326 #define CPU_MMU_INDEX (cpu_mmu_index(env))
327 #define MEMSUFFIX _code
328 #define SOFTMMU_CODE_ACCESS
329
330 #define DATA_SIZE 1
331 #include "exec/cpu_ldst_template.h"
332
333 #define DATA_SIZE 2
334 #include "exec/cpu_ldst_template.h"
335
336 #define DATA_SIZE 4
337 #include "exec/cpu_ldst_template.h"
338
339 #define DATA_SIZE 8
340 #include "exec/cpu_ldst_template.h"
341
342 #undef CPU_MMU_INDEX
343 #undef MEMSUFFIX
344 #undef SOFTMMU_CODE_ACCESS
345
346 /**
347 * tlb_vaddr_to_host:
348 * @env: CPUArchState
349 * @addr: guest virtual address to look up
350 * @access_type: 0 for read, 1 for write, 2 for execute
351 * @mmu_idx: MMU index to use for lookup
352 *
353 * Look up the specified guest virtual index in the TCG softmmu TLB.
354 * If the TLB contains a host virtual address suitable for direct RAM
355 * access, then return it. Otherwise (TLB miss, TLB entry is for an
356 * I/O access, etc) return NULL.
357 *
358 * This is the equivalent of the initial fast-path code used by
359 * TCG backends for guest load and store accesses.
360 */
tlb_vaddr_to_host(CPUArchState * env,target_ulong addr,int access_type,int mmu_idx)361 static inline void *tlb_vaddr_to_host(CPUArchState *env, target_ulong addr,
362 int access_type, int mmu_idx)
363 {
364 int index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
365 CPUTLBEntry *tlbentry = &env->tlb_table[mmu_idx][index];
366 target_ulong tlb_addr;
367 uintptr_t haddr;
368
369 switch (access_type) {
370 case 0:
371 tlb_addr = tlbentry->addr_read;
372 break;
373 case 1:
374 tlb_addr = tlbentry->addr_write;
375 break;
376 case 2:
377 tlb_addr = tlbentry->addr_code;
378 break;
379 default:
380 g_assert_not_reached();
381 }
382
383 if ((addr & TARGET_PAGE_MASK)
384 != (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
385 /* TLB entry is for a different page */
386 return NULL;
387 }
388
389 if (tlb_addr & ~TARGET_PAGE_MASK) {
390 /* IO access */
391 return NULL;
392 }
393
394 haddr = (uintptr_t)(addr + env->tlb_table[mmu_idx][index].addend);
395 return (void *)haddr;
396 }
397
398 #endif /* defined(CONFIG_USER_ONLY) */
399
400 #endif /* CPU_LDST_H */
401