include/exec/cpu_ldst.h

   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.1 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  * The syntax for the accessors is:
  27  *
  28  * load:  cpu_ld{sign}{size}{end}_{mmusuffix}(env, ptr)
  29  *        cpu_ld{sign}{size}{end}_{mmusuffix}_ra(env, ptr, retaddr)
  30  *        cpu_ld{sign}{size}{end}_mmuidx_ra(env, ptr, mmu_idx, retaddr)
  31  *
  32  * store: cpu_st{size}{end}_{mmusuffix}(env, ptr, val)
  33  *        cpu_st{size}{end}_{mmusuffix}_ra(env, ptr, val, retaddr)
  34  *        cpu_st{size}{end}_mmuidx_ra(env, ptr, val, mmu_idx, retaddr)
  35  *
  36  * sign is:
  37  * (empty): for 32 and 64 bit sizes
  38  *   u    : unsigned
  39  *   s    : signed
  40  *
  41  * size is:
  42  *   b: 8 bits
  43  *   w: 16 bits
  44  *   l: 32 bits
  45  *   q: 64 bits
  46  *
  47  * end is:
  48  * (empty): for target native endian, or for 8 bit access
  49  *     _be: for forced big endian
  50  *     _le: for forced little endian
  51  *
  52  * mmusuffix is one of the generic suffixes "data" or "code", or "mmuidx".
  53  * The "mmuidx" suffix carries an extra mmu_idx argument that specifies
  54  * the index to use; the "data" and "code" suffixes take the index from
  55  * cpu_mmu_index().
  56  */
  57 #ifndef CPU_LDST_H
  58 #define CPU_LDST_H
  59
  60 #if defined(CONFIG_USER_ONLY)
  61 /* sparc32plus has 64bit long but 32bit space address
  62  * this can make bad result with g2h() and h2g()
  63  */
  64 #if TARGET_VIRT_ADDR_SPACE_BITS <= 32
  65 typedef uint32_t abi_ptr;
  66 #define TARGET_ABI_FMT_ptr "%x"
  67 #else
  68 typedef uint64_t abi_ptr;
  69 #define TARGET_ABI_FMT_ptr "%"PRIx64
  70 #endif
  71
  72 /* All direct uses of g2h and h2g need to go away for usermode softmmu.  */
  73 #define g2h(x) ((void *)((unsigned long)(abi_ptr)(x) + guest_base))
  74
  75 #if HOST_LONG_BITS <= TARGET_VIRT_ADDR_SPACE_BITS
  76 #define guest_addr_valid(x) (1)
  77 #else
  78 #define guest_addr_valid(x) ((x) <= GUEST_ADDR_MAX)
  79 #endif
  80 #define h2g_valid(x) guest_addr_valid((unsigned long)(x) - guest_base)
  81
  82 static inline int guest_range_valid(unsigned long start, unsigned long len)
  83 {
  84     return len - 1 <= GUEST_ADDR_MAX && start <= GUEST_ADDR_MAX - len + 1;
  85 }
  86
  87 #define h2g_nocheck(x) ({ \
  88     unsigned long __ret = (unsigned long)(x) - guest_base; \
  89     (abi_ptr)__ret; \
  90 })
  91
  92 #define h2g(x) ({ \
  93     /* Check if given address fits target address space */ \
  94     assert(h2g_valid(x)); \
  95     h2g_nocheck(x); \
  96 })
  97 #else
  98 typedef target_ulong abi_ptr;
  99 #define TARGET_ABI_FMT_ptr TARGET_ABI_FMT_lx
 100 #endif
 101
 102 uint32_t cpu_ldub_data(CPUArchState *env, abi_ptr ptr);
 103 int cpu_ldsb_data(CPUArchState *env, abi_ptr ptr);
 104
 105 uint32_t cpu_lduw_be_data(CPUArchState *env, abi_ptr ptr);
 106 int cpu_ldsw_be_data(CPUArchState *env, abi_ptr ptr);
 107 uint32_t cpu_ldl_be_data(CPUArchState *env, abi_ptr ptr);
 108 uint64_t cpu_ldq_be_data(CPUArchState *env, abi_ptr ptr);
 109
 110 uint32_t cpu_lduw_le_data(CPUArchState *env, abi_ptr ptr);
 111 int cpu_ldsw_le_data(CPUArchState *env, abi_ptr ptr);
 112 uint32_t cpu_ldl_le_data(CPUArchState *env, abi_ptr ptr);
 113 uint64_t cpu_ldq_le_data(CPUArchState *env, abi_ptr ptr);
 114
 115 uint32_t cpu_ldub_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t ra);
 116 int cpu_ldsb_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t ra);
 117
 118 uint32_t cpu_lduw_be_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t ra);
 119 int cpu_ldsw_be_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t ra);
 120 uint32_t cpu_ldl_be_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t ra);
 121 uint64_t cpu_ldq_be_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t ra);
 122
 123 uint32_t cpu_lduw_le_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t ra);
 124 int cpu_ldsw_le_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t ra);
 125 uint32_t cpu_ldl_le_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t ra);
 126 uint64_t cpu_ldq_le_data_ra(CPUArchState *env, abi_ptr ptr, uintptr_t ra);
 127
 128 void cpu_stb_data(CPUArchState *env, abi_ptr ptr, uint32_t val);
 129
 130 void cpu_stw_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val);
 131 void cpu_stl_be_data(CPUArchState *env, abi_ptr ptr, uint32_t val);
 132 void cpu_stq_be_data(CPUArchState *env, abi_ptr ptr, uint64_t val);
 133
 134 void cpu_stw_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val);
 135 void cpu_stl_le_data(CPUArchState *env, abi_ptr ptr, uint32_t val);
 136 void cpu_stq_le_data(CPUArchState *env, abi_ptr ptr, uint64_t val);
 137
 138 void cpu_stb_data_ra(CPUArchState *env, abi_ptr ptr,
 139                      uint32_t val, uintptr_t ra);
 140
 141 void cpu_stw_be_data_ra(CPUArchState *env, abi_ptr ptr,
 142                         uint32_t val, uintptr_t ra);
 143 void cpu_stl_be_data_ra(CPUArchState *env, abi_ptr ptr,
 144                         uint32_t val, uintptr_t ra);
 145 void cpu_stq_be_data_ra(CPUArchState *env, abi_ptr ptr,
 146                         uint64_t val, uintptr_t ra);
 147
 148 void cpu_stw_le_data_ra(CPUArchState *env, abi_ptr ptr,
 149                         uint32_t val, uintptr_t ra);
 150 void cpu_stl_le_data_ra(CPUArchState *env, abi_ptr ptr,
 151                         uint32_t val, uintptr_t ra);
 152 void cpu_stq_le_data_ra(CPUArchState *env, abi_ptr ptr,
 153                         uint64_t val, uintptr_t ra);
 154
 155 #if defined(CONFIG_USER_ONLY)
 156
 157 extern __thread uintptr_t helper_retaddr;
 158
 159 static inline void set_helper_retaddr(uintptr_t ra)
 160 {
 161     helper_retaddr = ra;
 162     /*
 163      * Ensure that this write is visible to the SIGSEGV handler that
 164      * may be invoked due to a subsequent invalid memory operation.
 165      */
 166     signal_barrier();
 167 }
 168
 169 static inline void clear_helper_retaddr(void)
 170 {
 171     /*
 172      * Ensure that previous memory operations have succeeded before
 173      * removing the data visible to the signal handler.
 174      */
 175     signal_barrier();
 176     helper_retaddr = 0;
 177 }
 178
 179 /*
 180  * Provide the same *_mmuidx_ra interface as for softmmu.
 181  * The mmu_idx argument is ignored.
 182  */
 183
 184 static inline uint32_t cpu_ldub_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 185                                           int mmu_idx, uintptr_t ra)
 186 {
 187     return cpu_ldub_data_ra(env, addr, ra);
 188 }
 189
 190 static inline int cpu_ldsb_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 191                                      int mmu_idx, uintptr_t ra)
 192 {
 193     return cpu_ldsb_data_ra(env, addr, ra);
 194 }
 195
 196 static inline uint32_t cpu_lduw_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 197                                              int mmu_idx, uintptr_t ra)
 198 {
 199     return cpu_lduw_be_data_ra(env, addr, ra);
 200 }
 201
 202 static inline int cpu_ldsw_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 203                                         int mmu_idx, uintptr_t ra)
 204 {
 205     return cpu_ldsw_be_data_ra(env, addr, ra);
 206 }
 207
 208 static inline uint32_t cpu_ldl_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 209                                             int mmu_idx, uintptr_t ra)
 210 {
 211     return cpu_ldl_be_data_ra(env, addr, ra);
 212 }
 213
 214 static inline uint64_t cpu_ldq_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 215                                             int mmu_idx, uintptr_t ra)
 216 {
 217     return cpu_ldq_be_data_ra(env, addr, ra);
 218 }
 219
 220 static inline uint32_t cpu_lduw_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 221                                              int mmu_idx, uintptr_t ra)
 222 {
 223     return cpu_lduw_le_data_ra(env, addr, ra);
 224 }
 225
 226 static inline int cpu_ldsw_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 227                                         int mmu_idx, uintptr_t ra)
 228 {
 229     return cpu_ldsw_le_data_ra(env, addr, ra);
 230 }
 231
 232 static inline uint32_t cpu_ldl_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 233                                             int mmu_idx, uintptr_t ra)
 234 {
 235     return cpu_ldl_le_data_ra(env, addr, ra);
 236 }
 237
 238 static inline uint64_t cpu_ldq_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 239                                             int mmu_idx, uintptr_t ra)
 240 {
 241     return cpu_ldq_le_data_ra(env, addr, ra);
 242 }
 243
 244 static inline void cpu_stb_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 245                                      uint32_t val, int mmu_idx, uintptr_t ra)
 246 {
 247     cpu_stb_data_ra(env, addr, val, ra);
 248 }
 249
 250 static inline void cpu_stw_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 251                                         uint32_t val, int mmu_idx,
 252                                         uintptr_t ra)
 253 {
 254     cpu_stw_be_data_ra(env, addr, val, ra);
 255 }
 256
 257 static inline void cpu_stl_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 258                                         uint32_t val, int mmu_idx,
 259                                         uintptr_t ra)
 260 {
 261     cpu_stl_be_data_ra(env, addr, val, ra);
 262 }
 263
 264 static inline void cpu_stq_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 265                                         uint64_t val, int mmu_idx,
 266                                         uintptr_t ra)
 267 {
 268     cpu_stq_be_data_ra(env, addr, val, ra);
 269 }
 270
 271 static inline void cpu_stw_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 272                                         uint32_t val, int mmu_idx,
 273                                         uintptr_t ra)
 274 {
 275     cpu_stw_le_data_ra(env, addr, val, ra);
 276 }
 277
 278 static inline void cpu_stl_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 279                                         uint32_t val, int mmu_idx,
 280                                         uintptr_t ra)
 281 {
 282     cpu_stl_le_data_ra(env, addr, val, ra);
 283 }
 284
 285 static inline void cpu_stq_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 286                                         uint64_t val, int mmu_idx,
 287                                         uintptr_t ra)
 288 {
 289     cpu_stq_le_data_ra(env, addr, val, ra);
 290 }
 291
 292 #else
 293
 294 /* Needed for TCG_OVERSIZED_GUEST */
 295 #include "tcg/tcg.h"
 296
 297 static inline target_ulong tlb_addr_write(const CPUTLBEntry *entry)
 298 {
 299 #if TCG_OVERSIZED_GUEST
 300     return entry->addr_write;
 301 #else
 302     return qatomic_read(&entry->addr_write);
 303 #endif
 304 }
 305
 306 /* Find the TLB index corresponding to the mmu_idx + address pair.  */
 307 static inline uintptr_t tlb_index(CPUArchState *env, uintptr_t mmu_idx,
 308                                   target_ulong addr)
 309 {
 310     uintptr_t size_mask = env_tlb(env)->f[mmu_idx].mask >> CPU_TLB_ENTRY_BITS;
 311
 312     return (addr >> TARGET_PAGE_BITS) & size_mask;
 313 }
 314
 315 /* Find the TLB entry corresponding to the mmu_idx + address pair.  */
 316 static inline CPUTLBEntry *tlb_entry(CPUArchState *env, uintptr_t mmu_idx,
 317                                      target_ulong addr)
 318 {
 319     return &env_tlb(env)->f[mmu_idx].table[tlb_index(env, mmu_idx, addr)];
 320 }
 321
 322 uint32_t cpu_ldub_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 323                             int mmu_idx, uintptr_t ra);
 324 int cpu_ldsb_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 325                        int mmu_idx, uintptr_t ra);
 326
 327 uint32_t cpu_lduw_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 328                                int mmu_idx, uintptr_t ra);
 329 int cpu_ldsw_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 330                           int mmu_idx, uintptr_t ra);
 331 uint32_t cpu_ldl_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 332                               int mmu_idx, uintptr_t ra);
 333 uint64_t cpu_ldq_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 334                               int mmu_idx, uintptr_t ra);
 335
 336 uint32_t cpu_lduw_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 337                                int mmu_idx, uintptr_t ra);
 338 int cpu_ldsw_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 339                           int mmu_idx, uintptr_t ra);
 340 uint32_t cpu_ldl_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 341                               int mmu_idx, uintptr_t ra);
 342 uint64_t cpu_ldq_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 343                               int mmu_idx, uintptr_t ra);
 344
 345 void cpu_stb_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint32_t val,
 346                        int mmu_idx, uintptr_t retaddr);
 347
 348 void cpu_stw_be_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint32_t val,
 349                           int mmu_idx, uintptr_t retaddr);
 350 void cpu_stl_be_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint32_t val,
 351                           int mmu_idx, uintptr_t retaddr);
 352 void cpu_stq_be_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint64_t val,
 353                           int mmu_idx, uintptr_t retaddr);
 354
 355 void cpu_stw_le_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint32_t val,
 356                           int mmu_idx, uintptr_t retaddr);
 357 void cpu_stl_le_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint32_t val,
 358                           int mmu_idx, uintptr_t retaddr);
 359 void cpu_stq_le_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint64_t val,
 360                           int mmu_idx, uintptr_t retaddr);
 361
 362 #endif /* defined(CONFIG_USER_ONLY) */
 363
 364 #ifdef TARGET_WORDS_BIGENDIAN
 365 # define cpu_lduw_data        cpu_lduw_be_data
 366 # define cpu_ldsw_data        cpu_ldsw_be_data
 367 # define cpu_ldl_data         cpu_ldl_be_data
 368 # define cpu_ldq_data         cpu_ldq_be_data
 369 # define cpu_lduw_data_ra     cpu_lduw_be_data_ra
 370 # define cpu_ldsw_data_ra     cpu_ldsw_be_data_ra
 371 # define cpu_ldl_data_ra      cpu_ldl_be_data_ra
 372 # define cpu_ldq_data_ra      cpu_ldq_be_data_ra
 373 # define cpu_lduw_mmuidx_ra   cpu_lduw_be_mmuidx_ra
 374 # define cpu_ldsw_mmuidx_ra   cpu_ldsw_be_mmuidx_ra
 375 # define cpu_ldl_mmuidx_ra    cpu_ldl_be_mmuidx_ra
 376 # define cpu_ldq_mmuidx_ra    cpu_ldq_be_mmuidx_ra
 377 # define cpu_stw_data         cpu_stw_be_data
 378 # define cpu_stl_data         cpu_stl_be_data
 379 # define cpu_stq_data         cpu_stq_be_data
 380 # define cpu_stw_data_ra      cpu_stw_be_data_ra
 381 # define cpu_stl_data_ra      cpu_stl_be_data_ra
 382 # define cpu_stq_data_ra      cpu_stq_be_data_ra
 383 # define cpu_stw_mmuidx_ra    cpu_stw_be_mmuidx_ra
 384 # define cpu_stl_mmuidx_ra    cpu_stl_be_mmuidx_ra
 385 # define cpu_stq_mmuidx_ra    cpu_stq_be_mmuidx_ra
 386 #else
 387 # define cpu_lduw_data        cpu_lduw_le_data
 388 # define cpu_ldsw_data        cpu_ldsw_le_data
 389 # define cpu_ldl_data         cpu_ldl_le_data
 390 # define cpu_ldq_data         cpu_ldq_le_data
 391 # define cpu_lduw_data_ra     cpu_lduw_le_data_ra
 392 # define cpu_ldsw_data_ra     cpu_ldsw_le_data_ra
 393 # define cpu_ldl_data_ra      cpu_ldl_le_data_ra
 394 # define cpu_ldq_data_ra      cpu_ldq_le_data_ra
 395 # define cpu_lduw_mmuidx_ra   cpu_lduw_le_mmuidx_ra
 396 # define cpu_ldsw_mmuidx_ra   cpu_ldsw_le_mmuidx_ra
 397 # define cpu_ldl_mmuidx_ra    cpu_ldl_le_mmuidx_ra
 398 # define cpu_ldq_mmuidx_ra    cpu_ldq_le_mmuidx_ra
 399 # define cpu_stw_data         cpu_stw_le_data
 400 # define cpu_stl_data         cpu_stl_le_data
 401 # define cpu_stq_data         cpu_stq_le_data
 402 # define cpu_stw_data_ra      cpu_stw_le_data_ra
 403 # define cpu_stl_data_ra      cpu_stl_le_data_ra
 404 # define cpu_stq_data_ra      cpu_stq_le_data_ra
 405 # define cpu_stw_mmuidx_ra    cpu_stw_le_mmuidx_ra
 406 # define cpu_stl_mmuidx_ra    cpu_stl_le_mmuidx_ra
 407 # define cpu_stq_mmuidx_ra    cpu_stq_le_mmuidx_ra
 408 #endif
 409
 410 uint32_t cpu_ldub_code(CPUArchState *env, abi_ptr addr);
 411 uint32_t cpu_lduw_code(CPUArchState *env, abi_ptr addr);
 412 uint32_t cpu_ldl_code(CPUArchState *env, abi_ptr addr);
 413 uint64_t cpu_ldq_code(CPUArchState *env, abi_ptr addr);
 414
 415 static inline int cpu_ldsb_code(CPUArchState *env, abi_ptr addr)
 416 {
 417     return (int8_t)cpu_ldub_code(env, addr);
 418 }
 419
 420 static inline int cpu_ldsw_code(CPUArchState *env, abi_ptr addr)
 421 {
 422     return (int16_t)cpu_lduw_code(env, addr);
 423 }
 424
 425 /**
 426  * tlb_vaddr_to_host:
 427  * @env: CPUArchState
 428  * @addr: guest virtual address to look up
 429  * @access_type: 0 for read, 1 for write, 2 for execute
 430  * @mmu_idx: MMU index to use for lookup
 431  *
 432  * Look up the specified guest virtual index in the TCG softmmu TLB.
 433  * If we can translate a host virtual address suitable for direct RAM
 434  * access, without causing a guest exception, then return it.
 435  * Otherwise (TLB entry is for an I/O access, guest software
 436  * TLB fill required, etc) return NULL.
 437  */
 438 #ifdef CONFIG_USER_ONLY
 439 static inline void *tlb_vaddr_to_host(CPUArchState *env, abi_ptr addr,
 440                                       MMUAccessType access_type, int mmu_idx)
 441 {
 442     return g2h(addr);
 443 }
 444 #else
 445 void *tlb_vaddr_to_host(CPUArchState *env, abi_ptr addr,
 446                         MMUAccessType access_type, int mmu_idx);
 447 #endif
 448
 449 #endif /* CPU_LDST_H */