← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to target-ppc/translate_init.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-22 10:13:17 UTC
  • mfrom: (1.2.1 upstream) (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090322101317-iigjtnu5qil35dtb
Tags: 0.10.1-1
http://bugs.debian.org/501400
[ Aurelien Jarno ]
* New upstream stable release:
  - patches/80_stable-branch.patch: remove.
* debian/control: 
  - Remove depends on proll.
  - Move depends on device-tree-compiler to build-depends.
  - Bump Standards-Version to 3.8.1 (no changes).
* patches/82_qemu-img_decimal.patch: new patch from upstream to make
  qemu-img accept sizes with decimal values (closes: bug#501400).

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-ppc/translate_init.c
15
15
 *
16
16
 * You should have received a copy of the GNU Lesser General Public
17
17
 * License along with this library; if not, write to the Free Software
18
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA  02110-1301 USA
19
19
 */
20
20
 
21
21
/* A lot of PowerPC definition have been included here.
24
24
 */
25
25
 
26
26
#include "dis-asm.h"
27
 
#include "host-utils.h"
 
27
#include "gdbstub.h"
28
28
 
29
29
//#define PPC_DUMP_CPU
30
30
//#define PPC_DEBUG_SPR
34
34
#endif
35
35
 
36
36
struct ppc_def_t {
37
 
    const unsigned char *name;
 
37
    const char *name;
38
38
    uint32_t pvr;
39
39
    uint32_t svr;
40
40
    uint64_t insns_flags;
62
62
PPC_IRQ_INIT_FN(40x);
63
63
PPC_IRQ_INIT_FN(6xx);
64
64
PPC_IRQ_INIT_FN(970);
 
65
PPC_IRQ_INIT_FN(e500);
65
66
 
66
67
/* Generic callbacks:
67
68
 * do nothing but store/retrieve spr value
68
69
 */
69
 
#ifdef PPC_DUMP_SPR_ACCESSES
70
 
static void spr_read_generic (void *opaque, int sprn)
71
 
{
72
 
    gen_op_load_dump_spr(sprn);
73
 
}
74
 
 
75
 
static void spr_write_generic (void *opaque, int sprn)
76
 
{
77
 
    gen_op_store_dump_spr(sprn);
78
 
}
79
 
#else
80
 
static void spr_read_generic (void *opaque, int sprn)
81
 
{
82
 
    gen_op_load_spr(sprn);
83
 
}
84
 
 
85
 
static void spr_write_generic (void *opaque, int sprn)
86
 
{
87
 
    gen_op_store_spr(sprn);
88
 
}
89
 
#endif
 
70
static void spr_read_generic (void *opaque, int gprn, int sprn)
 
71
{
 
72
    gen_load_spr(cpu_gpr[gprn], sprn);
 
73
#ifdef PPC_DUMP_SPR_ACCESSES
 
74
    {
 
75
        TCGv t0 = tcg_const_i32(sprn);
 
76
        gen_helper_load_dump_spr(t0);
 
77
        tcg_temp_free_i32(t0);
 
78
    }
 
79
#endif
 
80
}
 
81
 
 
82
static void spr_write_generic (void *opaque, int sprn, int gprn)
 
83
{
 
84
    gen_store_spr(sprn, cpu_gpr[gprn]);
 
85
#ifdef PPC_DUMP_SPR_ACCESSES
 
86
    {
 
87
        TCGv t0 = tcg_const_i32(sprn);
 
88
        gen_helper_store_dump_spr(t0);
 
89
        tcg_temp_free_i32(t0);
 
90
    }
 
91
#endif
 
92
}
90
93
 
91
94
#if !defined(CONFIG_USER_ONLY)
92
 
static void spr_write_clear (void *opaque, int sprn)
 
95
static void spr_write_clear (void *opaque, int sprn, int gprn)
93
96
{
94
 
    gen_op_mask_spr(sprn);
 
97
    TCGv t0 = tcg_temp_new();
 
98
    TCGv t1 = tcg_temp_new();
 
99
    gen_load_spr(t0, sprn);
 
100
    tcg_gen_neg_tl(t1, cpu_gpr[gprn]);
 
101
    tcg_gen_and_tl(t0, t0, t1);
 
102
    gen_store_spr(sprn, t0);
 
103
    tcg_temp_free(t0);
 
104
    tcg_temp_free(t1);
95
105
}
96
106
#endif
97
107
 
98
108
/* SPR common to all PowerPC */
99
109
/* XER */
100
 
static void spr_read_xer (void *opaque, int sprn)
 
110
static void spr_read_xer (void *opaque, int gprn, int sprn)
101
111
{
102
 
    gen_op_load_xer();
 
112
    tcg_gen_mov_tl(cpu_gpr[gprn], cpu_xer);
103
113
}
104
114
 
105
 
static void spr_write_xer (void *opaque, int sprn)
 
115
static void spr_write_xer (void *opaque, int sprn, int gprn)
106
116
{
107
 
    gen_op_store_xer();
 
117
    tcg_gen_mov_tl(cpu_xer, cpu_gpr[gprn]);
108
118
}
109
119
 
110
120
/* LR */
111
 
static void spr_read_lr (void *opaque, int sprn)
 
121
static void spr_read_lr (void *opaque, int gprn, int sprn)
112
122
{
113
 
    gen_op_load_lr();
 
123
    tcg_gen_mov_tl(cpu_gpr[gprn], cpu_lr);
114
124
}
115
125
 
116
 
static void spr_write_lr (void *opaque, int sprn)
 
126
static void spr_write_lr (void *opaque, int sprn, int gprn)
117
127
{
118
 
    gen_op_store_lr();
 
128
    tcg_gen_mov_tl(cpu_lr, cpu_gpr[gprn]);
119
129
}
120
130
 
121
131
/* CTR */
122
 
static void spr_read_ctr (void *opaque, int sprn)
 
132
static void spr_read_ctr (void *opaque, int gprn, int sprn)
123
133
{
124
 
    gen_op_load_ctr();
 
134
    tcg_gen_mov_tl(cpu_gpr[gprn], cpu_ctr);
125
135
}
126
136
 
127
 
static void spr_write_ctr (void *opaque, int sprn)
 
137
static void spr_write_ctr (void *opaque, int sprn, int gprn)
128
138
{
129
 
    gen_op_store_ctr();
 
139
    tcg_gen_mov_tl(cpu_ctr, cpu_gpr[gprn]);
130
140
}
131
141
 
132
142
/* User read access to SPR */
135
145
/* UPMCx */
136
146
/* USIA */
137
147
/* UDECR */
138
 
static void spr_read_ureg (void *opaque, int sprn)
 
148
static void spr_read_ureg (void *opaque, int gprn, int sprn)
139
149
{
140
 
    gen_op_load_spr(sprn + 0x10);
 
150
    gen_load_spr(cpu_gpr[gprn], sprn + 0x10);
141
151
}
142
152
 
143
153
/* SPR common to all non-embedded PowerPC */
144
154
/* DECR */
145
155
#if !defined(CONFIG_USER_ONLY)
146
 
static void spr_read_decr (void *opaque, int sprn)
 
156
static void spr_read_decr (void *opaque, int gprn, int sprn)
147
157
{
148
 
    gen_op_load_decr();
 
158
    gen_helper_load_decr(cpu_gpr[gprn]);
149
159
}
150
160
 
151
 
static void spr_write_decr (void *opaque, int sprn)
 
161
static void spr_write_decr (void *opaque, int sprn, int gprn)
152
162
{
153
 
    gen_op_store_decr();
 
163
    gen_helper_store_decr(cpu_gpr[gprn]);
154
164
}
155
165
#endif
156
166
 
157
167
/* SPR common to all non-embedded PowerPC, except 601 */
158
168
/* Time base */
159
 
static void spr_read_tbl (void *opaque, int sprn)
160
 
{
161
 
    gen_op_load_tbl();
162
 
}
163
 
 
164
 
static void spr_read_tbu (void *opaque, int sprn)
165
 
{
166
 
    gen_op_load_tbu();
167
 
}
168
 
 
169
 
__attribute__ (( unused ))
170
 
static void spr_read_atbl (void *opaque, int sprn)
171
 
{
172
 
    gen_op_load_atbl();
173
 
}
174
 
 
175
 
__attribute__ (( unused ))
176
 
static void spr_read_atbu (void *opaque, int sprn)
177
 
{
178
 
    gen_op_load_atbu();
 
169
static void spr_read_tbl (void *opaque, int gprn, int sprn)
 
170
{
 
171
    gen_helper_load_tbl(cpu_gpr[gprn]);
 
172
}
 
173
 
 
174
static void spr_read_tbu (void *opaque, int gprn, int sprn)
 
175
{
 
176
    gen_helper_load_tbu(cpu_gpr[gprn]);
 
177
}
 
178
 
 
179
__attribute__ (( unused ))
 
180
static void spr_read_atbl (void *opaque, int gprn, int sprn)
 
181
{
 
182
    gen_helper_load_atbl(cpu_gpr[gprn]);
 
183
}
 
184
 
 
185
__attribute__ (( unused ))
 
186
static void spr_read_atbu (void *opaque, int gprn, int sprn)
 
187
{
 
188
    gen_helper_load_atbu(cpu_gpr[gprn]);
179
189
}
180
190
 
181
191
#if !defined(CONFIG_USER_ONLY)
182
 
static void spr_write_tbl (void *opaque, int sprn)
183
 
{
184
 
    gen_op_store_tbl();
185
 
}
186
 
 
187
 
static void spr_write_tbu (void *opaque, int sprn)
188
 
{
189
 
    gen_op_store_tbu();
190
 
}
191
 
 
192
 
__attribute__ (( unused ))
193
 
static void spr_write_atbl (void *opaque, int sprn)
194
 
{
195
 
    gen_op_store_atbl();
196
 
}
197
 
 
198
 
__attribute__ (( unused ))
199
 
static void spr_write_atbu (void *opaque, int sprn)
200
 
{
201
 
    gen_op_store_atbu();
 
192
static void spr_write_tbl (void *opaque, int sprn, int gprn)
 
193
{
 
194
    gen_helper_store_tbl(cpu_gpr[gprn]);
 
195
}
 
196
 
 
197
static void spr_write_tbu (void *opaque, int sprn, int gprn)
 
198
{
 
199
    gen_helper_store_tbu(cpu_gpr[gprn]);
 
200
}
 
201
 
 
202
__attribute__ (( unused ))
 
203
static void spr_write_atbl (void *opaque, int sprn, int gprn)
 
204
{
 
205
    gen_helper_store_atbl(cpu_gpr[gprn]);
 
206
}
 
207
 
 
208
__attribute__ (( unused ))
 
209
static void spr_write_atbu (void *opaque, int sprn, int gprn)
 
210
{
 
211
    gen_helper_store_atbu(cpu_gpr[gprn]);
202
212
}
203
213
#endif
204
214
 
205
215
#if !defined(CONFIG_USER_ONLY)
206
216
/* IBAT0U...IBAT0U */
207
217
/* IBAT0L...IBAT7L */
208
 
static void spr_read_ibat (void *opaque, int sprn)
209
 
{
210
 
    gen_op_load_ibat(sprn & 1, (sprn - SPR_IBAT0U) / 2);
211
 
}
212
 
 
213
 
static void spr_read_ibat_h (void *opaque, int sprn)
214
 
{
215
 
    gen_op_load_ibat(sprn & 1, (sprn - SPR_IBAT4U) / 2);
216
 
}
217
 
 
218
 
static void spr_write_ibatu (void *opaque, int sprn)
219
 
{
220
 
    gen_op_store_ibatu((sprn - SPR_IBAT0U) / 2);
221
 
}
222
 
 
223
 
static void spr_write_ibatu_h (void *opaque, int sprn)
224
 
{
225
 
    gen_op_store_ibatu((sprn - SPR_IBAT4U) / 2);
226
 
}
227
 
 
228
 
static void spr_write_ibatl (void *opaque, int sprn)
229
 
{
230
 
    gen_op_store_ibatl((sprn - SPR_IBAT0L) / 2);
231
 
}
232
 
 
233
 
static void spr_write_ibatl_h (void *opaque, int sprn)
234
 
{
235
 
    gen_op_store_ibatl((sprn - SPR_IBAT4L) / 2);
 
218
static void spr_read_ibat (void *opaque, int gprn, int sprn)
 
219
{
 
220
    tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
 
221
}
 
222
 
 
223
static void spr_read_ibat_h (void *opaque, int gprn, int sprn)
 
224
{
 
225
    tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, IBAT[sprn & 1][(sprn - SPR_IBAT4U) / 2]));
 
226
}
 
227
 
 
228
static void spr_write_ibatu (void *opaque, int sprn, int gprn)
 
229
{
 
230
    TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
 
231
    gen_helper_store_ibatu(t0, cpu_gpr[gprn]);
 
232
    tcg_temp_free_i32(t0);
 
233
}
 
234
 
 
235
static void spr_write_ibatu_h (void *opaque, int sprn, int gprn)
 
236
{
 
237
    TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT4U) / 2);
 
238
    gen_helper_store_ibatu(t0, cpu_gpr[gprn]);
 
239
    tcg_temp_free_i32(t0);
 
240
}
 
241
 
 
242
static void spr_write_ibatl (void *opaque, int sprn, int gprn)
 
243
{
 
244
    TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0L) / 2);
 
245
    gen_helper_store_ibatl(t0, cpu_gpr[gprn]);
 
246
    tcg_temp_free_i32(t0);
 
247
}
 
