xref: /openbmc/qemu/accel/tcg/ldst_common.c.inc (revision 7cef6d686309e2792186504ae17cf4f3eb57ef68) 
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
15tcg_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
22tcg_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
29tcg_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
36uint64_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
48tcg_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
54tcg_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
60tcg_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
66Int128 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
73Int128 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
82void 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
89void 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
96void 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
103void 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
110void 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
117void 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
126static void plugin_load_cb(CPUArchState *env, vaddr addr,
127                           uint64_t value_low,
128                           uint64_t value_high,
129                           MemOpIdx oi)
130{
131    if (cpu_plugin_mem_cbs_enabled(env_cpu(env))) {
132        qemu_plugin_vcpu_mem_cb(env_cpu(env), addr,
133                                value_low, value_high,
134                                oi, QEMU_PLUGIN_MEM_R);
135    }
136}
137
138uint8_t cpu_ldb_mmu(CPUArchState *env, vaddr addr, MemOpIdx oi, uintptr_t ra)
139{
140    uint8_t ret;
141
142    tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_UB);
143    ret = do_ld1_mmu(env_cpu(env), addr, oi, ra, MMU_DATA_LOAD);
144    plugin_load_cb(env, addr, ret, 0, oi);
145    return ret;
146}
147
148uint16_t cpu_ldw_mmu(CPUArchState *env, vaddr addr,
149                     MemOpIdx oi, uintptr_t ra)
150{
151    uint16_t ret;
152
153    tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_16);
154    ret = do_ld2_mmu(env_cpu(env), addr, oi, ra, MMU_DATA_LOAD);
155    plugin_load_cb(env, addr, ret, 0, oi);
156    return ret;
157}
158
159uint32_t cpu_ldl_mmu(CPUArchState *env, vaddr addr,
160                     MemOpIdx oi, uintptr_t ra)
161{
162    uint32_t ret;
163
164    tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_32);
165    ret = do_ld4_mmu(env_cpu(env), addr, oi, ra, MMU_DATA_LOAD);
166    plugin_load_cb(env, addr, ret, 0, oi);
167    return ret;
168}
169
170uint64_t cpu_ldq_mmu(CPUArchState *env, vaddr addr,
171                     MemOpIdx oi, uintptr_t ra)
172{
173    uint64_t ret;
174
175    tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_64);
176    ret = do_ld8_mmu(env_cpu(env), addr, oi, ra, MMU_DATA_LOAD);
177    plugin_load_cb(env, addr, ret, 0, oi);
178    return ret;
179}
180
181Int128 cpu_ld16_mmu(CPUArchState *env, vaddr addr,
182                    MemOpIdx oi, uintptr_t ra)
183{
184    Int128 ret;
185
186    tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_128);
187    ret = do_ld16_mmu(env_cpu(env), addr, oi, ra);
188    plugin_load_cb(env, addr, int128_getlo(ret), int128_gethi(ret), oi);
189    return ret;
190}
191
192/*
193 * Store helpers for cpu_ldst.h
194 */
195
196static void plugin_store_cb(CPUArchState *env, vaddr addr,
197                            uint64_t value_low,
198                            uint64_t value_high,
199                            MemOpIdx oi)
200{
201    if (cpu_plugin_mem_cbs_enabled(env_cpu(env))) {
202        qemu_plugin_vcpu_mem_cb(env_cpu(env), addr,
203                                value_low, value_high,
204                                oi, QEMU_PLUGIN_MEM_W);
205    }
206}
207
208void cpu_stb_mmu(CPUArchState *env, vaddr addr, uint8_t val,
209                 MemOpIdx oi, uintptr_t retaddr)
210{
211    helper_stb_mmu(env, addr, val, oi, retaddr);
212    plugin_store_cb(env, addr, val, 0, oi);
213}
214
215void cpu_stw_mmu(CPUArchState *env, vaddr addr, uint16_t val,
216                 MemOpIdx oi, uintptr_t retaddr)
217{
218    tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_16);
219    do_st2_mmu(env_cpu(env), addr, val, oi, retaddr);
220    plugin_store_cb(env, addr, val, 0, oi);
221}
222
223void cpu_stl_mmu(CPUArchState *env, vaddr addr, uint32_t val,
224                    MemOpIdx oi, uintptr_t retaddr)
225{
226    tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_32);
227    do_st4_mmu(env_cpu(env), addr, val, oi, retaddr);
228    plugin_store_cb(env, addr, val, 0, oi);
229}
230
231void cpu_stq_mmu(CPUArchState *env, vaddr addr, uint64_t val,
232                 MemOpIdx oi, uintptr_t retaddr)
233{
234    tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_64);
235    do_st8_mmu(env_cpu(env), addr, val, oi, retaddr);
236    plugin_store_cb(env, addr, val, 0, oi);
237}
238
239void cpu_st16_mmu(CPUArchState *env, vaddr addr, Int128 val,
240                  MemOpIdx oi, uintptr_t retaddr)
241{
242    tcg_debug_assert((get_memop(oi) & MO_SIZE) == MO_128);
243    do_st16_mmu(env_cpu(env), addr, val, oi, retaddr);
244    plugin_store_cb(env, addr, int128_getlo(val), int128_gethi(val), oi);
245}
246