← Back to branch summary

~fboudra/qemu-linaro/new-upstream-release-1.2.0-2012.09-0ubuntu1

« back to all changes in this revision

Viewing changes to target-unicore32/helper.c

  • Committer: Fathi Boudra
  • Author(s): Fathi Boudra
  • Date: 2012-08-21 06:47:11 UTC
  • mfrom: (0.1.16)
  • Revision ID: fathi.boudra@linaro.org-20120821064711-7yxmubp2v8a44xce
Tags: 1.1.50-2012.08-0ubuntu1
https://launchpad.net/bugs/1030588
https://launchpad.net/bugs/1030594
* New upstream release.
  - support emulated systems with more than 2G of memory. (LP: #1030588)
* Drop powerpc-missing-include.patch - merged upstream.
* Update debian/control: 
  - drop perl build dependency.
  - add libfdt-dev build dependency.
* Update debian/qemu-keymaps.install file.
* Update debian/rules:
  - update QEMU_CPU for ARM architecture: armv4l -> armv7l.
  - update conf_audio_drv: default to PulseAudio since PA is the default on
    Ubuntu.
  - enable KVM on ARM architecture.
  - enable flat device tree support (--enable-fdt). (LP: #1030594)

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-unicore32/helper.c
4
4
 * This program is free software; you can redistribute it and/or modify
5
5
 * it under the terms of the GNU General Public License version 2 as
6
6
 * published by the Free Software Foundation.
 
7
 *
 
8
 * Contributions from 2012-04-01 on are considered under GPL version 2,
 
9
 * or (at your option) any later version.
7
10
 */
8
11
 
9
12
#include "cpu.h"
11
14
#include "helper.h"
12
15
#include "host-utils.h"
13
16
 
14
 
static inline void set_feature(CPUState *env, int feature)
15
 
{
16
 
    env->features |= feature;
17
 
}
18
 
 
19
 
struct uc32_cpu_t {
20
 
    uint32_t id;
21
 
    const char *name;
22
 
};
23
 
 
24
 
static const struct uc32_cpu_t uc32_cpu_names[] = {
25
 
    { UC32_CPUID_UCV2, "UniCore-II"},
26
 
    { UC32_CPUID_ANY, "any"},
27
 
    { 0, NULL}
28
 
};
29
 
 
30
 
/* return 0 if not found */
31
 
static uint32_t uc32_cpu_find_by_name(const char *name)
32
 
{
33
 
    int i;
34
 
    uint32_t id;
35
 
 
36
 
    id = 0;
37
 
    for (i = 0; uc32_cpu_names[i].name; i++) {
38
 
        if (strcmp(name, uc32_cpu_names[i].name) == 0) {
39
 
            id = uc32_cpu_names[i].id;
40
 
            break;
41
 
        }
42
 
    }
43
 
    return id;
44
 
}
45
 
 
46
 
CPUState *uc32_cpu_init(const char *cpu_model)
47
 
{
48
 
    CPUState *env;
49
 
    uint32_t id;
 
17
CPUUniCore32State *uc32_cpu_init(const char *cpu_model)
 
18
{
 
19
    UniCore32CPU *cpu;
 
20
    CPUUniCore32State *env;
50
21
    static int inited = 1;
51
22
 
52
 
    env = g_malloc0(sizeof(CPUState));
53
 
    cpu_exec_init(env);
54
 
 
55
 
    id = uc32_cpu_find_by_name(cpu_model);
56
 
    switch (id) {
57
 
    case UC32_CPUID_UCV2:
58
 
        set_feature(env, UC32_HWCAP_CMOV);
59
 
        set_feature(env, UC32_HWCAP_UCF64);
60
 
        env->ucf64.xregs[UC32_UCF64_FPSCR] = 0;
61
 
        env->cp0.c0_cachetype = 0x1dd20d2;
62
 
        env->cp0.c1_sys = 0x00090078;
63
 
        break;
64
 
    case UC32_CPUID_ANY: /* For userspace emulation.  */
65
 
        set_feature(env, UC32_HWCAP_CMOV);
66
 
        set_feature(env, UC32_HWCAP_UCF64);
67
 
        break;
68
 
    default:
69
 
        cpu_abort(env, "Bad CPU ID: %x\n", id);
 
23
    if (object_class_by_name(cpu_model) == NULL) {
 
24
        return NULL;
70
25
    }
71
 
 
72
 
    env->cpu_model_str = cpu_model;
73
 
    env->cp0.c0_cpuid = id;
74
 
    env->uncached_asr = ASR_MODE_USER;
75
 
    env->regs[31] = 0;
 
26
    cpu = UNICORE32_CPU(object_new(cpu_model));
 
27
    env = &cpu->env;
76
28
 
77
29
    if (inited) {
78
30
        inited = 0;
79
31
        uc32_translate_init();
80
32
    }
81
33
 
82
 
    tlb_flush(env, 1);
83
34
    qemu_init_vcpu(env);
84
35
    return env;
85
36
}
94
45
    return clz32(x);
95
46
}
96
47
 
97
 
void do_interrupt(CPUState *env)
 
48
void do_interrupt(CPUUniCore32State *env)
98
49
{
99
50
    env->exception_index = -1;
100
51
}
101
52
 
102
 
int uc32_cpu_handle_mmu_fault(CPUState *env, target_ulong address, int rw,
 
53
int uc32_cpu_handle_mmu_fault(CPUUniCore32State *env, target_ulong address, int rw,
103
54
                              int mmu_idx)
104
55
{
105
56
    env->exception_index = UC32_EXCP_TRAP;
108
59
}
109
60
 
110
61
/* These should probably raise undefined insn exceptions.  */
111
 
void HELPER(set_cp)(CPUState *env, uint32_t insn, uint32_t val)
 
62
void HELPER(set_cp)(CPUUniCore32State *env, uint32_t insn, uint32_t val)
112
63
{
113
64
    int op1 = (insn >> 8) & 0xf;
114
65
    cpu_abort(env, "cp%i insn %08x\n", op1, insn);
115
66
    return;
116
67
}
117
68
 
118
 
uint32_t HELPER(get_cp)(CPUState *env, uint32_t insn)
 
69
uint32_t HELPER(get_cp)(CPUUniCore32State *env, uint32_t insn)
119
70
{
120
71
    int op1 = (insn >> 8) & 0xf;
121
72
    cpu_abort(env, "cp%i insn %08x\n", op1, insn);
122
73
    return 0;
123
74
}
124
75
 
125
 
void HELPER(set_cp0)(CPUState *env, uint32_t insn, uint32_t val)
 
76
void HELPER(set_cp0)(CPUUniCore32State *env, uint32_t insn, uint32_t val)
126
77
{
127
78
    cpu_abort(env, "cp0 insn %08x\n", insn);
128
79
}
129
80
 
130
 
uint32_t HELPER(get_cp0)(CPUState *env, uint32_t insn)
 
81
uint32_t HELPER(get_cp0)(CPUUniCore32State *env, uint32_t insn)
131
82
{
132
83
    cpu_abort(env, "cp0 insn %08x\n", insn);
133
84
    return 0;
134
85
}
135
86
 
136
 
void switch_mode(CPUState *env, int mode)
 
87
void switch_mode(CPUUniCore32State *env, int mode)
137
88
{
138
89
    if (mode != ASR_MODE_USER) {
139
90
        cpu_abort(env, "Tried to switch out of user mode\n");
140
91
    }
141
92
}
142
93
 
143
 
void HELPER(set_r29_banked)(CPUState *env, uint32_t mode, uint32_t val)
 
94
void HELPER(set_r29_banked)(CPUUniCore32State *env, uint32_t mode, uint32_t val)
144
95
{
145
96
    cpu_abort(env, "banked r29 write\n");
146
97
}
147
98
 
148
 
uint32_t HELPER(get_r29_banked)(CPUState *env, uint32_t mode)
 
99
uint32_t HELPER(get_r29_banked)(CPUUniCore32State *env, uint32_t mode)
149
100
{
150
101
    cpu_abort(env, "banked r29 read\n");
151
102
    return 0;
178
129
    return target_bits;
179
130
}
180
131
 
181
 
uint32_t HELPER(ucf64_get_fpscr)(CPUState *env)
 
132
uint32_t HELPER(ucf64_get_fpscr)(CPUUniCore32State *env)
182
133
{
183
134
    int i;
184
135
    uint32_t fpscr;
212
163
    return host_bits;
213
164
}
214
165
 
215
 
void HELPER(ucf64_set_fpscr)(CPUState *env, uint32_t val)
 
166
void HELPER(ucf64_set_fpscr)(CPUUniCore32State *env, uint32_t val)
216
167
{
217
168
    int i;
218
169
    uint32_t changed;
246
197
    set_float_exception_flags(i, &env->ucf64.fp_status);
247
198
}
248
199
 
249
 
float32 HELPER(ucf64_adds)(float32 a, float32 b, CPUState *env)
 
200
float32 HELPER(ucf64_adds)(float32 a, float32 b, CPUUniCore32State *env)
250
201
{
251
202
    return float32_add(a, b, &env->ucf64.fp_status);
252
203
}
253
204
 
254
 
float64 HELPER(ucf64_addd)(float64 a, float64 b, CPUState *env)
 
205
float64 HELPER(ucf64_addd)(float64 a, float64 b, CPUUniCore32State *env)
255
206
{
256
207
    return float64_add(a, b, &env->ucf64.fp_status);
257
208
}
258
209
 
259
 
float32 HELPER(ucf64_subs)(float32 a, float32 b, CPUState *env)
 
210
float32 HELPER(ucf64_subs)(float32 a, float32 b, CPUUniCore32State *env)
260
211
{
261
212
    return float32_sub(a, b, &env->ucf64.fp_status);
262
213
}
263
214
 
264
 
float64 HELPER(ucf64_subd)(float64 a, float64 b, CPUState *env)
 
215
float64 HELPER(ucf64_subd)(float64 a, float64 b, CPUUniCore32State *env)
265
216
{
266
217
    return float64_sub(a, b, &env->ucf64.fp_status);
267
218
}
268
219
 
269
 
float32 HELPER(ucf64_muls)(float32 a, float32 b, CPUState *env)
 
220
float32 HELPER(ucf64_muls)(float32 a, float32 b, CPUUniCore32State *env)
270
221
{
271
222
    return float32_mul(a, b, &env->ucf64.fp_status);
272
223
}
273
224
 
274
 
float64 HELPER(ucf64_muld)(float64 a, float64 b, CPUState *env)
 
225
float64 HELPER(ucf64_muld)(float64 a, float64 b, CPUUniCore32State *env)
275
226
{
276
227
    return float64_mul(a, b, &env->ucf64.fp_status);
277
228
}
278
229
 
279
 
float32 HELPER(ucf64_divs)(float32 a, float32 b, CPUState *env)
 
230
float32 HELPER(ucf64_divs)(float32 a, float32 b, CPUUniCore32State *env)
280
231
{
281
232
    return float32_div(a, b, &env->ucf64.fp_status);
282
233
}
283
234
 
284
 
float64 HELPER(ucf64_divd)(float64 a, float64 b, CPUState *env)
 
235
float64 HELPER(ucf64_divd)(float64 a, float64 b, CPUUniCore32State *env)
285
236
{
286
237
    return float64_div(a, b, &env->ucf64.fp_status);
287
238
}
307
258
}
308
259
 
309
260
/* XXX: check quiet/signaling case */
310
 
void HELPER(ucf64_cmps)(float32 a, float32 b, uint32_t c, CPUState *env)
 
261
void HELPER(ucf64_cmps)(float32 a, float32 b, uint32_t c, CPUUniCore32State *env)
311
262
{
312
263
    int flag;
313
264
    flag = float32_compare_quiet(a, b, &env->ucf64.fp_status);
355
306
                    | (env->ucf64.xregs[UC32_UCF64_FPSCR] & 0x0fffffff);
356
307
}
357
308
 
358
 
void HELPER(ucf64_cmpd)(float64 a, float64 b, uint32_t c, CPUState *env)
 
309
void HELPER(ucf64_cmpd)(float64 a, float64 b, uint32_t c, CPUUniCore32State *env)
359
310
{
360
311
    int flag;
361
312
    flag = float64_compare_quiet(a, b, &env->ucf64.fp_status);
449
400
}
450
401
 
451
402
/* Integer to float conversion.  */
452
 
float32 HELPER(ucf64_si2sf)(float32 x, CPUState *env)
 
403
float32 HELPER(ucf64_si2sf)(float32 x, CPUUniCore32State *env)
453
404
{
454
405
    return int32_to_float32(ucf64_stoi(x), &env->ucf64.fp_status);
455
406
}
456
407
 
457
 
float64 HELPER(ucf64_si2df)(float32 x, CPUState *env)
 
408
float64 HELPER(ucf64_si2df)(float32 x, CPUUniCore32State *env)
458
409
{
459
410
    return int32_to_float64(ucf64_stoi(x), &env->ucf64.fp_status);
460
411
}
461
412
 
462
413
/* Float to integer conversion.  */
463
 
float32 HELPER(ucf64_sf2si)(float32 x, CPUState *env)
 
414
float32 HELPER(ucf64_sf2si)(float32 x, CPUUniCore32State *env)
464
415
{
465
416
    return ucf64_itos(float32_to_int32(x, &env->ucf64.fp_status));
466
417
}
467
418
 
468
 
float32 HELPER(ucf64_df2si)(float64 x, CPUState *env)
 
419
float32 HELPER(ucf64_df2si)(float64 x, CPUUniCore32State *env)
469
420
{
470
421
    return ucf64_itos(float64_to_int32(x, &env->ucf64.fp_status));
471
422
}
472
423
 
473
424
/* floating point conversion */
474
 
float64 HELPER(ucf64_sf2df)(float32 x, CPUState *env)
 
425
float64 HELPER(ucf64_sf2df)(float32 x, CPUUniCore32State *env)
475
426
{
476
427
    return float32_to_float64(x, &env->ucf64.fp_status);
477
428
}
478
429
 
479
 
float32 HELPER(ucf64_df2sf)(float64 x, CPUState *env)
 
430
float32 HELPER(ucf64_df2sf)(float64 x, CPUUniCore32State *env)
480
431
{
481
432
    return float64_to_float32(x, &env->ucf64.fp_status);
482
433
}