248
 
 
249
static void spr_write_ibatl_h (void *opaque, int sprn, int gprn)
 
250
{
 
251
    TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT4L) / 2);
 
252
    gen_helper_store_ibatl(t0, cpu_gpr[gprn]);
 
253
    tcg_temp_free_i32(t0);
236
254
}
237
255
 
238
256
/* DBAT0U...DBAT7U */
239
257
/* DBAT0L...DBAT7L */
240
 
static void spr_read_dbat (void *opaque, int sprn)
241
 
{
242
 
    gen_op_load_dbat(sprn & 1, (sprn - SPR_DBAT0U) / 2);
243
 
}
244
 
 
245
 
static void spr_read_dbat_h (void *opaque, int sprn)
246
 
{
247
 
    gen_op_load_dbat(sprn & 1, ((sprn - SPR_DBAT4U) / 2) + 4);
248
 
}
249
 
 
250
 
static void spr_write_dbatu (void *opaque, int sprn)
251
 
{
252
 
    gen_op_store_dbatu((sprn - SPR_DBAT0U) / 2);
253
 
}
254
 
 
255
 
static void spr_write_dbatu_h (void *opaque, int sprn)
256
 
{
257
 
    gen_op_store_dbatu(((sprn - SPR_DBAT4U) / 2) + 4);
258
 
}
259
 
 
260
 
static void spr_write_dbatl (void *opaque, int sprn)
261
 
{
262
 
    gen_op_store_dbatl((sprn - SPR_DBAT0L) / 2);
263
 
}
264
 
 
265
 
static void spr_write_dbatl_h (void *opaque, int sprn)
266
 
{
267
 
    gen_op_store_dbatl(((sprn - SPR_DBAT4L) / 2) + 4);
 
258
static void spr_read_dbat (void *opaque, int gprn, int sprn)
 
259
{
 
260
    tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, DBAT[sprn & 1][(sprn - SPR_DBAT0U) / 2]));
 
261
}
 
262
 
 
263
static void spr_read_dbat_h (void *opaque, int gprn, int sprn)
 
264
{
 
265
    tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, DBAT[sprn & 1][((sprn - SPR_DBAT4U) / 2) + 4]));
 
266
}
 
267
 
 
268
static void spr_write_dbatu (void *opaque, int sprn, int gprn)
 
269
{
 
270
    TCGv_i32 t0 = tcg_const_i32((sprn - SPR_DBAT0U) / 2);
 
271
    gen_helper_store_dbatu(t0, cpu_gpr[gprn]);
 
272
    tcg_temp_free_i32(t0);
 
273
}
 
274
 
 
275
static void spr_write_dbatu_h (void *opaque, int sprn, int gprn)
 
276
{
 
277
    TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_DBAT4U) / 2) + 4);
 
278
    gen_helper_store_dbatu(t0, cpu_gpr[gprn]);
 
279
    tcg_temp_free_i32(t0);
 
280
}
 
281
 
 
282
static void spr_write_dbatl (void *opaque, int sprn, int gprn)
 
283
{
 
284
    TCGv_i32 t0 = tcg_const_i32((sprn - SPR_DBAT0L) / 2);
 
285
    gen_helper_store_dbatl(t0, cpu_gpr[gprn]);
 
286
    tcg_temp_free_i32(t0);
 
287
}
 
288
 
 
289
static void spr_write_dbatl_h (void *opaque, int sprn, int gprn)
 
290
{
 
291
    TCGv_i32 t0 = tcg_const_i32(((sprn - SPR_DBAT4L) / 2) + 4);
 
292
    gen_helper_store_dbatl(t0, cpu_gpr[gprn]);
 
293
    tcg_temp_free_i32(t0);
268
294
}
269
295
 
270
296
/* SDR1 */
271
 
static void spr_read_sdr1 (void *opaque, int sprn)
 
297
static void spr_read_sdr1 (void *opaque, int gprn, int sprn)
272
298
{
273
 
    gen_op_load_sdr1();
 
299
    tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, sdr1));
274
300
}
275
301
 
276
 
static void spr_write_sdr1 (void *opaque, int sprn)
 
302
static void spr_write_sdr1 (void *opaque, int sprn, int gprn)
277
303
{
278
 
    gen_op_store_sdr1();
 
304
    gen_helper_store_sdr1(cpu_gpr[gprn]);
279
305
}
280
306
 
281
307
/* 64 bits PowerPC specific SPRs */
282
308
/* ASR */
283
309
#if defined(TARGET_PPC64)
284
 
static void spr_read_asr (void *opaque, int sprn)
285
 
{
286
 
    gen_op_load_asr();
287
 
}
288
 
 
289
 
static void spr_write_asr (void *opaque, int sprn)
290
 
{
291
 
    gen_op_store_asr();
 
310
static void spr_read_hior (void *opaque, int gprn, int sprn)
 
311
{
 
312
    tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, excp_prefix));
 
313
}
 
314
 
 
315
static void spr_write_hior (void *opaque, int sprn, int gprn)
 
316
{
 
317
    TCGv t0 = tcg_temp_new();
 
318
    tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0x3FFFFF00000ULL);
 
319
    tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, excp_prefix));
 
320
    tcg_temp_free(t0);
 
321
}
 
322
 
 
323
static void spr_read_asr (void *opaque, int gprn, int sprn)
 
324
{
 
325
    tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, asr));
 
326
}
 
327
 
 
328
static void spr_write_asr (void *opaque, int sprn, int gprn)
 
329
{
 
330
    gen_helper_store_asr(cpu_gpr[gprn]);
292
331
}
293
332
#endif
294
333
#endif
295
334
 
296
335
/* PowerPC 601 specific registers */
297
336
/* RTC */
298
 
static void spr_read_601_rtcl (void *opaque, int sprn)
 
337
static void spr_read_601_rtcl (void *opaque, int gprn, int sprn)
299
338
{
300
 
    gen_op_load_601_rtcl();
 
339
    gen_helper_load_601_rtcl(cpu_gpr[gprn]);
301
340
}
302
341
 
303
 
static void spr_read_601_rtcu (void *opaque, int sprn)
 
342
static void spr_read_601_rtcu (void *opaque, int gprn, int sprn)
304
343
{
305
 
    gen_op_load_601_rtcu();
 
344
    gen_helper_load_601_rtcu(cpu_gpr[gprn]);
306
345
}
307
346
 
308
347
#if !defined(CONFIG_USER_ONLY)
309
 
static void spr_write_601_rtcu (void *opaque, int sprn)
310
 
{
311
 
    gen_op_store_601_rtcu();
312
 
}
313
 
 
314
 
static void spr_write_601_rtcl (void *opaque, int sprn)
315
 
{
316
 
    gen_op_store_601_rtcl();
317
 
}
318
 
 
319
 
static void spr_write_hid0_601 (void *opaque, int sprn)
 
348
static void spr_write_601_rtcu (void *opaque, int sprn, int gprn)
 
349
{
 
350
    gen_helper_store_601_rtcu(cpu_gpr[gprn]);
 
351
}
 
352
 
 
353
static void spr_write_601_rtcl (void *opaque, int sprn, int gprn)
 
354
{
 
355
    gen_helper_store_601_rtcl(cpu_gpr[gprn]);
 
356
}
 
