blob: 337a362205af97f5d48728faffd64046b9099d38 [file] [log] [blame]
Gautham R. Shenoy3e008842016-10-30 08:44:56 +05301/*
zhaolichang136fbf62020-10-09 14:44:37 +08002 * PowerPC internal definitions for qemu.
Gautham R. Shenoy3e008842016-10-30 08:44:56 +05303 *
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
Chetan Pant6bd039c2020-10-19 06:11:26 +00007 * version 2.1 of the License, or (at your option) any later version.
Gautham R. Shenoy3e008842016-10-30 08:44:56 +05308 *
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#ifndef PPC_INTERNAL_H
19#define PPC_INTERNAL_H
20
Lucas Mateus Castro (alqotel)34553152022-05-24 11:05:31 -030021#include "hw/registerfields.h"
22
Gautham R. Shenoy3e008842016-10-30 08:44:56 +053023#define FUNC_MASK(name, ret_type, size, max_val) \
24static inline ret_type name(uint##size##_t start, \
25 uint##size##_t end) \
26{ \
27 ret_type ret, max_bit = size - 1; \
28 \
29 if (likely(start == 0)) { \
30 ret = max_val << (max_bit - end); \
31 } else if (likely(end == max_bit)) { \
32 ret = max_val >> start; \
33 } else { \
34 ret = (((uint##size##_t)(-1ULL)) >> (start)) ^ \
35 (((uint##size##_t)(-1ULL) >> (end)) >> 1); \
36 if (unlikely(start > end)) { \
37 return ~ret; \
38 } \
39 } \
40 \
41 return ret; \
42}
43
44#if defined(TARGET_PPC64)
45FUNC_MASK(MASK, target_ulong, 64, UINT64_MAX);
46#else
47FUNC_MASK(MASK, target_ulong, 32, UINT32_MAX);
48#endif
49FUNC_MASK(mask_u32, uint32_t, 32, UINT32_MAX);
50FUNC_MASK(mask_u64, uint64_t, 64, UINT64_MAX);
51
Bharata B Rao985e3022016-11-23 17:07:10 +053052/*****************************************************************************/
53/*** Instruction decoding ***/
54#define EXTRACT_HELPER(name, shift, nb) \
55static inline uint32_t name(uint32_t opcode) \
56{ \
Mark Cave-Ayland4c23c2a2019-01-02 09:14:16 +000057 return extract32(opcode, shift, nb); \
Bharata B Rao985e3022016-11-23 17:07:10 +053058}
59
60#define EXTRACT_SHELPER(name, shift, nb) \
61static inline int32_t name(uint32_t opcode) \
62{ \
Mark Cave-Ayland4c23c2a2019-01-02 09:14:16 +000063 return sextract32(opcode, shift, nb); \
Bharata B Rao985e3022016-11-23 17:07:10 +053064}
65
66#define EXTRACT_HELPER_SPLIT(name, shift1, nb1, shift2, nb2) \
67static inline uint32_t name(uint32_t opcode) \
68{ \
Mark Cave-Ayland4c23c2a2019-01-02 09:14:16 +000069 return extract32(opcode, shift1, nb1) << nb2 | \
70 extract32(opcode, shift2, nb2); \
Bharata B Rao985e3022016-11-23 17:07:10 +053071}
72
Nikunj A Dadhania403a8842017-01-13 14:53:39 +053073#define EXTRACT_HELPER_SPLIT_3(name, \
Bharata B Rao985e3022016-11-23 17:07:10 +053074 d0_bits, shift_op_d0, shift_d0, \
75 d1_bits, shift_op_d1, shift_d1, \
76 d2_bits, shift_op_d2, shift_d2) \
77static inline int16_t name(uint32_t opcode) \
78{ \
79 return \
80 (((opcode >> (shift_op_d0)) & ((1 << (d0_bits)) - 1)) << (shift_d0)) | \
81 (((opcode >> (shift_op_d1)) & ((1 << (d1_bits)) - 1)) << (shift_d1)) | \
82 (((opcode >> (shift_op_d2)) & ((1 << (d2_bits)) - 1)) << (shift_d2)); \
83}
84
85
86/* Opcode part 1 */
87EXTRACT_HELPER(opc1, 26, 6);
88/* Opcode part 2 */
89EXTRACT_HELPER(opc2, 1, 5);
90/* Opcode part 3 */
91EXTRACT_HELPER(opc3, 6, 5);
92/* Opcode part 4 */
93EXTRACT_HELPER(opc4, 16, 5);
94/* Update Cr0 flags */
95EXTRACT_HELPER(Rc, 0, 1);
96/* Update Cr6 flags (Altivec) */
97EXTRACT_HELPER(Rc21, 10, 1);
98/* Destination */
99EXTRACT_HELPER(rD, 21, 5);
100/* Source */
101EXTRACT_HELPER(rS, 21, 5);
102/* First operand */
103EXTRACT_HELPER(rA, 16, 5);
104/* Second operand */
105EXTRACT_HELPER(rB, 11, 5);
106/* Third operand */
107EXTRACT_HELPER(rC, 6, 5);
108/*** Get CRn ***/
109EXTRACT_HELPER(crfD, 23, 3);
110EXTRACT_HELPER(BF, 23, 3);
111EXTRACT_HELPER(crfS, 18, 3);
112EXTRACT_HELPER(crbD, 21, 5);
113EXTRACT_HELPER(crbA, 16, 5);
114EXTRACT_HELPER(crbB, 11, 5);
115/* SPR / TBL */
116EXTRACT_HELPER(_SPR, 11, 10);
117static inline uint32_t SPR(uint32_t opcode)
118{
119 uint32_t sprn = _SPR(opcode);
120
121 return ((sprn >> 5) & 0x1F) | ((sprn & 0x1F) << 5);
122}
123/*** Get constants ***/
124/* 16 bits signed immediate value */
125EXTRACT_SHELPER(SIMM, 0, 16);
126/* 16 bits unsigned immediate value */
127EXTRACT_HELPER(UIMM, 0, 16);
128/* 5 bits signed immediate value */
Mark Cave-Aylandffcd21a2019-01-02 09:14:15 +0000129EXTRACT_SHELPER(SIMM5, 16, 5);
Bharata B Rao985e3022016-11-23 17:07:10 +0530130/* 5 bits signed immediate value */
131EXTRACT_HELPER(UIMM5, 16, 5);
132/* 4 bits unsigned immediate value */
133EXTRACT_HELPER(UIMM4, 16, 4);
134/* Bit count */
135EXTRACT_HELPER(NB, 11, 5);
136/* Shift count */
137EXTRACT_HELPER(SH, 11, 5);
Balamuruhan Sa68a6142017-02-09 11:03:30 +0530138/* lwat/stwat/ldat/lwat */
139EXTRACT_HELPER(FC, 11, 5);
Bharata B Rao985e3022016-11-23 17:07:10 +0530140/* Vector shift count */
141EXTRACT_HELPER(VSH, 6, 4);
142/* Mask start */
143EXTRACT_HELPER(MB, 6, 5);
144/* Mask end */
145EXTRACT_HELPER(ME, 1, 5);
146/* Trap operand */
147EXTRACT_HELPER(TO, 21, 5);
148
149EXTRACT_HELPER(CRM, 12, 8);
150
151#ifndef CONFIG_USER_ONLY
152EXTRACT_HELPER(SR, 16, 4);
153#endif
154
155/* mtfsf/mtfsfi */
156EXTRACT_HELPER(FPBF, 23, 3);
157EXTRACT_HELPER(FPIMM, 12, 4);
158EXTRACT_HELPER(FPL, 25, 1);
159EXTRACT_HELPER(FPFLM, 17, 8);
160EXTRACT_HELPER(FPW, 16, 1);
161
162/* addpcis */
Nikunj A Dadhania403a8842017-01-13 14:53:39 +0530163EXTRACT_HELPER_SPLIT_3(DX, 10, 6, 6, 5, 16, 1, 1, 0, 0)
Bharata B Rao985e3022016-11-23 17:07:10 +0530164#if defined(TARGET_PPC64)
165/* darn */
166EXTRACT_HELPER(L, 16, 2);
167#endif
Nicholas Piggin0c9717f2022-07-20 23:33:52 +1000168/* wait */
169EXTRACT_HELPER(WC, 21, 2);
170EXTRACT_HELPER(PL, 16, 2);
Bharata B Rao985e3022016-11-23 17:07:10 +0530171
172/*** Jump target decoding ***/
173/* Immediate address */
174static inline target_ulong LI(uint32_t opcode)
175{
176 return (opcode >> 0) & 0x03FFFFFC;
177}
178
179static inline uint32_t BD(uint32_t opcode)
180{
181 return (opcode >> 0) & 0xFFFC;
182}
183
184EXTRACT_HELPER(BO, 21, 5);
185EXTRACT_HELPER(BI, 16, 5);
186/* Absolute/relative address */
187EXTRACT_HELPER(AA, 1, 1);
188/* Link */
189EXTRACT_HELPER(LK, 0, 1);
190
191/* DFP Z22-form */
192EXTRACT_HELPER(DCM, 10, 6)
193
194/* DFP Z23-form */
195EXTRACT_HELPER(RMC, 9, 2)
Jose Ricardo Zivianibe07ad52017-02-03 20:01:14 -0200196EXTRACT_HELPER(Rrm, 16, 1)
Bharata B Rao985e3022016-11-23 17:07:10 +0530197
Nikunj A Dadhaniad59ba582016-11-23 17:07:17 +0530198EXTRACT_HELPER_SPLIT(DQxT, 3, 1, 21, 5);
Bharata B Rao985e3022016-11-23 17:07:10 +0530199EXTRACT_HELPER_SPLIT(xT, 0, 1, 21, 5);
200EXTRACT_HELPER_SPLIT(xS, 0, 1, 21, 5);
201EXTRACT_HELPER_SPLIT(xA, 2, 1, 16, 5);
202EXTRACT_HELPER_SPLIT(xB, 1, 1, 11, 5);
203EXTRACT_HELPER_SPLIT(xC, 3, 1, 6, 5);
204EXTRACT_HELPER(DM, 8, 2);
205EXTRACT_HELPER(UIM, 16, 2);
206EXTRACT_HELPER(SHW, 8, 2);
207EXTRACT_HELPER(SP, 19, 2);
208EXTRACT_HELPER(IMM8, 11, 8);
Nikunj A Dadhania78241762017-01-13 14:53:40 +0530209EXTRACT_HELPER(DCMX, 16, 7);
Nikunj A Dadhania403a8842017-01-13 14:53:39 +0530210EXTRACT_HELPER_SPLIT_3(DCMX_XV, 5, 16, 0, 1, 2, 5, 1, 6, 6);
Bharata B Rao985e3022016-11-23 17:07:10 +0530211
Bharata B Raof566c042017-01-06 11:44:49 +0530212void helper_compute_fprf_float16(CPUPPCState *env, float16 arg);
Bharata B Rao9aeae8e2017-01-06 11:44:50 +0530213void helper_compute_fprf_float32(CPUPPCState *env, float32 arg);
Bharata B Rao07bdd242017-01-09 19:56:13 +0530214void helper_compute_fprf_float128(CPUPPCState *env, float128 arg);
Richard Henderson0f3110f2018-06-26 09:19:09 -0700215
Bruno Larsen (billionai)7468e2c2021-04-29 13:21:24 -0300216/* translate.c */
217
Bruno Larsen (billionai)7468e2c2021-04-29 13:21:24 -0300218int ppc_fixup_cpu(PowerPCCPU *cpu);
219void create_ppc_opcodes(PowerPCCPU *cpu, Error **errp);
220void destroy_ppc_opcodes(PowerPCCPU *cpu);
221
Bruno Larsen (billionai)35a5d742021-04-26 15:47:06 -0300222/* gdbstub.c */
223void ppc_gdb_init(CPUState *cs, PowerPCCPUClass *ppc);
224gchar *ppc_gdb_arch_name(CPUState *cs);
225
Richard Henderson182357d2021-05-18 15:11:23 -0500226/**
227 * prot_for_access_type:
228 * @access_type: Access type
229 *
230 * Return the protection bit required for the given access type.
231 */
232static inline int prot_for_access_type(MMUAccessType access_type)
233{
234 switch (access_type) {
235 case MMU_INST_FETCH:
236 return PAGE_EXEC;
237 case MMU_DATA_LOAD:
238 return PAGE_READ;
239 case MMU_DATA_STORE:
240 return PAGE_WRITE;
241 }
242 g_assert_not_reached();
243}
244
Lucas Mateus Castro (alqotel)5118ebe2021-07-23 14:56:25 -0300245/* PowerPC MMU emulation */
246
247typedef struct mmu_ctx_t mmu_ctx_t;
248bool ppc_xlate(PowerPCCPU *cpu, vaddr eaddr, MMUAccessType access_type,
249 hwaddr *raddrp, int *psizep, int *protp,
250 int mmu_idx, bool guest_visible);
251int get_physical_address_wtlb(CPUPPCState *env, mmu_ctx_t *ctx,
252 target_ulong eaddr,
253 MMUAccessType access_type, int type,
254 int mmu_idx);
255/* Software driven TLB helpers */
256int ppc6xx_tlb_getnum(CPUPPCState *env, target_ulong eaddr,
257 int way, int is_code);
258/* Context used internally during MMU translations */
259struct mmu_ctx_t {
260 hwaddr raddr; /* Real address */
261 hwaddr eaddr; /* Effective address */
262 int prot; /* Protection bits */
263 hwaddr hash[2]; /* Pagetable hash values */
264 target_ulong ptem; /* Virtual segment ID | API */
265 int key; /* Access key */
266 int nx; /* Non-execute area */
267};
268
269/* Common routines used by software and hardware TLBs emulation */
270static inline int pte_is_valid(target_ulong pte0)
271{
272 return pte0 & 0x80000000 ? 1 : 0;
273}
274
275static inline void pte_invalidate(target_ulong *pte0)
276{
277 *pte0 &= ~0x80000000;
278}
279
280#define PTE_PTEM_MASK 0x7FFFFFBF
281#define PTE_CHECK_MASK (TARGET_PAGE_MASK | 0x7B)
282
Richard Henderson1db8af52021-09-18 06:37:19 -0700283#ifdef CONFIG_USER_ONLY
284void ppc_cpu_record_sigsegv(CPUState *cs, vaddr addr,
285 MMUAccessType access_type,
286 bool maperr, uintptr_t ra);
287#else
288bool ppc_cpu_tlb_fill(CPUState *cs, vaddr address, int size,
289 MMUAccessType access_type, int mmu_idx,
290 bool probe, uintptr_t retaddr);
Marc-André Lureau89057702022-04-20 17:26:02 +0400291G_NORETURN void ppc_cpu_do_unaligned_access(CPUState *cs, vaddr addr,
292 MMUAccessType access_type, int mmu_idx,
293 uintptr_t retaddr);
Richard Henderson1db8af52021-09-18 06:37:19 -0700294#endif
Lucas Mateus Castro (alqotel)5118ebe2021-07-23 14:56:25 -0300295
Lucas Mateus Castro (alqotel)34553152022-05-24 11:05:31 -0300296FIELD(GER_MSK, XMSK, 0, 4)
297FIELD(GER_MSK, YMSK, 4, 4)
298FIELD(GER_MSK, PMSK, 8, 8)
299
300static inline int ger_pack_masks(int pmsk, int ymsk, int xmsk)
301{
302 int msk = 0;
303 msk = FIELD_DP32(msk, GER_MSK, XMSK, xmsk);
304 msk = FIELD_DP32(msk, GER_MSK, YMSK, ymsk);
305 msk = FIELD_DP32(msk, GER_MSK, PMSK, pmsk);
306 return msk;
307}
308
Gautham R. Shenoy3e008842016-10-30 08:44:56 +0530309#endif /* PPC_INTERNAL_H */