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     return cpu_ldub_mmuidx_ra(env, addr, cpu_mmu_index(env, false), ra);
 358 }
 359
 360 int cpu_ldsb_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 361 {
 362     return (int8_t)cpu_ldub_data_ra(env, addr, ra);
 363 }
 364
 365 uint32_t cpu_lduw_be_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 366 {
 367     return cpu_lduw_be_mmuidx_ra(env, addr, cpu_mmu_index(env, false), ra);
 368 }
 369
 370 int cpu_ldsw_be_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 371 {
 372     return (int16_t)cpu_lduw_be_data_ra(env, addr, ra);
 373 }
 374
 375 uint32_t cpu_ldl_be_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 376 {
 377     return cpu_ldl_be_mmuidx_ra(env, addr, cpu_mmu_index(env, false), ra);
 378 }
 379
 380 uint64_t cpu_ldq_be_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 381 {
 382     return cpu_ldq_be_mmuidx_ra(env, addr, cpu_mmu_index(env, false), ra);
 383 }
 384
 385 uint32_t cpu_lduw_le_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 386 {
 387     return cpu_lduw_le_mmuidx_ra(env, addr, cpu_mmu_index(env, false), ra);
 388 }
 389
 390 int cpu_ldsw_le_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 391 {
 392     return (int16_t)cpu_lduw_le_data_ra(env, addr, ra);
 393 }
 394
 395 uint32_t cpu_ldl_le_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 396 {
 397     return cpu_ldl_le_mmuidx_ra(env, addr, cpu_mmu_index(env, false), ra);
 398 }
 399
 400 uint64_t cpu_ldq_le_data_ra(CPUArchState *env, abi_ptr addr, uintptr_t ra)
 401 {
 402     return cpu_ldq_le_mmuidx_ra(env, addr, cpu_mmu_index(env, false), ra);
 403 }
 404
 405 void cpu_stb_data_ra(CPUArchState *env, abi_ptr addr,
 406                      uint32_t val, uintptr_t ra)
 407 {
 408     cpu_stb_mmuidx_ra(env, addr, val, cpu_mmu_index(env, false), ra);
 409 }
 410
 411 void cpu_stw_be_data_ra(CPUArchState *env, abi_ptr addr,
 412                         uint32_t val, uintptr_t ra)
 413 {
 414     cpu_stw_be_mmuidx_ra(env, addr, val, cpu_mmu_index(env, false), ra);
 415 }
 416
 417 void cpu_stl_be_data_ra(CPUArchState *env, abi_ptr addr,
 418                         uint32_t val, uintptr_t ra)
 419 {
 420     cpu_stl_be_mmuidx_ra(env, addr, val, cpu_mmu_index(env, false), ra);
 421 }
 422
 423 void cpu_stq_be_data_ra(CPUArchState *env, abi_ptr addr,
 424                         uint64_t val, uintptr_t ra)
 425 {
 426     cpu_stq_be_mmuidx_ra(env, addr, val, cpu_mmu_index(env, false), ra);
 427 }
 428
 429 void cpu_stw_le_data_ra(CPUArchState *env, abi_ptr addr,
 430                         uint32_t val, uintptr_t ra)
 431 {
 432     cpu_stw_le_mmuidx_ra(env, addr, val, cpu_mmu_index(env, false), ra);
 433 }
 434
 435 void cpu_stl_le_data_ra(CPUArchState *env, abi_ptr addr,
 436                         uint32_t val, uintptr_t ra)
 437 {
 438     cpu_stl_le_mmuidx_ra(env, addr, val, cpu_mmu_index(env, false), ra);
 439 }
 440
 441 void cpu_stq_le_data_ra(CPUArchState *env, abi_ptr addr,
 442                         uint64_t val, uintptr_t ra)
 443 {
 444     cpu_stq_le_mmuidx_ra(env, addr, val, cpu_mmu_index(env, false), ra);
 445 }
 446
 447 /*--------------------------*/
 448
 449 uint32_t cpu_ldub_data(CPUArchState *env, abi_ptr addr)
 450 {
 451     return cpu_ldub_data_ra(env, addr, 0);
 452 }
 453
 454 int cpu_ldsb_data(CPUArchState *env, abi_ptr addr)
 455 {
 456     return (int8_t)cpu_ldub_data(env, addr);
 457 }
 458
 459 uint32_t cpu_lduw_be_data(CPUArchState *env, abi_ptr addr)
 460 {
 461     return cpu_lduw_be_data_ra(env, addr, 0);
 462 }
 463
 464 int cpu_ldsw_be_data(CPUArchState *env, abi_ptr addr)
 465 {
 466     return (int16_t)cpu_lduw_be_data(env, addr);
 467 }
 468
 469 uint32_t cpu_ldl_be_data(CPUArchState *env, abi_ptr addr)
 470 {
 471     return cpu_ldl_be_data_ra(env, addr, 0);
 472 }
 473
 474 uint64_t cpu_ldq_be_data(CPUArchState *env, abi_ptr addr)
 475 {
 476     return cpu_ldq_be_data_ra(env, addr, 0);
 477 }
 478
 479 uint32_t cpu_lduw_le_data(CPUArchState *env, abi_ptr addr)
 480 {
 481     return cpu_lduw_le_data_ra(env, addr, 0);
 482 }
 483
 484 int cpu_ldsw_le_data(CPUArchState *env, abi_ptr addr)
 485 {
 486     return (int16_t)cpu_lduw_le_data(env, addr);
 487 }
 488
 489 uint32_t cpu_ldl_le_data(CPUArchState *env, abi_ptr addr)
 490 {
 491     return cpu_ldl_le_data_ra(env, addr, 0);
 492 }
 493
 494 uint64_t cpu_ldq_le_data(CPUArchState *env, abi_ptr addr)
 495 {
 496     return cpu_ldq_le_data_ra(env, addr, 0);
 497 }
 498
 499 void cpu_stb_data(CPUArchState *env, abi_ptr addr, uint32_t val)
 500 {
 501     cpu_stb_data_ra(env, addr, val, 0);
 502 }
 503
 504 void cpu_stw_be_data(CPUArchState *env, abi_ptr addr, uint32_t val)
 505 {
 506     cpu_stw_be_data_ra(env, addr, val, 0);
 507 }
 508
 509 void cpu_stl_be_data(CPUArchState *env, abi_ptr addr, uint32_t val)
 510 {
 511     cpu_stl_be_data_ra(env, addr, val, 0);
 512 }
 513
 514 void cpu_stq_be_data(CPUArchState *env, abi_ptr addr, uint64_t val)
 515 {
 516     cpu_stq_be_data_ra(env, addr, val, 0);
 517 }
 518
 519 void cpu_stw_le_data(CPUArchState *env, abi_ptr addr, uint32_t val)
 520 {
 521     cpu_stw_le_data_ra(env, addr, val, 0);
 522 }
 523
 524 void cpu_stl_le_data(CPUArchState *env, abi_ptr addr, uint32_t val)
 525 {
 526     cpu_stl_le_data_ra(env, addr, val, 0);
 527 }
 528
 529 void cpu_stq_le_data(CPUArchState *env, abi_ptr addr, uint64_t val)
 530 {
 531     cpu_stq_le_data_ra(env, addr, val, 0);
 532 }