357
 
 
358
static void spr_write_hid0_601 (void *opaque, int sprn, int gprn)
320
359
{
321
360
    DisasContext *ctx = opaque;
322
361
 
323
 
    gen_op_store_hid0_601();
 
362
    gen_helper_store_hid0_601(cpu_gpr[gprn]);
324
363
    /* Must stop the translation as endianness may have changed */
325
 
    GEN_STOP(ctx);
 
364
    gen_stop_exception(ctx);
326
365
}
327
366
#endif
328
367
 
329
368
/* Unified bats */
330
369
#if !defined(CONFIG_USER_ONLY)
331
 
static void spr_read_601_ubat (void *opaque, int sprn)
332
 
{
333
 
    gen_op_load_601_bat(sprn & 1, (sprn - SPR_IBAT0U) / 2);
334
 
}
335
 
 
336
 
static void spr_write_601_ubatu (void *opaque, int sprn)
337
 
{
338
 
    gen_op_store_601_batu((sprn - SPR_IBAT0U) / 2);
339
 
}
340
 
 
341
 
static void spr_write_601_ubatl (void *opaque, int sprn)
342
 
{
343
 
    gen_op_store_601_batl((sprn - SPR_IBAT0L) / 2);
 
370
static void spr_read_601_ubat (void *opaque, int gprn, int sprn)
 
371
{
 
372
    tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, IBAT[sprn & 1][(sprn - SPR_IBAT0U) / 2]));
 
373
}
 
374
 
 
375
static void spr_write_601_ubatu (void *opaque, int sprn, int gprn)
 
376
{
 
377
    TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
 
378
    gen_helper_store_601_batl(t0, cpu_gpr[gprn]);
 
379
    tcg_temp_free_i32(t0);
 
380
}
 
381
 
 
382
static void spr_write_601_ubatl (void *opaque, int sprn, int gprn)
 
383
{
 
384
    TCGv_i32 t0 = tcg_const_i32((sprn - SPR_IBAT0U) / 2);
 
385
    gen_helper_store_601_batu(t0, cpu_gpr[gprn]);
 
386
    tcg_temp_free_i32(t0);
344
387
}
345
388
#endif
346
389
 
347
390
/* PowerPC 40x specific registers */
348
391
#if !defined(CONFIG_USER_ONLY)
349
 
static void spr_read_40x_pit (void *opaque, int sprn)
350
 
{
351
 
    gen_op_load_40x_pit();
352
 
}
353
 
 
354
 
static void spr_write_40x_pit (void *opaque, int sprn)
355
 
{
356
 
    gen_op_store_40x_pit();
357
 
}
358
 
 
359
 
static void spr_write_40x_dbcr0 (void *opaque, int sprn)
 
392
static void spr_read_40x_pit (void *opaque, int gprn, int sprn)
 
393
{
 
394
    gen_helper_load_40x_pit(cpu_gpr[gprn]);
 
395
}
 
396
 
 
397
static void spr_write_40x_pit (void *opaque, int sprn, int gprn)
 
398
{
 
399
    gen_helper_store_40x_pit(cpu_gpr[gprn]);
 
400
}
 
401
 
 
402
static void spr_write_40x_dbcr0 (void *opaque, int sprn, int gprn)
360
403
{
361
404
    DisasContext *ctx = opaque;
362
405
 
363
 
    gen_op_store_40x_dbcr0();
 
406
    gen_helper_store_40x_dbcr0(cpu_gpr[gprn]);
364
407
    /* We must stop translation as we may have rebooted */
365
 
    GEN_STOP(ctx);
366
 
}
367
 
 
368
 
static void spr_write_40x_sler (void *opaque, int sprn)
369
 
{
370
 
    gen_op_store_40x_sler();
371
 
}
372
 
 
373
 
static void spr_write_booke_tcr (void *opaque, int sprn)
374
 
{
375
 
    gen_op_store_booke_tcr();
376
 
}
377
 
 
378
 
static void spr_write_booke_tsr (void *opaque, int sprn)
379
 
{
380
 
    gen_op_store_booke_tsr();
 
408
    gen_stop_exception(ctx);
 
409
}
 
410
 
 
411
static void spr_write_40x_sler (void *opaque, int sprn, int gprn)
 
412
{
 
413
    gen_helper_store_40x_sler(cpu_gpr[gprn]);
 
414
}
 
415
 
 
416
static void spr_write_booke_tcr (void *opaque, int sprn, int gprn)
 
417
{
 
418
    gen_helper_store_booke_tcr(cpu_gpr[gprn]);
 
419
}
 
420
 
 
421
static void spr_write_booke_tsr (void *opaque, int sprn, int gprn)
 
422
{
 
423
    gen_helper_store_booke_tsr(cpu_gpr[gprn]);
381
424
}
382
425
#endif
383
426
 
384
427
/* PowerPC 403 specific registers */
385
428
/* PBL1 / PBU1 / PBL2 / PBU2 */
386
429
#if !defined(CONFIG_USER_ONLY)
387
 
static void spr_read_403_pbr (void *opaque, int sprn)
388
 
{
389
 
    gen_op_load_403_pb(sprn - SPR_403_PBL1);
390
 
}
391
 
 
392
 
static void spr_write_403_pbr (void *opaque, int sprn)
393
 
{
394
 
    gen_op_store_403_pb(sprn - SPR_403_PBL1);
395
 
}
396
 
 
397
 
static void spr_write_pir (void *opaque, int sprn)
398
 
{
399
 
    gen_op_store_pir();
 
430
static void spr_read_403_pbr (void *opaque, int gprn, int sprn)
 
431
{
 
432
    tcg_gen_ld_tl(cpu_gpr[gprn], cpu_env, offsetof(CPUState, pb[sprn - SPR_403_PBL1]));
 
433
}
 
434
 
 
435
static void spr_write_403_pbr (void *opaque, int sprn, int gprn)
 
436
{
 
437
    TCGv_i32 t0 = tcg_const_i32(sprn - SPR_403_PBL1);
 
438
    gen_helper_store_403_pbr(t0, cpu_gpr[gprn]);
 
439
    tcg_temp_free_i32(t0);
 
440
}
 
441
 
 
442
static void spr_write_pir (void *opaque, int sprn, int gprn)
 
443
{
 
444
    TCGv t0 = tcg_temp_new();
 
445
    tcg_gen_andi_tl(t0, cpu_gpr[gprn], 0xF);
 
446
    gen_store_spr(SPR_PIR, t0);
 
447
    tcg_temp_free(t0);
400
448
}
401
449
#endif
402
450
 
403
451
#if !defined(CONFIG_USER_ONLY)
404
452
/* Callback used to write the exception vector base */
405
 
static void spr_write_excp_prefix (void *opaque, int sprn)
 
453
static void spr_write_excp_prefix (void *opaque, int sprn, int gprn)
406
454
{
407
 
    gen_op_store_excp_prefix();
408
 
    gen_op_store_spr(sprn);
 
455
    TCGv t0 = tcg_temp_new();
 
456
    tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, ivpr_mask));
 
457
    tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
 
458
    tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, excp_prefix));
 
459
    gen_store_spr(sprn, t0);
409
460
}
410
461
 
411
 
static void spr_write_excp_vector (void *opaque, int sprn)
 
462
static void spr_write_excp_vector (void *opaque, int sprn, int gprn)
412
463
{
413
464
    DisasContext *ctx = opaque;
414
465
 
415
466
    if (sprn >= SPR_BOOKE_IVOR0 && sprn <= SPR_BOOKE_IVOR15) {
416
 
        gen_op_store_excp_vector(sprn - SPR_BOOKE_IVOR0);
417
 
        gen_op_store_spr(sprn);
 
467
        TCGv t0 = tcg_temp_new();
 
468
        tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, ivor_mask));
 
469
        tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
 
470
        tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, excp_vectors[sprn - SPR_BOOKE_IVOR0]));
 
471
        gen_store_spr(sprn, t0);
 
472
        tcg_temp_free(t0);
418
473
    } else if (sprn >= SPR_BOOKE_IVOR32 && sprn <= SPR_BOOKE_IVOR37) {
419
 
        gen_op_store_excp_vector(sprn - SPR_BOOKE_IVOR32 + 32);
420
 
        gen_op_store_spr(sprn);
 
474
        TCGv t0 = tcg_temp_new();
 
475
        tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUState, ivor_mask));
 
476
        tcg_gen_and_tl(t0, t0, cpu_gpr[gprn]);
 
477
        tcg_gen_st_tl(t0, cpu_env, offsetof(CPUState, excp_vectors[sprn - SPR_BOOKE_IVOR32 + 32]));
 
478
        gen_store_spr(sprn, t0);
 
479
        tcg_temp_free(t0);
421
480
    } else {
422
481
        printf("Trying to write an unknown exception vector %d %03x\n",
423
482
               sprn, sprn);
424
 
        GEN_EXCP_PRIVREG(ctx);
 
483
        gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
425
484
    }
426
485
}
427
486
#endif
428
487
 
 
488
static inline void vscr_init (CPUPPCState *env, uint32_t val)
 
489
{
 
490
    env->vscr = val;
 
491
    /* Altivec always uses round-to-nearest */
 
492
    set_float_rounding_mode(float_round_nearest_even, &env->vec_status);
 
493
    set_flush_to_zero(vscr_nj, &env->vec_status);
 
494
}
 
495
 
429
496
#if defined(CONFIG_USER_ONLY)
430
497
#define spr_register(env, num, name, uea_read, uea_write,                     \
431
498
                     oea_read, oea_write, initial_value)                      \
433
500
     _spr_register(env, num, name, uea_read, uea_write, initial_value);       \
434
501
} while (0)
435
502
static inline void _spr_register (CPUPPCState *env, int num,
436
 
                                  const unsigned char *name,
437
 
                                  void (*uea_read)(void *opaque, int sprn),
438
 
                                  void (*uea_write)(void *opaque, int sprn),
 
503
                                  const char *name,
 
504
                                  void (*uea_read)(void *opaque, int gprn, int sprn),
 
505
                                  void (*uea_write)(void *opaque, int sprn, int gprn),
439
506
                                  target_ulong initial_value)
440
507
#else
441
508
static inline void spr_register (CPUPPCState *env, int num,
442
 
                                 const unsigned char *name,
443
 
                                 void (*uea_read)(void *opaque, int sprn),
444
 
                                 void (*uea_write)(void *opaque, int sprn),
445
 
                                 void (*oea_read)(void *opaque, int sprn),
446
 
                                 void (*oea_write)(void *opaque, int sprn),
 
509
                                 const char *name,
 
510
                                 void (*uea_read)(void *opaque, int gprn, int sprn),
 
511
                                 void (*uea_write)(void *opaque, int sprn, int gprn),
 
512
                                 void (*oea_read)(void *opaque, int gprn, int sprn),
 
513
                                 void (*oea_write)(void *opaque, int sprn, int gprn),
447
514
                                 target_ulong initial_value)
