accel/tcg/ldst_common.c.inc

   1 /*
   2  * Routines common to user and system emulation of load/store.
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * SPDX-License-Identifier: GPL-2.0-or-later
   7  *
   8  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   9  * See the COPYING file in the top-level directory.
  10  */
  11 /*
  12  * Load helpers for tcg-ldst.h
  13  */
  14
  15 tcg_target_ulong helper_ldub_mmu(CPUArchState *env, uint64_t addr,
  16                                  MemOpIdx oi, uintptr_t retaddr)
  17 {
  18     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_8);
  19     return do_ld1_mmu(env_cpu(env), addr, oi, retaddr, MMU_DATA_LOAD);
  20 }
  21
  22 tcg_target_ulong helper_lduw_mmu(CPUArchState *env, uint64_t addr,
  23                                  MemOpIdx oi, uintptr_t retaddr)
  24 {
  25     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_16);
  26     return do_ld2_mmu(env_cpu(env), addr, oi, retaddr, MMU_DATA_LOAD);
  27 }
  28
  29 tcg_target_ulong helper_ldul_mmu(CPUArchState *env, uint64_t addr,
  30                                  MemOpIdx oi, uintptr_t retaddr)
  31 {
  32     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_32);
  33     return do_ld4_mmu(env_cpu(env), addr, oi, retaddr, MMU_DATA_LOAD);
  34 }
  35
  36 uint64_t helper_ldq_mmu(CPUArchState *env, uint64_t addr,
  37                         MemOpIdx oi, uintptr_t retaddr)
  38 {
  39     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_64);
  40     return do_ld8_mmu(env_cpu(env), addr, oi, retaddr, MMU_DATA_LOAD);
  41 }
  42
  43 /*
  44  * Provide signed versions of the load routines as well.  We can of course
  45  * avoid this for 64-bit data, or for 32-bit data on 32-bit host.
  46  */
  47
  48 tcg_target_ulong helper_ldsb_mmu(CPUArchState *env, uint64_t addr,
  49                                  MemOpIdx oi, uintptr_t retaddr)
  50 {
  51     return (int8_t)helper_ldub_mmu(env, addr, oi, retaddr);
  52 }
  53
  54 tcg_target_ulong helper_ldsw_mmu(CPUArchState *env, uint64_t addr,
  55                                  MemOpIdx oi, uintptr_t retaddr)
  56 {
  57     return (int16_t)helper_lduw_mmu(env, addr, oi, retaddr);
  58 }
  59
  60 tcg_target_ulong helper_ldsl_mmu(CPUArchState *env, uint64_t addr,
  61                                  MemOpIdx oi, uintptr_t retaddr)
  62 {
  63     return (int32_t)helper_ldul_mmu(env, addr, oi, retaddr);
  64 }
  65
  66 Int128 helper_ld16_mmu(CPUArchState *env, uint64_t addr,
  67                        MemOpIdx oi, uintptr_t retaddr)
  68 {
  69     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_128);
  70     return do_ld16_mmu(env_cpu(env), addr, oi, retaddr);
  71 }
  72
  73 Int128 helper_ld_i128(CPUArchState *env, uint64_t addr, uint32_t oi)
  74 {
  75     return helper_ld16_mmu(env, addr, oi, GETPC());
  76 }
  77
  78 /*
  79  * Store helpers for tcg-ldst.h
  80  */
  81
  82 void helper_stb_mmu(CPUArchState *env, uint64_t addr, uint32_t val,
  83                     MemOpIdx oi, uintptr_t ra)
  84 {
  85     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_8);
  86     do_st1_mmu(env_cpu(env), addr, val, oi, ra);
  87 }
  88
  89 void helper_stw_mmu(CPUArchState *env, uint64_t addr, uint32_t val,
  90                     MemOpIdx oi, uintptr_t retaddr)
  91 {
  92     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_16);
  93     do_st2_mmu(env_cpu(env), addr, val, oi, retaddr);
  94 }
  95
  96 void helper_stl_mmu(CPUArchState *env, uint64_t addr, uint32_t val,
  97                     MemOpIdx oi, uintptr_t retaddr)
  98 {
  99     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_32);
 100     do_st4_mmu(env_cpu(env), addr, val, oi, retaddr);
 101 }
 102
 103 void helper_stq_mmu(CPUArchState *env, uint64_t addr, uint64_t val,
 104                     MemOpIdx oi, uintptr_t retaddr)
 105 {
 106     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_64);
 107     do_st8_mmu(env_cpu(env), addr, val, oi, retaddr);
 108 }
 109
 110 void helper_st16_mmu(CPUArchState *env, uint64_t addr, Int128 val,
 111                      MemOpIdx oi, uintptr_t retaddr)
 112 {
 113     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_128);
 114     do_st16_mmu(env_cpu(env), addr, val, oi, retaddr);
 115 }
 116
 117 void helper_st_i128(CPUArchState *env, uint64_t addr, Int128 val, MemOpIdx oi)
 118 {
 119     helper_st16_mmu(env, addr, val, oi, GETPC());
 120 }
 121
 122 /*
 123  * Load helpers for cpu_ldst.h
 124  */
 125
 126 static void plugin_load_cb(CPUArchState *env, abi_ptr addr, MemOpIdx oi)
 127 {
 128     qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, oi, QEMU_PLUGIN_MEM_R);
 129 }
 130
 131 uint8_t cpu_ldb_mmu(CPUArchState *env, abi_ptr addr, MemOpIdx oi, uintptr_t ra)
 132 {
 133     uint8_t ret;
 134
 135     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_UB);
 136     ret = do_ld1_mmu(env_cpu(env), addr, oi, ra, MMU_DATA_LOAD);
 137     plugin_load_cb(env, addr, oi);
 138     return ret;
 139 }
 140
 141 uint16_t cpu_ldw_mmu(CPUArchState *env, abi_ptr addr,
 142                      MemOpIdx oi, uintptr_t ra)
 143 {
 144     uint16_t ret;
 145
 146     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_16);
 147     ret = do_ld2_mmu(env_cpu(env), addr, oi, ra, MMU_DATA_LOAD);
 148     plugin_load_cb(env, addr, oi);
 149     return ret;
 150 }
 151
 152 uint32_t cpu_ldl_mmu(CPUArchState *env, abi_ptr addr,
 153                      MemOpIdx oi, uintptr_t ra)
 154 {
 155     uint32_t ret;
 156
 157     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_32);
 158     ret = do_ld4_mmu(env_cpu(env), addr, oi, ra, MMU_DATA_LOAD);
 159     plugin_load_cb(env, addr, oi);
 160     return ret;
 161 }
 162
 163 uint64_t cpu_ldq_mmu(CPUArchState *env, abi_ptr addr,
 164                      MemOpIdx oi, uintptr_t ra)
 165 {
 166     uint64_t ret;
 167
 168     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_64);
 169     ret = do_ld8_mmu(env_cpu(env), addr, oi, ra, MMU_DATA_LOAD);
 170     plugin_load_cb(env, addr, oi);
 171     return ret;
 172 }
 173
 174 Int128 cpu_ld16_mmu(CPUArchState *env, abi_ptr addr,
 175                     MemOpIdx oi, uintptr_t ra)
 176 {
 177     Int128 ret;
 178
 179     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_128);
 180     ret = do_ld16_mmu(env_cpu(env), addr, oi, ra);
 181     plugin_load_cb(env, addr, oi);
 182     return ret;
 183 }
 184
 185 /*
 186  * Store helpers for cpu_ldst.h
 187  */
 188
 189 static void plugin_store_cb(CPUArchState *env, abi_ptr addr, MemOpIdx oi)
 190 {
 191     qemu_plugin_vcpu_mem_cb(env_cpu(env), addr, oi, QEMU_PLUGIN_MEM_W);
 192 }
 193
 194 void cpu_stb_mmu(CPUArchState *env, abi_ptr addr, uint8_t val,
 195                  MemOpIdx oi, uintptr_t retaddr)
 196 {
 197     helper_stb_mmu(env, addr, val, oi, retaddr);
 198     plugin_store_cb(env, addr, oi);
 199 }
 200
 201 void cpu_stw_mmu(CPUArchState *env, abi_ptr addr, uint16_t val,
 202                  MemOpIdx oi, uintptr_t retaddr)
 203 {
 204     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_16);
 205     do_st2_mmu(env_cpu(env), addr, val, oi, retaddr);
 206     plugin_store_cb(env, addr, oi);
 207 }
 208
 209 void cpu_stl_mmu(CPUArchState *env, abi_ptr addr, uint32_t val,
 210                     MemOpIdx oi, uintptr_t retaddr)
 211 {
 212     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_32);
 213     do_st4_mmu(env_cpu(env), addr, val, oi, retaddr);
 214     plugin_store_cb(env, addr, oi);
 215 }
 216
 217 void cpu_stq_mmu(CPUArchState *env, abi_ptr addr, uint64_t val,
 218                  MemOpIdx oi, uintptr_t retaddr)
 219 {
 220     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_64);
 221     do_st8_mmu(env_cpu(env), addr, val, oi, retaddr);
 222     plugin_store_cb(env, addr, oi);
 223 }
 224
 225 void cpu_st16_mmu(CPUArchState *env, abi_ptr addr, Int128 val,
 226                   MemOpIdx oi, uintptr_t retaddr)
 227 {
 228     tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_128);
 229     do_st16_mmu(env_cpu(env), addr, val, oi, retaddr);
 230     plugin_store_cb(env, addr, oi);
 231 }
 232
 233 /*
 234  * Wrappers of the above
 235  */
 236
 237 uint32_t cpu_ldub_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 238                             int mmu_idx, uintptr_t ra)
 239 {
 240     MemOpIdx oi = make_memop_idx(MO_UB, mmu_idx);
 241     return cpu_ldb_mmu(env, addr, oi, ra);
 242 }
 243
 244 int cpu_ldsb_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 245                        int mmu_idx, uintptr_t ra)
 246 {
 247     return (int8_t)cpu_ldub_mmuidx_ra(env, addr, mmu_idx, ra);
 248 }
 249
 250 uint32_t cpu_lduw_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 251                                int mmu_idx, uintptr_t ra)
 252 {
 253     MemOpIdx oi = make_memop_idx(MO_BEUW | MO_UNALN, mmu_idx);
 254     return cpu_ldw_mmu(env, addr, oi, ra);
 255 }
 256
 257 int cpu_ldsw_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 258                           int mmu_idx, uintptr_t ra)
 259 {
 260     return (int16_t)cpu_lduw_be_mmuidx_ra(env, addr, mmu_idx, ra);
 261 }
 262
 263 uint32_t cpu_ldl_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 264                               int mmu_idx, uintptr_t ra)
 265 {
 266     MemOpIdx oi = make_memop_idx(MO_BEUL | MO_UNALN, mmu_idx);
 267     return cpu_ldl_mmu(env, addr, oi, ra);
 268 }
 269
 270 uint64_t cpu_ldq_be_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 271                               int mmu_idx, uintptr_t ra)
 272 {
 273     MemOpIdx oi = make_memop_idx(MO_BEUQ | MO_UNALN, mmu_idx);
 274     return cpu_ldq_mmu(env, addr, oi, ra);
 275 }
 276
 277 uint32_t cpu_lduw_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 278                                int mmu_idx, uintptr_t ra)
 279 {
 280     MemOpIdx oi = make_memop_idx(MO_LEUW | MO_UNALN, mmu_idx);
 281     return cpu_ldw_mmu(env, addr, oi, ra);
 282 }
 283
 284 int cpu_ldsw_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 285                           int mmu_idx, uintptr_t ra)
 286 {
 287     return (int16_t)cpu_lduw_le_mmuidx_ra(env, addr, mmu_idx, ra);
 288 }
 289
 290 uint32_t cpu_ldl_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 291                               int mmu_idx, uintptr_t ra)
 292 {
 293     MemOpIdx oi = make_memop_idx(MO_LEUL | MO_UNALN, mmu_idx);
 294     return cpu_ldl_mmu(env, addr, oi, ra);
 295 }
 296
 297 uint64_t cpu_ldq_le_mmuidx_ra(CPUArchState *env, abi_ptr addr,
 298                               int mmu_idx, uintptr_t ra)
 299 {
 300     MemOpIdx oi = make_memop_idx(MO_LEUQ | MO_UNALN, mmu_idx);
 301     return cpu_ldq_mmu(env, addr, oi, ra);
 302 }
 303
 304 void cpu_stb_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint32_t val,
 305                        int mmu_idx, uintptr_t ra)
 306 {
 307     MemOpIdx oi = make_memop_idx(MO_UB, mmu_idx);
 308     cpu_stb_mmu(env, addr, val, oi, ra);
 309 }
 310
 311 void cpu_stw_be_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint32_t val,
 312                           int mmu_idx, uintptr_t ra)
 313 {
 314     MemOpIdx oi = make_memop_idx(MO_BEUW | MO_UNALN, mmu_idx);
 315     cpu_stw_mmu(env, addr, val, oi, ra);
 316 }
 317
 318 void cpu_stl_be_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint32_t val,
 319                           int mmu_idx, uintptr_t ra)
 320 {
 321     MemOpIdx oi = make_memop_idx(MO_BEUL | MO_UNALN, mmu_idx);
 322     cpu_stl_mmu(env, addr, val, oi, ra);
 323 }
 324
 325 void cpu_stq_be_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint64_t val,
 326                           int mmu_idx, uintptr_t ra)
 327 {
 328     MemOpIdx oi = make_memop_idx(MO_BEUQ | MO_UNALN, mmu_idx);
 329     cpu_stq_mmu(env, addr, val, oi, ra);
 330 }
 331
 332 void cpu_stw_le_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint32_t val,
 333                           int mmu_idx, uintptr_t ra)
 334 {
 335     MemOpIdx oi = make_memop_idx(MO_LEUW | MO_UNALN, mmu_idx);
 336     cpu_stw_mmu(env, addr, val, oi, ra);
 337 }
 338
 339 void cpu_stl_le_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint32_t val,
 340                           int mmu_idx, uintptr_t ra)
 341 {
 342     MemOpIdx oi = make_memop_idx(MO_LEUL | MO_UNALN, mmu_idx);
 343     cpu_stl_mmu(env, addr, val, oi, ra);
 344 }
 345
 346 void cpu_stq_le_mmuidx_ra(CPUArchState *env, abi_ptr addr, uint64_t val,
 347                           int mmu_idx, uintptr_t ra)
 348 {
 349     MemOpIdx oi = make_memop_idx(MO_LEUQ | MO_UNALN, mmu_idx);
 350     cpu_stq_mmu(env, addr, val, oi, ra);
 351 }
 352
 353 /*--------------------------*/
 354
 355 uint32_t cpu_ldub_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 356 {
 357     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 358     return cpu_ldub_mmuidx_ra(env, addr, mmu_index, ra);
 359 }
 360
 361 int cpu_ldsb_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 362 {
 363     return (int8_t)cpu_ldub_data_ra(env, addr, ra);
 364 }
 365
 366 uint32_t cpu_lduw_be_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 367 {
 368     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 369     return cpu_lduw_be_mmuidx_ra(env, addr, mmu_index, ra);
 370 }
 371
 372 int cpu_ldsw_be_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 373 {
 374     return (int16_t)cpu_lduw_be_data_ra(env, addr, ra);
 375 }
 376
 377 uint32_t cpu_ldl_be_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 378 {
 379     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 380     return cpu_ldl_be_mmuidx_ra(env, addr, mmu_index, ra);
 381 }
 382
 383 uint64_t cpu_ldq_be_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 384 {
 385     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 386     return cpu_ldq_be_mmuidx_ra(env, addr, mmu_index, ra);
 387 }
 388
 389 uint32_t cpu_lduw_le_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 390 {
 391     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 392     return cpu_lduw_le_mmuidx_ra(env, addr, mmu_index, ra);
 393 }
 394
 395 int cpu_ldsw_le_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 396 {
 397     return (int16_t)cpu_lduw_le_data_ra(env, addr, ra);
 398 }
 399
 400 uint32_t cpu_ldl_le_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 401 {
 402     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 403     return cpu_ldl_le_mmuidx_ra(env, addr, mmu_index, ra);
 404 }
 405
 406 uint64_t cpu_ldq_le_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 407 {
 408     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 409     return cpu_ldq_le_mmuidx_ra(env, addr, mmu_index, ra);
 410 }
 411
 412 void cpu_stb_data_ra(CPUArchState *env, abi_ptr addr,
 413                      uint32_t val, uintptr_t ra)
 414 {
 415     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 416     cpu_stb_mmuidx_ra(env, addr, val, mmu_index, ra);
 417 }
 418
 419 void cpu_stw_be_data_ra(CPUArchState *env, abi_ptr addr,
 420                         uint32_t val, uintptr_t ra)
 421 {
 422     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 423     cpu_stw_be_mmuidx_ra(env, addr, val, mmu_index, ra);
 424 }
 425
 426 void cpu_stl_be_data_ra(CPUArchState *env, abi_ptr addr,
 427                         uint32_t val, uintptr_t ra)
 428 {
 429     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 430     cpu_stl_be_mmuidx_ra(env, addr, val, mmu_index, ra);
 431 }
 432
 433 void cpu_stq_be_data_ra(CPUArchState *env, abi_ptr addr,
 434                         uint64_t val, uintptr_t ra)
 435 {
 436     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 437     cpu_stq_be_mmuidx_ra(env, addr, val, mmu_index, ra);
 438 }
 439
 440 void cpu_stw_le_data_ra(CPUArchState *env, abi_ptr addr,
 441                         uint32_t val, uintptr_t ra)
 442 {
 443     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 444     cpu_stw_le_mmuidx_ra(env, addr, val, mmu_index, ra);
 445 }
 446
 447 void cpu_stl_le_data_ra(CPUArchState *env, abi_ptr addr,
 448                         uint32_t val, uintptr_t ra)
 449 {
 450     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 451     cpu_stl_le_mmuidx_ra(env, addr, val, mmu_index, ra);
 452 }
 453
 454 void cpu_stq_le_data_ra(CPUArchState *env, abi_ptr addr,
 455                         uint64_t val, uintptr_t ra)
 456 {
 457     int mmu_index = cpu_mmu_index(env_cpu(env), false);
 458     cpu_stq_le_mmuidx_ra(env, addr, val, mmu_index, ra);
 459 }
 460
 461 /*--------------------------*/
 462
 463 uint32_t cpu_ldub_data(CPUArchState *env, abi_ptr addr)
 464 {
 465     return cpu_ldub_data_ra(env, addr, 0);
 466 }
 467
 468 int cpu_ldsb_data(CPUArchState *env, abi_ptr addr)
 469 {
 470     return (int8_t)cpu_ldub_data(env, addr);
 471 }
 472
 473 uint32_t cpu_lduw_be_data(CPUArchState *env, abi_ptr addr)
 474 {
 475     return cpu_lduw_be_data_ra(env, addr, 0);
 476 }
 477
 478 int cpu_ldsw_be_data(CPUArchState *env, abi_ptr addr)
 479 {
 480     return (int16_t)cpu_lduw_be_data(env, addr);
 481 }
 482
 483 uint32_t cpu_ldl_be_data(CPUArchState *env, abi_ptr addr)
 484 {
 485     return cpu_ldl_be_data_ra(env, addr, 0);
 486 }
 487
 488 uint64_t cpu_ldq_be_data(CPUArchState *env, abi_ptr addr)
 489 {
 490     return cpu_ldq_be_data_ra(env, addr, 0);
 491 }
 492
 493 uint32_t cpu_lduw_le_data(CPUArchState *env, abi_ptr addr)
 494 {
 495     return cpu_lduw_le_data_ra(env, addr, 0);
 496 }
 497
 498 int cpu_ldsw_le_data(CPUArchState *env, abi_ptr addr)
 499 {
 500     return (int16_t)cpu_lduw_le_data(env, addr);
 501 }
 502
 503 uint32_t cpu_ldl_le_data(CPUArchState *env, abi_ptr addr)
 504 {
 505     return cpu_ldl_le_data_ra(env, addr, 0);
 506 }
 507
 508 uint64_t cpu_ldq_le_data(CPUArchState *env, abi_ptr addr)
 509 {
 510     return cpu_ldq_le_data_ra(env, addr, 0);
 511 }
 512
 513 void cpu_stb_data(CPUArchState *env, abi_ptr addr, uint32_t val)
 514 {
 515     cpu_stb_data_ra(env, addr, val, 0);
 516 }
 517
 518 void cpu_stw_be_data(CPUArchState *env, abi_ptr addr, uint32_t val)
 519 {
 520     cpu_stw_be_data_ra(env, addr, val, 0);
 521 }
 522
 523 void cpu_stl_be_data(CPUArchState *env, abi_ptr addr, uint32_t val)
 524 {
 525     cpu_stl_be_data_ra(env, addr, val, 0);
 526 }
 527
 528 void cpu_stq_be_data(CPUArchState *env, abi_ptr addr, uint64_t val)
 529 {
 530     cpu_stq_be_data_ra(env, addr, val, 0);
 531 }
 532
 533 void cpu_stw_le_data(CPUArchState *env, abi_ptr addr, uint32_t val)
 534 {
 535     cpu_stw_le_data_ra(env, addr, val, 0);
 536 }
 537
 538 void cpu_stl_le_data(CPUArchState *env, abi_ptr addr, uint32_t val)
 539 {
 540     cpu_stl_le_data_ra(env, addr, val, 0);
 541 }
 542
 543 void cpu_stq_le_data(CPUArchState *env, abi_ptr addr, uint64_t val)
 544 {
 545     cpu_stq_le_data_ra(env, addr, val, 0);
 546 }