1 /*
2 * Software MMU support
3 *
4 * Generate inline load/store functions for one MMU mode and data
5 * size.
6 *
7 * Generate a store function as well as signed and unsigned loads. For
8 * 32 and 64 bit cases, also generate floating point functions with
9 * the same size.
10 *
11 * Not used directly but included from softmmu_exec.h and exec-all.h.
12 *
13 * Copyright (c) 2003 Fabrice Bellard
14 *
15 * This library is free software; you can redistribute it and/or
16 * modify it under the terms of the GNU Lesser General Public
17 * License as published by the Free Software Foundation; either
18 * version 2 of the License, or (at your option) any later version.
19 *
20 * This library is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23 * Lesser General Public License for more details.
24 *
25 * You should have received a copy of the GNU Lesser General Public
26 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
27 */
28 #if DATA_SIZE == 8
29 #define SUFFIX q
30 #define USUFFIX q
31 #define DATA_TYPE uint64_t
32 #elif DATA_SIZE == 4
33 #define SUFFIX l
34 #define USUFFIX l
35 #define DATA_TYPE uint32_t
36 #elif DATA_SIZE == 2
37 #define SUFFIX w
38 #define USUFFIX uw
39 #define DATA_TYPE uint16_t
40 #define DATA_STYPE int16_t
41 #elif DATA_SIZE == 1
42 #define SUFFIX b
43 #define USUFFIX ub
44 #define DATA_TYPE uint8_t
45 #define DATA_STYPE int8_t
46 #else
47 #error unsupported data size
48 #endif
49
50 #if ACCESS_TYPE < (NB_MMU_MODES)
51
52 #define CPU_MMU_INDEX ACCESS_TYPE
53 #define MMUSUFFIX _mmu
54
55 #elif ACCESS_TYPE == (NB_MMU_MODES)
56
57 #define CPU_MMU_INDEX (cpu_mmu_index(env))
58 #define MMUSUFFIX _mmu
59
60 #elif ACCESS_TYPE == (NB_MMU_MODES + 1)
61
62 #define CPU_MMU_INDEX (cpu_mmu_index(env))
63 #define MMUSUFFIX _cmmu
64
65 #else
66 #error invalid ACCESS_TYPE
67 #endif
68
69 #if DATA_SIZE == 8
70 #define RES_TYPE uint64_t
71 #else
72 #define RES_TYPE uint32_t
73 #endif
74
75 #if ACCESS_TYPE == (NB_MMU_MODES + 1)
76 #define ADDR_READ addr_code
77 #else
78 #define ADDR_READ addr_read
79 #endif
80
81 /* generic load/store macros */
82
83 static inline RES_TYPE
glue(glue (cpu_ld,USUFFIX),MEMSUFFIX)84 glue(glue(cpu_ld, USUFFIX), MEMSUFFIX)(CPUArchState *env, target_ulong ptr)
85 {
86 int page_index;
87 RES_TYPE res;
88 target_ulong addr;
89 int mmu_idx;
90
91 addr = ptr;
92 page_index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
93 mmu_idx = CPU_MMU_INDEX;
94 if (unlikely(env->tlb_table[mmu_idx][page_index].ADDR_READ !=
95 (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))))) {
96 res = glue(glue(helper_ld, SUFFIX), MMUSUFFIX)(env, addr, mmu_idx);
97 } else {
98 uintptr_t hostaddr = addr + env->tlb_table[mmu_idx][page_index].addend;
99 res = glue(glue(ld, USUFFIX), _raw)(hostaddr);
100 }
101 return res;
102 }
103
104 #if DATA_SIZE <= 2
105 static inline int
glue(glue (cpu_lds,SUFFIX),MEMSUFFIX)106 glue(glue(cpu_lds, SUFFIX), MEMSUFFIX)(CPUArchState *env, target_ulong ptr)
107 {
108 int res, page_index;
109 target_ulong addr;
110 int mmu_idx;
111
112 addr = ptr;
113 page_index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
114 mmu_idx = CPU_MMU_INDEX;
115 if (unlikely(env->tlb_table[mmu_idx][page_index].ADDR_READ !=
116 (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))))) {
117 res = (DATA_STYPE)glue(glue(helper_ld, SUFFIX),
118 MMUSUFFIX)(env, addr, mmu_idx);
119 } else {
120 uintptr_t hostaddr = addr + env->tlb_table[mmu_idx][page_index].addend;
121 res = glue(glue(lds, SUFFIX), _raw)(hostaddr);
122 }
123 return res;
124 }
125 #endif
126
127 #if ACCESS_TYPE != (NB_MMU_MODES + 1)
128
129 /* generic store macro */
130
131 static inline void
glue(glue (cpu_st,SUFFIX),MEMSUFFIX)132 glue(glue(cpu_st, SUFFIX), MEMSUFFIX)(CPUArchState *env, target_ulong ptr,
133 RES_TYPE v)
134 {
135 int page_index;
136 target_ulong addr;
137 int mmu_idx;
138
139 addr = ptr;
140 page_index = (addr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
141 mmu_idx = CPU_MMU_INDEX;
142 if (unlikely(env->tlb_table[mmu_idx][page_index].addr_write !=
143 (addr & (TARGET_PAGE_MASK | (DATA_SIZE - 1))))) {
144 glue(glue(helper_st, SUFFIX), MMUSUFFIX)(env, addr, v, mmu_idx);
145 } else {
146 uintptr_t hostaddr = addr + env->tlb_table[mmu_idx][page_index].addend;
147 glue(glue(st, SUFFIX), _raw)(hostaddr, v);
148 }
149 }
150
151 #endif /* ACCESS_TYPE != (NB_MMU_MODES + 1) */
152
153 #if ACCESS_TYPE != (NB_MMU_MODES + 1)
154
155 #if DATA_SIZE == 8
glue(cpu_ldfq,MEMSUFFIX)156 static inline float64 glue(cpu_ldfq, MEMSUFFIX)(CPUArchState *env,
157 target_ulong ptr)
158 {
159 union {
160 float64 d;
161 uint64_t i;
162 } u;
163 u.i = glue(cpu_ldq, MEMSUFFIX)(env, ptr);
164 return u.d;
165 }
166
glue(cpu_stfq,MEMSUFFIX)167 static inline void glue(cpu_stfq, MEMSUFFIX)(CPUArchState *env,
168 target_ulong ptr, float64 v)
169 {
170 union {
171 float64 d;
172 uint64_t i;
173 } u;
174 u.d = v;
175 glue(cpu_stq, MEMSUFFIX)(env, ptr, u.i);
176 }
177 #endif /* DATA_SIZE == 8 */
178
179 #if DATA_SIZE == 4
glue(cpu_ldfl,MEMSUFFIX)180 static inline float32 glue(cpu_ldfl, MEMSUFFIX)(CPUArchState *env,
181 target_ulong ptr)
182 {
183 union {
184 float32 f;
185 uint32_t i;
186 } u;
187 u.i = glue(cpu_ldl, MEMSUFFIX)(env, ptr);
188 return u.f;
189 }
190
glue(cpu_stfl,MEMSUFFIX)191 static inline void glue(cpu_stfl, MEMSUFFIX)(CPUArchState *env,
192 target_ulong ptr, float32 v)
193 {
194 union {
195 float32 f;
196 uint32_t i;
197 } u;
198 u.f = v;
199 glue(cpu_stl, MEMSUFFIX)(env, ptr, u.i);
200 }
201 #endif /* DATA_SIZE == 4 */
202
203 #endif /* ACCESS_TYPE != (NB_MMU_MODES + 1) */
204
205 #undef RES_TYPE
206 #undef DATA_TYPE
207 #undef DATA_STYPE
208 #undef SUFFIX
209 #undef USUFFIX
210 #undef DATA_SIZE
211 #undef CPU_MMU_INDEX
212 #undef MMUSUFFIX
213 #undef ADDR_READ
214