448
515
#endif
449
516
{
1174
1241
                 SPR_NOACCESS, SPR_NOACCESS,
1175
1242
                 &spr_read_generic, &spr_write_generic,
1176
1243
                 0x00000000);
 
1244
    /* Not strictly an SPR */
 
1245
    vscr_init(env, 0x00010000);
1177
1246
}
1178
1247
 
1179
1248
static void gen_l3_ctrl (CPUPPCState *env)
1245
1314
/* PowerPC BookE SPR */
1246
1315
static void gen_spr_BookE (CPUPPCState *env, uint64_t ivor_mask)
1247
1316
{
1248
 
    const unsigned char *ivor_names[64] = {
 
1317
    const char *ivor_names[64] = {
1249
1318
        "IVOR0",  "IVOR1",  "IVOR2",  "IVOR3",
1250
1319
        "IVOR4",  "IVOR5",  "IVOR6",  "IVOR7",
1251
1320
        "IVOR8",  "IVOR9",  "IVOR10", "IVOR11",
1407
1476
static void gen_spr_BookE_FSL (CPUPPCState *env, uint32_t mas_mask)
1408
1477
{
1409
1478
#if !defined(CONFIG_USER_ONLY)
1410
 
    const unsigned char *mas_names[8] = {
 
1479
    const char *mas_names[8] = {
1411
1480
        "MAS0", "MAS1", "MAS2", "MAS3", "MAS4", "MAS5", "MAS6", "MAS7",
1412
1481
    };
1413
1482
    int mas_sprn[8] = {
3928
3997
 * all SPE multiply-accumulate instructions
3929
3998
 */
3930
3999
#define POWERPC_INSNS_e200   (PPC_INSNS_BASE | PPC_ISEL |                     \
3931
 
                              PPC_SPE | PPC_SPEFPU |                          \
 
4000
                              PPC_SPE | PPC_SPE_SINGLE |                      \
3932
4001
                              PPC_WRTEE | PPC_RFDI |                          \
3933
4002
                              PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |   \
3934
4003
                              PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
4091
4160
    ppc6xx_irq_init(env);
4092
4161
}
4093
4162
 
4094
 
/* e500 core                                                                 */
4095
 
#define POWERPC_INSNS_e500   (PPC_INSNS_BASE | PPC_ISEL |                     \
4096
 
                              PPC_SPE | PPC_SPEFPU |                          \
4097
 
                              PPC_WRTEE | PPC_RFDI |                          \
4098
 
                              PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI |   \
4099
 
                              PPC_CACHE_DCBZ | PPC_CACHE_DCBA |               \
4100
 
                              PPC_MEM_TLBSYNC | PPC_TLBIVAX |                 \
4101
 
                              PPC_BOOKE)
4102
 
#define POWERPC_MSRM_e500    (0x000000000606FF30ULL)
4103
 
#define POWERPC_MMU_e500     (POWERPC_MMU_BOOKE_FSL)
4104
 
#define POWERPC_EXCP_e500    (POWERPC_EXCP_BOOKE)
4105
 
#define POWERPC_INPUT_e500   (PPC_FLAGS_INPUT_BookE)
4106
 
#define POWERPC_BFDM_e500    (bfd_mach_ppc_860)
4107
 
#define POWERPC_FLAG_e500    (POWERPC_FLAG_SPE | POWERPC_FLAG_CE |            \
4108
 
                              POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |           \
4109
 
                              POWERPC_FLAG_BUS_CLK)
4110
 
#define check_pow_e500       check_pow_hid0
4111
 
 
4112
 
__attribute__ (( unused ))
 
4163
/* e500v1 core                                                               */
 
4164
#define POWERPC_INSNS_e500v1   (PPC_INSNS_BASE | PPC_ISEL |             \
 
4165
                                PPC_SPE | PPC_SPE_SINGLE |              \
 
4166
                                PPC_WRTEE | PPC_RFDI |                  \
 
4167
                                PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI | \
 
4168
                                PPC_CACHE_DCBZ | PPC_CACHE_DCBA |       \
 
4169
                                PPC_MEM_TLBSYNC | PPC_TLBIVAX |         \
 
4170
                                PPC_BOOKE)
 
4171
#define POWERPC_MSRM_e500v1    (0x000000000606FF30ULL)
 
4172
#define POWERPC_MMU_e500v1     (POWERPC_MMU_BOOKE_FSL)
 
4173
#define POWERPC_EXCP_e500v1    (POWERPC_EXCP_BOOKE)
 
4174
#define POWERPC_INPUT_e500v1   (PPC_FLAGS_INPUT_BookE)
 
4175
#define POWERPC_BFDM_e500v1    (bfd_mach_ppc_860)
 
4176
#define POWERPC_FLAG_e500v1    (POWERPC_FLAG_SPE | POWERPC_FLAG_CE |    \
 
4177
                                POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |   \
 
4178
                                POWERPC_FLAG_BUS_CLK)
 
4179
#define check_pow_e500v1       check_pow_hid0
 
4180
#define init_proc_e500v1       init_proc_e500
 
4181
 
 
4182
/* e500v2 core                                                               */
 
4183
#define POWERPC_INSNS_e500v2   (PPC_INSNS_BASE | PPC_ISEL |             \
 
4184
                                PPC_SPE | PPC_SPE_SINGLE | PPC_SPE_DOUBLE |   \
 
4185
                                PPC_WRTEE | PPC_RFDI |                  \
 
4186
                                PPC_CACHE | PPC_CACHE_LOCK | PPC_CACHE_ICBI | \
 
4187
                                PPC_CACHE_DCBZ | PPC_CACHE_DCBA |       \
 
4188
                                PPC_MEM_TLBSYNC | PPC_TLBIVAX |         \
 
4189
                                PPC_BOOKE)
 
4190
#define POWERPC_MSRM_e500v2    (0x000000000606FF30ULL)
 
4191
#define POWERPC_MMU_e500v2     (POWERPC_MMU_BOOKE_FSL)
 
4192
#define POWERPC_EXCP_e500v2    (POWERPC_EXCP_BOOKE)
 
4193
#define POWERPC_INPUT_e500v2   (PPC_FLAGS_INPUT_BookE)
 
4194
#define POWERPC_BFDM_e500v2    (bfd_mach_ppc_860)
 
4195
#define POWERPC_FLAG_e500v2    (POWERPC_FLAG_SPE | POWERPC_FLAG_CE |    \
 
4196
                                POWERPC_FLAG_UBLE | POWERPC_FLAG_DE |   \
 
4197
                                POWERPC_FLAG_BUS_CLK)
 
4198
#define check_pow_e500v2       check_pow_hid0
 
4199
#define init_proc_e500v2       init_proc_e500
 
4200
 
4113
4201
static void init_proc_e500 (CPUPPCState *env)
4114
4202
{
4115
4203
    /* Time base */
4211
4299
    init_excp_e200(env);
4212
4300
    env->dcache_line_size = 32;
4213
4301
    env->icache_line_size = 32;
4214
 
    /* XXX: TODO: allocate internal IRQ controller */
 
4302
    /* Allocate hardware IRQ controller */
 
4303
    ppce500_irq_init(env);
4215
4304
}
4216
4305
 
4217
4306
/* Non-embedded PowerPC                                                      */
5863
5952
                 0x00000000); /* TOFIX */
5864
5953
    spr_register(env, SPR_HIOR, "SPR_HIOR",
5865
5954
                 SPR_NOACCESS, SPR_NOACCESS,
5866
 
                 &spr_read_generic, &spr_write_generic,
5867
 
                 0xFFF00000); /* XXX: This is a hack */
 
5955
                 &spr_read_hior, &spr_write_hior,
 
5956
                 0x00000000);
5868
5957
#if !defined(CONFIG_USER_ONLY)
5869
5958
    env->slb_nr = 32;
5870
5959
#endif
5873
5962
    env->icache_line_size = 128;
5874
5963
    /* Allocate hardware IRQ controller */
5875
5964
    ppc970_irq_init(env);
 
5965
    /* Can't find information on what this should be on reset.  This
 
5966
     * value is the one used by 74xx processors. */
 
5967
    vscr_init(env, 0x00010000);
5876
5968
}
5877
5969
 
5878
5970
/* PowerPC 970FX (aka G5)                                                    */
5949
6041
                 0x00000000); /* TOFIX */
5950
6042
    spr_register(env, SPR_HIOR, "SPR_HIOR",
5951
6043
                 SPR_NOACCESS, SPR_NOACCESS,
5952
 
                 &spr_read_generic, &spr_write_generic,
5953
 
                 0xFFF00000); /* XXX: This is a hack */
 
6044
                 &spr_read_hior, &spr_write_hior,
 
6045
                 0x00000000);
5954
6046
#if !defined(CONFIG_USER_ONLY)
5955
6047
    env->slb_nr = 32;
5956
6048
#endif
5959
6051
    env->icache_line_size = 128;
5960
6052
    /* Allocate hardware IRQ controller */
5961
6053
    ppc970_irq_init(env);
 
6054
    /* Can't find information on what this should be on reset.  This
 
6055
     * value is the one used by 74xx processors. */
 
6056
    vscr_init(env, 0x00010000);
5962
6057
}
5963
6058
 
5964
6059
/* PowerPC 970 GX                                                            */
6035
6130
                 0x00000000); /* TOFIX */
6036
6131
    spr_register(env, SPR_HIOR, "SPR_HIOR",
6037
6132
                 SPR_NOACCESS, SPR_NOACCESS,
6038
 
                 &spr_read_generic, &spr_write_generic,
6039
 
                 0xFFF00000); /* XXX: This is a hack */
 
6133
                 &spr_read_hior, &spr_write_hior,
 
6134
                 0x00000000);
6040
6135
#if !defined(CONFIG_USER_ONLY)
6041
6136
    env->slb_nr = 32;
6042
6137
#endif
6045
6140
    env->icache_line_size = 128;
6046
6141
    /* Allocate hardware IRQ controller */
6047
6142
    ppc970_irq_init(env);
 
6143
    /* Can't find information on what this should be on reset.  This
 
6144
     * value is the one used by 74xx processors. */
 
6145
    vscr_init(env, 0x00010000);
6048
6146
}
6049
6147
 
6050
6148
/* PowerPC 970 MP                                                            */
6121
6219
                 0x00000000); /* TOFIX */
6122
6220
    spr_register(env, SPR_HIOR, "SPR_HIOR",
6123
6221
                 SPR_NOACCESS, SPR_NOACCESS,
6124
 
                 &spr_read_generic, &spr_write_generic,
6125
 
                 0xFFF00000); /* XXX: This is a hack */
 
6222
                 &spr_read_hior, &spr_write_hior,
 
6223
                 0x00000000);
6126
6224
#if !defined(CONFIG_USER_ONLY)
6127
6225
    env->slb_nr = 32;
6128
6226
#endif
6131
6229
    env->icache_line_size = 128;
6132
6230
    /* Allocate hardware IRQ controller */
6133
6231
    ppc970_irq_init(env);
 
6232
    /* Can't find information on what this should be on reset.  This
 
6233
     * value is the one used by 74xx processors. */
 
6234
    vscr_init(env, 0x00010000);
6134
6235
}
6135
6236
 
6136
6237
/* PowerPC 620                                                               */
6623
6724
    /* e500 family */
6624
6725
    /* e500 cores  */
6625
6726
#define CPU_POWERPC_e500             CPU_POWERPC_e500v2_v22
 
6727
#define CPU_POWERPC_e500v1           CPU_POWERPC_e500v1_v20
6626
6728
#define CPU_POWERPC_e500v2           CPU_POWERPC_e500v2_v22
6627
 
    CPU_POWERPC_e500_v10           = 0x80200010,
6628
 
    CPU_POWERPC_e500_v20           = 0x80200020,
 
6729
    CPU_POWERPC_e500v1_v10         = 0x80200010,
 
6730
    CPU_POWERPC_e500v1_v20         = 0x80200020,
6629
6731
    CPU_POWERPC_e500v2_v10         = 0x80210010,
6630
6732
    CPU_POWERPC_e500v2_v11         = 0x80210011,
6631
6733
    CPU_POWERPC_e500v2_v20         = 0x80210020,
6640
6742
#define CPU_POWERPC_MPC8533E_v10     CPU_POWERPC_e500v2_v21
6641
6743
#define CPU_POWERPC_MPC8533E_v11     CPU_POWERPC_e500v2_v22
6642
6744
#define CPU_POWERPC_MPC8540          CPU_POWERPC_MPC8540_v21
6643
 
#define CPU_POWERPC_MPC8540_v10      CPU_POWERPC_e500_v10
6644
 
#define CPU_POWERPC_MPC8540_v20      CPU_POWERPC_e500_v20
6645
 
#define CPU_POWERPC_MPC8540_v21      CPU_POWERPC_e500_v20
 
6745
#define CPU_POWERPC_MPC8540_v10      CPU_POWERPC_e500v1_v10
 
6746
#define CPU_POWERPC_MPC8540_v20      CPU_POWERPC_e500v1_v20
 
6747
#define CPU_POWERPC_MPC8540_v21      CPU_POWERPC_e500v1_v20
6646
6748
#define CPU_POWERPC_MPC8541          CPU_POWERPC_MPC8541_v11
6647
 
#define CPU_POWERPC_MPC8541_v10      CPU_POWERPC_e500_v20
6648
 
#define CPU_POWERPC_MPC8541_v11      CPU_POWERPC_e500_v20
 
6749
#define CPU_POWERPC_MPC8541_v10      CPU_POWERPC_e500v1_v20
 
6750
#define CPU_POWERPC_MPC8541_v11      CPU_POWERPC_e500v1_v20
6649
6751
#define CPU_POWERPC_MPC8541E         CPU_POWERPC_MPC8541E_v11
6650
 
#define CPU_POWERPC_MPC8541E_v10     CPU_POWERPC_e500_v20
6651
 
#define CPU_POWERPC_MPC8541E_v11     CPU_POWERPC_e500_v20
 
6752
#define CPU_POWERPC_MPC8541E_v10     CPU_POWERPC_e500v1_v20
 
6753
#define CPU_POWERPC_MPC8541E_v11     CPU_POWERPC_e500v1_v20
6652
6754
#define CPU_POWERPC_MPC8543          CPU_POWERPC_MPC8543_v21
6653
6755
#define CPU_POWERPC_MPC8543_v10      CPU_POWERPC_e500v2_v10
6654
6756
#define CPU_POWERPC_MPC8543_v11      CPU_POWERPC_e500v2_v11
7975
8077
                    CPU_POWERPC_MPC8379E,     POWERPC_SVR_8379E,     e300),
7976
8078
    /* e500 family                                                           */
7977
8079
    /* PowerPC e500 core                                                     */
7978
 
    POWERPC_DEF("e500",          CPU_POWERPC_e500,                   e500),
 
8080
    POWERPC_DEF("e500",          CPU_POWERPC_e500v2_v22,             e500v2),
 
8081
    /* PowerPC e500v1 core                                                   */
 
8082
    POWERPC_DEF("e500v1",        CPU_POWERPC_e500v1,                 e500v1),
7979
8083
    /* PowerPC e500 v1.0 core                                                */
7980
 
    POWERPC_DEF("e500_v10",      CPU_POWERPC_e500_v10,               e500),
 
8084
    POWERPC_DEF("e500_v10",      CPU_POWERPC_e500v1_v10,             e500v1),
7981
8085
    /* PowerPC e500 v2.0 core                                                */
7982
 
    POWERPC_DEF("e500_v20",      CPU_POWERPC_e500_v20,               e500),
 
8086
    POWERPC_DEF("e500_v20",      CPU_POWERPC_e500v1_v20,             e500v1),
7983
8087
    /* PowerPC e500v2 core                                                   */
7984
 
    POWERPC_DEF("e500v2",        CPU_POWERPC_e500v2,                 e500),
 
8088
    POWERPC_DEF("e500v2",        CPU_POWERPC_e500v2,                 e500v2),
7985
8089
    /* PowerPC e500v2 v1.0 core                                              */
7986
 
    POWERPC_DEF("e500v2_v10",    CPU_POWERPC_e500v2_v10,             e500),
 
8090
    POWERPC_DEF("e500v2_v10",    CPU_POWERPC_e500v2_v10,             e500v2),
7987
8091
    /* PowerPC e500v2 v2.0 core                                              */
7988
 
    POWERPC_DEF("e500v2_v20",    CPU_POWERPC_e500v2_v20,             e500),
 
8092
    POWERPC_DEF("e500v2_v20",    CPU_POWERPC_e500v2_v20,             e500v2),
7989
8093
    /* PowerPC e500v2 v2.1 core                                              */
7990
 
    POWERPC_DEF("e500v2_v21",    CPU_POWERPC_e500v2_v21,             e500),
 
8094
    POWERPC_DEF("e500v2_v21",    CPU_POWERPC_e500v2_v21,             e500v2),
7991
8095
    /* PowerPC e500v2 v2.2 core                                              */
7992
 
    POWERPC_DEF("e500v2_v22",    CPU_POWERPC_e500v2_v22,             e500),
 
8096
    POWERPC_DEF("e500v2_v22",    CPU_POWERPC_e500v2_v22,             e500v2),
7993
8097
    /* PowerPC e500v2 v3.0 core                                              */
7994
 
    POWERPC_DEF("e500v2_v30",    CPU_POWERPC_e500v2_v30,             e500),
 
8098
    POWERPC_DEF("e500v2_v30",    CPU_POWERPC_e500v2_v30,             e500v2),
7995
8099
    /* PowerPC e500 microcontrollers                                         */
7996
8100
    /* MPC8533                                                               */
7997
8101
    POWERPC_DEF_SVR("MPC8533",
7998
 
                    CPU_POWERPC_MPC8533,      POWERPC_SVR_8533,      e500),
 
8102
                    CPU_POWERPC_MPC8533,      POWERPC_SVR_8533,      e500v2),
7999
8103
    /* MPC8533 v1.0                                                          */
8000
8104
    POWERPC_DEF_SVR("MPC8533_v10",
8001
 
                    CPU_POWERPC_MPC8533_v10,  POWERPC_SVR_8533_v10,  e500),
 
8105
                    CPU_POWERPC_MPC8533_v10,  POWERPC_SVR_8533_v10,  e500v2),
8002
8106
    /* MPC8533 v1.1                                                          */
8003
8107
    POWERPC_DEF_SVR("MPC8533_v11",
8004
 
                    CPU_POWERPC_MPC8533_v11,  POWERPC_SVR_8533_v11,  e500),
 
8108
                    CPU_POWERPC_MPC8533_v11,  POWERPC_SVR_8533_v11,  e500v2),
8005
8109
    /* MPC8533E                                                              */
8006
8110
    POWERPC_DEF_SVR("MPC8533E",
8007
 
                    CPU_POWERPC_MPC8533E,     POWERPC_SVR_8533E,     e500),
 
8111
                    CPU_POWERPC_MPC8533E,     POWERPC_SVR_8533E,     e500v2),
8008
8112
    /* MPC8533E v1.0                                                         */
8009
8113
    POWERPC_DEF_SVR("MPC8533E_v10",
8010
 
                    CPU_POWERPC_MPC8533E_v10, POWERPC_SVR_8533E_v10, e500),
 
8114
                    CPU_POWERPC_MPC8533E_v10, POWERPC_SVR_8533E_v10, e500v2),
8011
8115
    POWERPC_DEF_SVR("MPC8533E_v11",
8012
 
                    CPU_POWERPC_MPC8533E_v11, POWERPC_SVR_8533E_v11, e500),
 
8116
                    CPU_POWERPC_MPC8533E_v11, POWERPC_SVR_8533E_v11, e500v2),
8013
8117
    /* MPC8540                                                               */
8014
8118
    POWERPC_DEF_SVR("MPC8540",
8015
 
                    CPU_POWERPC_MPC8540,      POWERPC_SVR_8540,      e500),
 
8119
                    CPU_POWERPC_MPC8540,      POWERPC_SVR_8540,      e500v1),
8016
8120
    /* MPC8540 v1.0                                                          */
8017
8121
    POWERPC_DEF_SVR("MPC8540_v10",
8018
 
                    CPU_POWERPC_MPC8540_v10,  POWERPC_SVR_8540_v10,  e500),
 
8122
                    CPU_POWERPC_MPC8540_v10,  POWERPC_SVR_8540_v10,  e500v1),
8019
8123
    /* MPC8540 v2.0                                                          */
8020
8124
    POWERPC_DEF_SVR("MPC8540_v20",
8021
 
                    CPU_POWERPC_MPC8540_v20,  POWERPC_SVR_8540_v20,  e500),
 
8125
                    CPU_POWERPC_MPC8540_v20,  POWERPC_SVR_8540_v20,  e500v1),
8022
8126
    /* MPC8540 v2.1                                                          */
8023
8127
    POWERPC_DEF_SVR("MPC8540_v21",
8024
 
                    CPU_POWERPC_MPC8540_v21,  POWERPC_SVR_8540_v21,  e500),
 
8128
                    CPU_POWERPC_MPC8540_v21,  POWERPC_SVR_8540_v21,  e500v1),
8025
8129
    /* MPC8541                                                               */
8026
8130
    POWERPC_DEF_SVR("MPC8541",
8027
 
                    CPU_POWERPC_MPC8541,      POWERPC_SVR_8541,      e500),
 
8131
                    CPU_POWERPC_MPC8541,      POWERPC_SVR_8541,      e500v1),
8028
8132
    /* MPC8541 v1.0                                                          */
8029
8133
    POWERPC_DEF_SVR("MPC8541_v10",
8030
 
                    CPU_POWERPC_MPC8541_v10,  POWERPC_SVR_8541_v10,  e500),
 
8134
                    CPU_POWERPC_MPC8541_v10,  POWERPC_SVR_8541_v10,  e500v1),
8031
8135
    /* MPC8541 v1.1                                                          */
8032
8136
    POWERPC_DEF_SVR("MPC8541_v11",
8033
 
                    CPU_POWERPC_MPC8541_v11,  POWERPC_SVR_8541_v11,  e500),
 
8137
                    CPU_POWERPC_MPC8541_v11,  POWERPC_SVR_8541_v11,  e500v1),
8034
8138
    /* MPC8541E                                                              */
8035
8139
    POWERPC_DEF_SVR("MPC8541E",
8036
 
                    CPU_POWERPC_MPC8541E,     POWERPC_SVR_8541E,     e500),
 
8140
                    CPU_POWERPC_MPC8541E,     POWERPC_SVR_8541E,     e500v1),
8037
8141
    /* MPC8541E v1.0                                                         */
8038
8142
    POWERPC_DEF_SVR("MPC8541E_v10",
8039
 
                    CPU_POWERPC_MPC8541E_v10, POWERPC_SVR_8541E_v10, e500),
 
8143
                    CPU_POWERPC_MPC8541E_v10, POWERPC_SVR_8541E_v10, e500v1),
8040
8144
    /* MPC8541E v1.1                                                         */
8041
8145
    POWERPC_DEF_SVR("MPC8541E_v11",
8042
 
                    CPU_POWERPC_MPC8541E_v11, POWERPC_SVR_8541E_v11, e500),
 
8146
                    CPU_POWERPC_MPC8541E_v11, POWERPC_SVR_8541E_v11, e500v1),
8043
8147
    /* MPC8543                                                               */
8044
8148
    POWERPC_DEF_SVR("MPC8543",
8045
 
                    CPU_POWERPC_MPC8543,      POWERPC_SVR_8543,      e500),
 
8149
                    CPU_POWERPC_MPC8543,      POWERPC_SVR_8543,      e500v2),
8046
8150
    /* MPC8543 v1.0                                                          */
8047
8151
    POWERPC_DEF_SVR("MPC8543_v10",
8048
 
                    CPU_POWERPC_MPC8543_v10,  POWERPC_SVR_8543_v10,  e500),
 
8152
                    CPU_POWERPC_MPC8543_v10,  POWERPC_SVR_8543_v10,  e500v2),
8049
8153
    /* MPC8543 v1.1                                                          */
8050
8154
    POWERPC_DEF_SVR("MPC8543_v11",
8051
 
                    CPU_POWERPC_MPC8543_v11,  POWERPC_SVR_8543_v11,  e500),
 
8155
                    CPU_POWERPC_MPC8543_v11,  POWERPC_SVR_8543_v11,  e500v2),
8052
8156
    /* MPC8543 v2.0                                                          */
8053
8157
    POWERPC_DEF_SVR("MPC8543_v20",
8054
 
                    CPU_POWERPC_MPC8543_v20,  POWERPC_SVR_8543_v20,  e500),
 
8158
                    CPU_POWERPC_MPC8543_v20,  POWERPC_SVR_8543_v20,  e500v2),
8055
8159
    /* MPC8543 v2.1                                                          */
8056
8160
    POWERPC_DEF_SVR("MPC8543_v21",
8057
 
                    CPU_POWERPC_MPC8543_v21,  POWERPC_SVR_8543_v21,  e500),
 
8161
                    CPU_POWERPC_MPC8543_v21,  POWERPC_SVR_8543_v21,  e500v2),
8058
8162
    /* MPC8543E                                                              */
8059
8163
    POWERPC_DEF_SVR("MPC8543E",
8060
 
                    CPU_POWERPC_MPC8543E,     POWERPC_SVR_8543E,     e500),
 
8164
                    CPU_POWERPC_MPC8543E,     POWERPC_SVR_8543E,     e500v2),
8061
8165
    /* MPC8543E v1.0                                                         */
8062
8166
    POWERPC_DEF_SVR("MPC8543E_v10",
8063
 
                    CPU_POWERPC_MPC8543E_v10, POWERPC_SVR_8543E_v10, e500),
 
8167
                    CPU_POWERPC_MPC8543E_v10, POWERPC_SVR_8543E_v10, e500v2),
8064
8168
    /* MPC8543E v1.1                                                         */
8065
8169
    POWERPC_DEF_SVR("MPC8543E_v11",
8066
 
                    CPU_POWERPC_MPC8543E_v11, POWERPC_SVR_8543E_v11, e500),
 
8170
                    CPU_POWERPC_MPC8543E_v11, POWERPC_SVR_8543E_v11, e500v2),
8067
8171
    /* MPC8543E v2.0                                                         */
8068
8172
    POWERPC_DEF_SVR("MPC8543E_v20",
8069
 
                    CPU_POWERPC_MPC8543E_v20, POWERPC_SVR_8543E_v20, e500),
 
8173
                    CPU_POWERPC_MPC8543E_v20, POWERPC_SVR_8543E_v20, e500v2),
8070
8174
    /* MPC8543E v2.1                                                         */
8071
8175
    POWERPC_DEF_SVR("MPC8543E_v21",
8072
 
                    CPU_POWERPC_MPC8543E_v21, POWERPC_SVR_8543E_v21, e500),
 
8176
                    CPU_POWERPC_MPC8543E_v21, POWERPC_SVR_8543E_v21, e500v2),
8073
8177
    /* MPC8544                                                               */
8074
8178
    POWERPC_DEF_SVR("MPC8544",
8075
 
                    CPU_POWERPC_MPC8544,      POWERPC_SVR_8544,      e500),
 
8179
                    CPU_POWERPC_MPC8544,      POWERPC_SVR_8544,      e500v2),
8076
8180
    /* MPC8544 v1.0                                                          */
8077
8181
    POWERPC_DEF_SVR("MPC8544_v10",
8078
 
                    CPU_POWERPC_MPC8544_v10,  POWERPC_SVR_8544_v10,  e500),
 
8182
                    CPU_POWERPC_MPC8544_v10,  POWERPC_SVR_8544_v10,  e500v2),
8079
8183
    /* MPC8544 v1.1                                                          */
8080
8184
    POWERPC_DEF_SVR("MPC8544_v11",
8081
 
                    CPU_POWERPC_MPC8544_v11,  POWERPC_SVR_8544_v11,  e500),
 
8185
                    CPU_POWERPC_MPC8544_v11,  POWERPC_SVR_8544_v11,  e500v2),
8082
8186
    /* MPC8544E                                                              */
8083
8187
    POWERPC_DEF_SVR("MPC8544E",
8084
 
                    CPU_POWERPC_MPC8544E,     POWERPC_SVR_8544E,     e500),
 
8188
                    CPU_POWERPC_MPC8544E,     POWERPC_SVR_8544E,     e500v2),
8085
8189
    /* MPC8544E v1.0                                                         */
8086
8190
    POWERPC_DEF_SVR("MPC8544E_v10",
8087
 
                    CPU_POWERPC_MPC8544E_v10, POWERPC_SVR_8544E_v10, e500),
 
8191
                    CPU_POWERPC_MPC8544E_v10, POWERPC_SVR_8544E_v10, e500v2),
8088
8192
    /* MPC8544E v1.1                                                         */
8089
8193
    POWERPC_DEF_SVR("MPC8544E_v11",
8090
 
                    CPU_POWERPC_MPC8544E_v11, POWERPC_SVR_8544E_v11, e500),
 
8194
                    CPU_POWERPC_MPC8544E_v11, POWERPC_SVR_8544E_v11, e500v2),
8091
8195
    /* MPC8545                                                               */
8092
8196
    POWERPC_DEF_SVR("MPC8545",
8093
 
                    CPU_POWERPC_MPC8545,      POWERPC_SVR_8545,      e500),
 
8197
                    CPU_POWERPC_MPC8545,      POWERPC_SVR_8545,      e500v2),
8094
8198
    /* MPC8545 v2.0                                                          */
8095
8199
    POWERPC_DEF_SVR("MPC8545_v20",
8096
 
                    CPU_POWERPC_MPC8545_v20,  POWERPC_SVR_8545_v20,  e500),
 
8200
                    CPU_POWERPC_MPC8545_v20,  POWERPC_SVR_8545_v20,  e500v2),
8097
8201
    /* MPC8545 v2.1                                                          */
8098
8202
    POWERPC_DEF_SVR("MPC8545_v21",
8099
 
                    CPU_POWERPC_MPC8545_v21,  POWERPC_SVR_8545_v21,  e500),
 
8203
                    CPU_POWERPC_MPC8545_v21,  POWERPC_SVR_8545_v21,  e500v2),
8100
8204
    /* MPC8545E                                                              */
8101
8205
    POWERPC_DEF_SVR("MPC8545E",
8102
 
                    CPU_POWERPC_MPC8545E,     POWERPC_SVR_8545E,     e500),
 
8206
                    CPU_POWERPC_MPC8545E,     POWERPC_SVR_8545E,     e500v2),
8103
8207
    /* MPC8545E v2.0                                                         */
8104
8208
    POWERPC_DEF_SVR("MPC8545E_v20",
8105
 
                    CPU_POWERPC_MPC8545E_v20, POWERPC_SVR_8545E_v20, e500),
 
8209
                    CPU_POWERPC_MPC8545E_v20, POWERPC_SVR_8545E_v20, e500v2),
8106
8210
    /* MPC8545E v2.1                                                         */
8107
8211
    POWERPC_DEF_SVR("MPC8545E_v21",
8108
 
                    CPU_POWERPC_MPC8545E_v21, POWERPC_SVR_8545E_v21, e500),
 
8212
                    CPU_POWERPC_MPC8545E_v21, POWERPC_SVR_8545E_v21, e500v2),
8109
8213
    /* MPC8547E                                                              */
8110
8214
    POWERPC_DEF_SVR("MPC8547E",
8111
 
                    CPU_POWERPC_MPC8547E,     POWERPC_SVR_8547E,     e500),
 
8215
                    CPU_POWERPC_MPC8547E,     POWERPC_SVR_8547E,     e500v2),
8112
8216
    /* MPC8547E v2.0                                                         */
8113
8217
    POWERPC_DEF_SVR("MPC8547E_v20",
8114
 
                    CPU_POWERPC_MPC8547E_v20, POWERPC_SVR_8547E_v20, e500),
 
8218
                    CPU_POWERPC_MPC8547E_v20, POWERPC_SVR_8547E_v20, e500v2),
8115
8219
    /* MPC8547E v2.1                                                         */
8116
8220
    POWERPC_DEF_SVR("MPC8547E_v21",
8117
 
                    CPU_POWERPC_MPC8547E_v21, POWERPC_SVR_8547E_v21, e500),
 
8221
                    CPU_POWERPC_MPC8547E_v21, POWERPC_SVR_8547E_v21, e500v2),
8118
8222
    /* MPC8548                                                               */
8119
8223
    POWERPC_DEF_SVR("MPC8548",
8120
 
                    CPU_POWERPC_MPC8548,      POWERPC_SVR_8548,      e500),
 
8224
                    CPU_POWERPC_MPC8548,      POWERPC_SVR_8548,      e500v2),
8121
8225
    /* MPC8548 v1.0                                                          */
8122
8226
    POWERPC_DEF_SVR("MPC8548_v10",
8123
 
                    CPU_POWERPC_MPC8548_v10,  POWERPC_SVR_8548_v10,  e500),
 
8227
                    CPU_POWERPC_MPC8548_v10,  POWERPC_SVR_8548_v10,  e500v2),
8124
8228
    /* MPC8548 v1.1                                                          */
8125
8229
    POWERPC_DEF_SVR("MPC8548_v11",
8126
 
                    CPU_POWERPC_MPC8548_v11,  POWERPC_SVR_8548_v11,  e500),
 
8230
                    CPU_POWERPC_MPC8548_v11,  POWERPC_SVR_8548_v11,  e500v2),
8127
8231
    /* MPC8548 v2.0                                                          */
8128
8232
    POWERPC_DEF_SVR("MPC8548_v20",
8129
 
                    CPU_POWERPC_MPC8548_v20,  POWERPC_SVR_8548_v20,  e500),
 
8233
                    CPU_POWERPC_MPC8548_v20,  POWERPC_SVR_8548_v20,  e500v2),
8130
8234
    /* MPC8548 v2.1                                                          */
8131
8235
    POWERPC_DEF_SVR("MPC8548_v21",
8132
 
                    CPU_POWERPC_MPC8548_v21,  POWERPC_SVR_8548_v21,  e500),
 
8236
                    CPU_POWERPC_MPC8548_v21,  POWERPC_SVR_8548_v21,  e500v2),
8133
8237
    /* MPC8548E                                                              */
8134
8238
    POWERPC_DEF_SVR("MPC8548E",
8135
 
                    CPU_POWERPC_MPC8548E,     POWERPC_SVR_8548E,     e500),
 
8239
                    CPU_POWERPC_MPC8548E,     POWERPC_SVR_8548E,     e500v2),
8136
8240
    /* MPC8548E v1.0                                                         */
8137
8241
    POWERPC_DEF_SVR("MPC8548E_v10",
8138
 
                    CPU_POWERPC_MPC8548E_v10, POWERPC_SVR_8548E_v10, e500),
 
8242
                    CPU_POWERPC_MPC8548E_v10, POWERPC_SVR_8548E_v10, e500v2),
8139
8243
    /* MPC8548E v1.1                                                         */
8140
8244
    POWERPC_DEF_SVR("MPC8548E_v11",
8141
 
                    CPU_POWERPC_MPC8548E_v11, POWERPC_SVR_8548E_v11, e500),
 
8245
                    CPU_POWERPC_MPC8548E_v11, POWERPC_SVR_8548E_v11, e500v2),
8142
8246
    /* MPC8548E v2.0                                                         */
8143
8247
    POWERPC_DEF_SVR("MPC8548E_v20",
8144
 
                    CPU_POWERPC_MPC8548E_v20, POWERPC_SVR_8548E_v20, e500),
 
8248
                    CPU_POWERPC_MPC8548E_v20, POWERPC_SVR_8548E_v20, e500v2),
8145
8249
    /* MPC8548E v2.1                                                         */
8146
8250
    POWERPC_DEF_SVR("MPC8548E_v21",
8147
 
                    CPU_POWERPC_MPC8548E_v21, POWERPC_SVR_8548E_v21, e500),
 
8251
                    CPU_POWERPC_MPC8548E_v21, POWERPC_SVR_8548E_v21, e500v2),
8148
8252
    /* MPC8555                                                               */
8149
8253
    POWERPC_DEF_SVR("MPC8555",
8150
 
                    CPU_POWERPC_MPC8555,      POWERPC_SVR_8555,      e500),
 
8254
                    CPU_POWERPC_MPC8555,      POWERPC_SVR_8555,      e500v2),
8151
8255
    /* MPC8555 v1.0                                                          */
8152
8256
    POWERPC_DEF_SVR("MPC8555_v10",
8153
 
                    CPU_POWERPC_MPC8555_v10,  POWERPC_SVR_8555_v10,  e500),
 
8257
                    CPU_POWERPC_MPC8555_v10,  POWERPC_SVR_8555_v10,  e500v2),
8154
8258
    /* MPC8555 v1.1                                                          */
8155
8259
    POWERPC_DEF_SVR("MPC8555_v11",
8156
 
                    CPU_POWERPC_MPC8555_v11,  POWERPC_SVR_8555_v11,  e500),
 
8260
                    CPU_POWERPC_MPC8555_v11,  POWERPC_SVR_8555_v11,  e500v2),
8157
8261
    /* MPC8555E                                                              */
8158
8262
    POWERPC_DEF_SVR("MPC8555E",
8159
 
                    CPU_POWERPC_MPC8555E,     POWERPC_SVR_8555E,     e500),
 
8263
                    CPU_POWERPC_MPC8555E,     POWERPC_SVR_8555E,     e500v2),
8160
8264
    /* MPC8555E v1.0                                                         */
8161
8265
    POWERPC_DEF_SVR("MPC8555E_v10",
8162
 
                    CPU_POWERPC_MPC8555E_v10, POWERPC_SVR_8555E_v10, e500),
 
8266
                    CPU_POWERPC_MPC8555E_v10, POWERPC_SVR_8555E_v10, e500v2),
8163
8267
    /* MPC8555E v1.1                                                         */
8164
8268
    POWERPC_DEF_SVR("MPC8555E_v11",
8165
 
                    CPU_POWERPC_MPC8555E_v11, POWERPC_SVR_8555E_v11, e500),
 
8269
                    CPU_POWERPC_MPC8555E_v11, POWERPC_SVR_8555E_v11, e500v2),
8166
8270
    /* MPC8560                                                               */
8167
8271
    POWERPC_DEF_SVR("MPC8560",
8168
 
                    CPU_POWERPC_MPC8560,      POWERPC_SVR_8560,      e500),
 
8272
                    CPU_POWERPC_MPC8560,      POWERPC_SVR_8560,      e500v2),
8169
8273
    /* MPC8560 v1.0                                                          */
8170
8274
    POWERPC_DEF_SVR("MPC8560_v10",
8171
 
                    CPU_POWERPC_MPC8560_v10,  POWERPC_SVR_8560_v10,  e500),
 
8275
                    CPU_POWERPC_MPC8560_v10,  POWERPC_SVR_8560_v10,  e500v2),
8172
8276
    /* MPC8560 v2.0                                                          */
8173
8277
    POWERPC_DEF_SVR("MPC8560_v20",
8174
 
                    CPU_POWERPC_MPC8560_v20,  POWERPC_SVR_8560_v20,  e500),
 
8278
                    CPU_POWERPC_MPC8560_v20,  POWERPC_SVR_8560_v20,  e500v2),
8175
8279
    /* MPC8560 v2.1                                                          */
8176
8280
    POWERPC_DEF_SVR("MPC8560_v21",
8177
 
                    CPU_POWERPC_MPC8560_v21,  POWERPC_SVR_8560_v21,  e500),
 
8281
                    CPU_POWERPC_MPC8560_v21,  POWERPC_SVR_8560_v21,  e500v2),
8178
8282
    /* MPC8567                                                               */
8179
8283
    POWERPC_DEF_SVR("MPC8567",
8180
 
                    CPU_POWERPC_MPC8567,      POWERPC_SVR_8567,      e500),
 
8284
                    CPU_POWERPC_MPC8567,      POWERPC_SVR_8567,      e500v2),
8181
8285
    /* MPC8567E                                                              */
8182
8286
    POWERPC_DEF_SVR("MPC8567E",
8183
 
                    CPU_POWERPC_MPC8567E,     POWERPC_SVR_8567E,     e500),
 
8287
                    CPU_POWERPC_MPC8567E,     POWERPC_SVR_8567E,     e500v2),
8184
8288
    /* MPC8568                                                               */
8185
8289
    POWERPC_DEF_SVR("MPC8568",
8186
 
                    CPU_POWERPC_MPC8568,      POWERPC_SVR_8568,      e500),
 
8290
                    CPU_POWERPC_MPC8568,      POWERPC_SVR_8568,      e500v2),
8187
8291
    /* MPC8568E                                                              */
8188
8292
    POWERPC_DEF_SVR("MPC8568E",
8189
 
                    CPU_POWERPC_MPC8568E,     POWERPC_SVR_8568E,     e500),
 
8293
                    CPU_POWERPC_MPC8568E,     POWERPC_SVR_8568E,     e500v2),
8190
8294
    /* MPC8572                                                               */
8191
8295
    POWERPC_DEF_SVR("MPC8572",
8192
 
                    CPU_POWERPC_MPC8572,      POWERPC_SVR_8572,      e500),
 
8296
                    CPU_POWERPC_MPC8572,      POWERPC_SVR_8572,      e500v2),
8193
8297
    /* MPC8572E                                                              */
8194
8298
    POWERPC_DEF_SVR("MPC8572E",
8195
 
                    CPU_POWERPC_MPC8572E,     POWERPC_SVR_8572E,     e500),
 
8299
                    CPU_POWERPC_MPC8572E,     POWERPC_SVR_8572E,     e500v2),
8196
8300
    /* e600 family                                                           */
8197
8301
    /* PowerPC e600 core                                                     */
8198
8302
    POWERPC_DEF("e600",          CPU_POWERPC_e600,                   7400),
8941
9045
#include <stdlib.h>
8942
9046
#include <string.h>
8943
9047
 
8944
 
int fflush (FILE *stream);
8945
 
 
8946
9048
/* Opcode types */
8947
9049
enum {
8948
9050
    PPC_DIRECT   = 0, /* Opcode routine        */
8974
9076
    opc_handler_t **tmp;
8975
9077
 
8976
9078
    tmp = malloc(0x20 * sizeof(opc_handler_t));
8977
 
    if (tmp == NULL)
8978
 
        return -1;
8979
9079
    fill_new_table(tmp, 0x20);
8980
9080
    table[idx] = (opc_handler_t *)((unsigned long)tmp | PPC_INDIRECT);
8981
9081
 
9159
9259
static void dump_ppc_insns (CPUPPCState *env)
9160
9260
{
9161
9261
    opc_handler_t **table, *handler;
9162
 
    const unsigned char *p, *q;
 
9262
    const char *p, *q;
9163
9263
    uint8_t opc1, opc2, opc3;
9164
9264
 
9165
9265
    printf("Instructions set:\n");
9228
9328
}
9229
9329
#endif
9230
9330
 
 
9331
static int gdb_get_float_reg(CPUState *env, uint8_t *mem_buf, int n)
 
9332
{
 
9333
    if (n < 32) {
 
9334
        stfq_p(mem_buf, env->fpr[n]);
 
9335
        return 8;
 
9336
    }
 
9337
    if (n == 32) {
 
9338
        /* FPSCR not implemented  */
 
9339
        memset(mem_buf, 0, 4);
 
9340
        return 4;
 
9341
    }
 
9342
    return 0;
 
9343
}
 
9344
 
 
9345
static int gdb_set_float_reg(CPUState *env, uint8_t *mem_buf, int n)
 
9346
{
 
9347
    if (n < 32) {
 
9348
        env->fpr[n] = ldfq_p(mem_buf);
 
9349
        return 8;
 
9350
    }
 
9351
    if (n == 32) {
 
9352
        /* FPSCR not implemented  */
 
9353
        return 4;
 
9354
    }
 
9355
    return 0;
 
9356
}
 
9357
 
 
9358
static int gdb_get_avr_reg(CPUState *env, uint8_t *mem_buf, int n)
 
9359
{
 
9360
    if (n < 32) {
 
9361
#ifdef WORDS_BIGENDIAN
 
9362
        stq_p(mem_buf, env->avr[n].u64[0]);
 
9363
        stq_p(mem_buf+8, env->avr[n].u64[1]);
 
9364
#else
 
9365
        stq_p(mem_buf, env->avr[n].u64[1]);
 
9366
        stq_p(mem_buf+8, env->avr[n].u64[0]);
 
9367
#endif
 
9368
        return 16;
 
9369
    }
 
9370
    if (n == 33) {
 
9371
        stl_p(mem_buf, env->vscr);
 
9372
        return 4;
 
9373
    }
 
9374
    if (n == 34) {
 
9375
        stl_p(mem_buf, (uint32_t)env->spr[SPR_VRSAVE]);
 
9376
        return 4;
 
9377
    }
 
9378
    return 0;
 
9379
}
 
9380
 
 
9381
static int gdb_set_avr_reg(CPUState *env, uint8_t *mem_buf, int n)
 
9382
{
 
9383
    if (n < 32) {
 
9384
#ifdef WORDS_BIGENDIAN
 
9385
        env->avr[n].u64[0] = ldq_p(mem_buf);
 
9386
        env->avr[n].u64[1] = ldq_p(mem_buf+8);
 
9387
#else
 
9388
        env->avr[n].u64[1] = ldq_p(mem_buf);
 
9389
        env->avr[n].u64[0] = ldq_p(mem_buf+8);
 
9390
#endif
 
9391
        return 16;
 
9392
    }
 
9393
    if (n == 33) {
 
9394
        env->vscr = ldl_p(mem_buf);
 
9395
        return 4;
 
9396
    }
 
9397
    if (n == 34) {
 
9398
        env->spr[SPR_VRSAVE] = (target_ulong)ldl_p(mem_buf);
 
9399
        return 4;
 
9400
    }
 
9401
    return 0;
 
9402
}
 
9403
 
 
9404
static int gdb_get_spe_reg(CPUState *env, uint8_t *mem_buf, int n)
 
9405
{
 
9406
    if (n < 32) {
 
9407
#if defined(TARGET_PPC64)
 
9408
        stl_p(mem_buf, env->gpr[n] >> 32);
 
9409
#else
 
9410
        stl_p(mem_buf, env->gprh[n]);
 
9411
#endif
 
9412
        return 4;
 
9413
    }
 
9414
    if (n == 33) {
 
9415
        stq_p(mem_buf, env->spe_acc);
 
9416
        return 8;
 
9417
    }
 
9418
    if (n == 34) {
 
9419
        /* SPEFSCR not implemented */
 
9420
        memset(mem_buf, 0, 4);
 
9421
        return 4;
 
9422
    }
 
9423
    return 0;
 
9424
}
 
9425
 
 
9426
static int gdb_set_spe_reg(CPUState *env, uint8_t *mem_buf, int n)
 
9427
{
 
9428
    if (n < 32) {
 
9429
#if defined(TARGET_PPC64)
 
9430
        target_ulong lo = (uint32_t)env->gpr[n];
 
9431
        target_ulong hi = (target_ulong)ldl_p(mem_buf) << 32;
 
9432
        env->gpr[n] = lo | hi;
 
9433
#else
 
9434
        env->gprh[n] = ldl_p(mem_buf);
 
9435
#endif
 
9436
        return 4;
 
9437
    }
 
9438
    if (n == 33) {
 
9439
        env->spe_acc = ldq_p(mem_buf);
 
9440
        return 8;
 
9441
    }
 
9442
    if (n == 34) {
 
9443
        /* SPEFSCR not implemented */
 
9444
        return 4;
 
9445
    }
 
9446
    return 0;
 
9447
}
 
9448
 
9231
9449
int cpu_ppc_register_internal (CPUPPCState *env, const ppc_def_t *def)
9232
9450
{
9233
9451
    env->msr_mask = def->msr_mask;
9240
9458
    if (create_ppc_opcodes(env, def) < 0)
9241
9459
        return -1;
9242
9460
    init_ppc_proc(env, def);
 
9461
 
 
9462
    if (def->insns_flags & PPC_FLOAT) {
 
9463
        gdb_register_coprocessor(env, gdb_get_float_reg, gdb_set_float_reg,
 
9464
                                 33, "power-fpu.xml", 0);
 
9465
    }
 
9466
    if (def->insns_flags & PPC_ALTIVEC) {
 
9467
        gdb_register_coprocessor(env, gdb_get_avr_reg, gdb_set_avr_reg,
 
9468
                                 34, "power-altivec.xml", 0);
 
9469
    }
 
9470
    if (def->insns_flags & PPC_SPE) {
 
9471
        gdb_register_coprocessor(env, gdb_get_spe_reg, gdb_set_spe_reg,
 
9472
                                 34, "power-spe.xml", 0);
 
9473
    }
 
9474
 
9243
9475
#if defined(PPC_DUMP_CPU)
9244
9476
    {
9245
 
        const unsigned char *mmu_model, *excp_model, *bus_model;
 
9477
        const char *mmu_model, *excp_model, *bus_model;
9246
9478
        switch (env->mmu_model) {
9247
9479
        case POWERPC_MMU_32B:
9248
9480
            mmu_model = "PowerPC 32";
9412
9644
    int i, best, match, best_match, max;
9413
9645
 
9414
9646
    ret = NULL;
9415
 
    max = sizeof(ppc_defs) / sizeof(ppc_def_t);
 
9647
    max = ARRAY_SIZE(ppc_defs);
9416
9648
    best = -1;
9417
9649
    pvr_rev = pvr & 0xFFFF;
9418
9650
    /* We want all specified bits to match */
9445
9677
 
9446
9678
#include <ctype.h>
9447
9679
 
9448
 
const ppc_def_t *cpu_ppc_find_by_name (const unsigned char *name)
 
9680
const ppc_def_t *cpu_ppc_find_by_name (const char *name)
9449
9681
{
9450
9682
    const ppc_def_t *ret;
9451
 
    const unsigned char *p;
 
9683
    const char *p;
9452
9684
    int i, max, len;
9453
9685
 
9454
9686
    /* Check if the given name is a PVR */
9460
9692
        p = name;
9461
9693
    check_pvr:
9462
9694
        for (i = 0; i < 8; i++) {
9463
 
            if (!isxdigit(*p++))
 
9695
            if (!qemu_isxdigit(*p++))
9464
9696
                break;
9465
9697
        }
9466
9698
        if (i == 8)
9467
9699
            return ppc_find_by_pvr(strtoul(name, NULL, 16));
9468
9700
    }
9469
9701
    ret = NULL;
9470
 
    max = sizeof(ppc_defs) / sizeof(ppc_def_t);
 
9702
    max = ARRAY_SIZE(ppc_defs);
9471
9703
    for (i = 0; i < max; i++) {
9472
9704
        if (strcasecmp(name, ppc_defs[i].name) == 0) {
9473
9705
            ret = &ppc_defs[i];
9482
9714
{
9483
9715
    int i, max;
9484
9716
 
9485
 
    max = sizeof(ppc_defs) / sizeof(ppc_def_t);
 
9717
    max = ARRAY_SIZE(ppc_defs);
9486
9718
    for (i = 0; i < max; i++) {
9487
9719
        (*cpu_fprintf)(f, "PowerPC %-16s PVR %08x\n",
9488
9720
                       ppc_defs[i].name, ppc_defs[i].pvr);