← Back to branch summary

~ubuntu-branches/ubuntu/lucid/skyeye/lucid

« back to all changes in this revision

Viewing changes to arch/arm/dbct/arm2x86_coproc.c

  • Committer: Bazaar Package Importer
  • Author(s): Yu Guanghui
  • Date: 2006-08-09 16:30:44 UTC
  • Revision ID: james.westby@ubuntu.com-20060809163044-6efqjm0t2stau23w
Tags: upstream-1.2.0rc8
Import upstream version 1.2.0rc8

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/arm/dbct/arm2x86_coproc.c
 
1
/* 
 
2
This program is free software; you can redistribute it and/or modify
 
3
it under the terms of the GNU General Public License as published by
 
4
the Free Software Foundation; either version 2, or (at your option)
 
5
any later version.
 
6
 
 
7
This program is distributed in the hope that it will be useful,
 
8
but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
GNU General Public License for more details.
 
11
 
 
12
You should have received a copy of the GNU General Public License along
 
13
with this program; if not, write to the Free Software Foundation, Inc.,
 
14
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
15
 
 
16
/*
 
17
 * author teawater <c7code-uc@yahoo.com.cn> <teawater@gmail.com>
 
18
 */
 
19
 
 
20
//koodailar add for mingw 2005.12.18 ----------------------------------------
 
21
#ifdef __MINGW32__
 
22
#include "arch/arm/common/armdefs.h"
 
23
#else
 
24
#include "armdefs.h"
 
25
#endif
 
26
// end ----------------------------------------------------------------------
 
27
#include "arm2x86_self.h"
 
28
 
 
29
//--------------------------------------------------------------------------------------------------
 
30
 
 
31
void
 
32
tea_ldc (ARMul_State * state, uint32_t insn, uint32_t address)
 
33
{
 
34
        ARMword cp_num = (insn >> 8) & 0xf;
 
35
        unsigned cpab;
 
36
        ARMword data;
 
37
 
 
38
        if (!CP_ACCESS_ALLOWED (state, cp_num)) {
 
39
                state->trap = TRAP_INSN_UNDEF;
 
40
                return;
 
41
        }
 
42
        cpab = (state->LDC[cp_num]) (state, ARMul_FIRST, insn, 0);
 
43
        while (cpab == ARMul_BUSY) {
 
44
                //XXX teawater:howto deal with it ?
 
45
                //ARMul_Icycles(state, 1, 0);
 
46
                if (arm2x86_exception (state)) {
 
47
                        cpab = (state->LDC[cp_num]) (state, ARMul_INTERRUPT,
 
48
                                                     insn, 0);
 
49
                        return;
 
50
                }
 
51
                cpab = (state->LDC[cp_num]) (state, ARMul_BUSY, insn, 0);
 
52
        }
 
53
        if (cpab == ARMul_CANT) {
 
54
                state->trap = TRAP_INSN_UNDEF;
 
55
                return;
 
56
        }
 
57
        cpab = (state->LDC[cp_num]) (state, ARMul_TRANSFER, insn, 0);
 
58
        //XXX teawater:howto deal with BUSUSEDINCPCN ?
 
59
        do {
 
60
                data = ARMul_ReadWord (state, address);
 
61
                if (state->abortSig != LOW) {
 
62
                        state->trap = TRAP_DATA_ABORT;
 
63
                        return;
 
64
                }
 
65
                cpab = (state->LDC[cp_num]) (state, ARMul_DATA, insn, data);
 
66
                address += 4;
 
67
        } while (cpab == ARMul_INC);
 
68
}
 
69
 
 
70
void
 
71
tea_stc (ARMul_State * state, uint32_t insn, uint32_t address)
 
72
{
 
73
        ARMword cp_num = (insn >> 8) & 0xf;
 
74
        unsigned cpab;
 
75
        ARMword data;
 
76
 
 
77
        if (!CP_ACCESS_ALLOWED (state, cp_num)) {
 
78
                state->trap = TRAP_INSN_UNDEF;
 
79
                return;
 
80
        }
 
81
        cpab = (state->STC[cp_num]) (state, ARMul_FIRST, insn, &data);
 
82
        while (cpab == ARMul_BUSY) {
 
83
                //XXX teawater:howto deal with it ?
 
84
                //ARMul_Icycles(state, 1, 0);
 
85
                if (arm2x86_exception (state)) {
 
86
                        cpab = (state->STC[cp_num]) (state, ARMul_INTERRUPT,
 
87
                                                     insn, 0);
 
88
                        return;
 
89
                }
 
90
                cpab = (state->STC[cp_num]) (state, ARMul_BUSY, insn, &data);
 
91
        }
 
92
        if (cpab == ARMul_CANT) {
 
93
                state->trap = TRAP_INSN_UNDEF;
 
94
                return;
 
95
        }
 
96
        //XXX teawater:howto deal with BUSUSEDINCPCN ?
 
97
        do {
 
98
                cpab = (state->STC[cp_num]) (state, ARMul_DATA, insn, &data);
 
99
                ARMul_WriteWord (state, address, data);
 
100
                if (state->abortSig != LOW) {
 
101
                        state->trap = TRAP_DATA_ABORT;
 
102
                        return;
 
103
                }
 
104
                address += 4;
 
105
        } while (cpab == ARMul_INC);
 
106
}
 
107
 
 
108
void
 
109
tea_mrc (ARMul_State * state, uint32_t insn, uint32_t cp_num)
 
110
{
 
111
        unsigned cpab;
 
112
        ARMword result = 0;
 
113
        ARMword rd;
 
114
 
 
115
        if (!CP_ACCESS_ALLOWED (state, cp_num)) {
 
116
                state->trap = TRAP_INSN_UNDEF;
 
117
                return;
 
118
        }
 
119
        cpab = (state->MRC[cp_num]) (state, ARMul_FIRST, insn, &result);
 
120
        while (cpab == ARMul_BUSY) {
 
121
                //XXX teawater:howto deal with it ?
 
122
                //ARMul_Icycles(state, 1, 0);
 
123
                if (arm2x86_exception (state)) {
 
124
                        cpab = (state->MRC[cp_num]) (state, ARMul_INTERRUPT,
 
125
                                                     insn, 0);
 
126
                        return;
 
127
                }
 
128
                cpab = (state->MRC[cp_num]) (state, ARMul_BUSY, insn,
 
129
                                             &result);
 
130
        }
 
131
        if (cpab == ARMul_CANT) {
 
132
                state->trap = TRAP_INSN_UNDEF;
 
133
                return;
 
134
        }
 
135
        //XXX teawater:howto deal with BUSUSEDINCPCN and so on ?
 
136
        rd = (insn >> 12) & 0xf;
 
137
        if (rd == 15) {
 
138
                st->Reg[15] = (result & (~3)) + 4;
 
139
                state->trap = TRAP_SET_R15;
 
140
        }
 
141
        else {
 
142
                state->Reg[rd] = result;
 
143
        }
 
144
}
 
145
 
 
146
void
 
147
tea_mcr (ARMul_State * state, uint32_t insn, uint32_t cp_num)
 
148
{
 
149
        unsigned cpab;
 
150
        ARMword source;
 
151
 
 
152
        if (!CP_ACCESS_ALLOWED (state, cp_num)) {
 
153
                state->trap = TRAP_INSN_UNDEF;
 
154
                return;
 
155
        }
 
156
        source = state->Reg[(insn >> 12) & 0xf];
 
157
        cpab = (state->MCR[cp_num]) (state, ARMul_FIRST, insn, source);
 
158
        while (cpab == ARMul_BUSY) {
 
159
                //XXX teawater:howto deal with it ?
 
160
                //ARMul_Icycles(state, 1, 0);
 
161
                if (arm2x86_exception (state)) {
 
162
                        cpab = (state->MCR[cp_num]) (state, ARMul_INTERRUPT,
 
163
                                                     insn, 0);
 
164
                        return;
 
165
                }
 
166
                cpab = (state->MCR[cp_num]) (state, ARMul_BUSY, insn, source);
 
167
        }
 
168
        if (cpab == ARMul_CANT) {
 
169
                state->trap = TRAP_INSN_UNDEF;
 
170
                return;
 
171
        }
 
172
        //XXX teawater:howto deal with BUSUSEDINCPCN and so on ?
 
173
}
 
174
 
 
175
void
 
176
tea_cdp (ARMul_State * state, uint32_t insn, uint32_t cp_num)
 
177
{
 
178
        unsigned cpab;
 
179
 
 
180
        if (!CP_ACCESS_ALLOWED (state, cp_num)) {
 
181
                state->trap = TRAP_INSN_UNDEF;
 
182
                return;
 
183
        }
 
184
        cpab = (state->CDP[cp_num]) (state, ARMul_FIRST, insn);
 
185
        while (cpab == ARMul_BUSY) {
 
186
                //XXX teawater:howto deal with it ?
 
187
                //ARMul_Icycles(state, 1, 0);
 
188
                if (arm2x86_exception (state)) {
 
189
                        cpab = (state->CDP[cp_num]) (state, ARMul_INTERRUPT,
 
190
                                                     insn);
 
191
                        return;
 
192
                }
 
193
                cpab = (state->CDP[cp_num]) (state, ARMul_BUSY, insn);
 
194
        }
 
195
        if (cpab == ARMul_CANT) {
 
196
                state->trap = TRAP_INSN_UNDEF;
 
197
                return;
 
198
        }
 
199
        //XXX teawater:howto deal with BUSUSEDINCPCN and so on ?
 
200
}
 
201
 
 
202
//teawater add for xscale(arm v5) 2005.09.12------------------------------------
 
203
uint8_t *
 
204
get_op_mar_T0_T1 (int *len)
 
205
{
 
206
        unsigned int begin = 0, end = 0;
 
207
 
 
208
        OP_BEGIN ("get_op_mar_T0_T1");
 
209
        if (T1 & 0x80) {
 
210
                T1 |= 0xffffff00;
 
211
        }
 
212
        else {
 
213
                T1 &= 0xff;
 
214
        }
 
215
        st->Accumulator = (ARMdword) T0 + (((ARMdword) T1) << 32);
 
216
        OP_END ("get_op_mar_T0_T1");
 
217
        *len = end - begin;
 
218
 
 
219
        return ((uint8_t *) begin);
 
220
}
 
221
 
 
222
uint8_t *
 
223
get_op_mra_T0_T1 (int *len)
 
224
{
 
225
        unsigned int begin = 0, end = 0;
 
226
 
 
227
        OP_BEGIN ("get_op_mra_T0_T1");
 
228
        T0 = (uint32_t) (st->Accumulator & 0xffffffff);
 
229
        T1 = ((uint32_t) (st->Accumulator >> 32)) & 0xff;
 
230
        if (T1 & 0x80) {
 
231
                T1 |= 0xffffff00;
 
232
        }
 
233
        OP_END ("get_op_mra_T0_T1");
 
234
        *len = end - begin;
 
235
 
 
236
        return ((uint8_t *) begin);
 
237
}
 
238
 
 
239
uint8_t *
 
240
get_op_mia_T0_T1 (int *len)
 
241
{
 
242
        unsigned int begin = 0, end = 0;
 
243
 
 
244
        OP_BEGIN ("get_op_mia_T0_T1");
 
245
        if (T1 & 0x80) {
 
246
                T1 |= 0xffffff00;
 
247
        }
 
248
        else {
 
249
                T1 &= 0xff;
 
250
        }
 
251
        st->Accumulator += (ARMdword) T0 + (((ARMdword) T1) << 32);
 
252
        OP_END ("get_op_mia_T0_T1");
 
253
        *len = end - begin;
 
254
 
 
255
        return ((uint8_t *) begin);
 
256
}
 
257
 
 
258
uint8_t *
 
259
get_op_miaph_T0_T1 (int *len)
 
260
{
 
261
        unsigned int begin = 0, end = 0;
 
262
 
 
263
        OP_BEGIN ("get_op_miaph_T0_T1");
 
264
        T2 = (uint32_t) ((int32_t) ((int16_t) (T0 >> 16)) *
 
265
                         (int32_t) ((int16_t) (T1 >> 16)));
 
266
        if (T2 & 0x80000000) {
 
267
                st->Accumulator += 0xffffffff00000000;
 
268
        }
 
269
        st->Accumulator += (ARMdword) T2;
 
270
        T2 = (uint32_t) ((int32_t) ((int16_t) (T0 & 0xffff)) *
 
271
                         (int32_t) ((int16_t) (T1 & 0xffff)));
 
272
        if (T2 & 0x80000000) {
 
273
                st->Accumulator += 0xffffffff00000000;
 
274
        }
 
275
        st->Accumulator += (ARMdword) T2;
 
276
        OP_END ("get_op_miaph_T0_T1");
 
277
        *len = end - begin;
 
278
 
 
279
        return ((uint8_t *) begin);
 
280
}
 
281
 
 
282
uint8_t *
 
283
get_op_miaxy_T0_T1 (int *len)
 
284
{
 
285
        unsigned int begin = 0, end = 0;
 
286
 
 
287
        OP_BEGIN ("get_op_miaxy_T0_T1");
 
288
        T2 = (uint32_t) ((int32_t) T0 * (int32_t) T1);
 
289
        if (T2 & 0x80000000) {
 
290
                st->Accumulator += 0xffffffff00000000;
 
291
        }
 
292
        st->Accumulator += (ARMdword) T2;
 
293
        OP_END ("get_op_miaxy_T0_T1");
 
294
        *len = end - begin;
 
295
 
 
296
        return ((uint8_t *) begin);
 
297
}
 
298
 
 
299
op_table_t op_mar_T0_T1;
 
300
op_table_t op_mra_T0_T1;
 
301
op_table_t op_mia_T0_T1;
 
302
op_table_t op_miaph_T0_T1;
 
303
op_table_t op_miaxy_T0_T1;
 
304
//AJ2D--------------------------------------------------------------------------
 
305
 
 
306
//--------------------------------------------------------------------------------------------------
 
307
 
 
308
uint8_t *
 
309
get_op_ldc_T0_T1 (int *len)
 
310
{
 
311
        unsigned int begin = 0, end = 0;
 
312
 
 
313
        OP_BEGIN ("get_op_ldc_T0_T1");
 
314
        //tea_ldc(st, T0, T1);
 
315
        __asm__ __volatile__ ("subl     $0x4, %esp");
 
316
        __asm__ __volatile__ ("push     %" AREG_T1);
 
317
        __asm__ __volatile__ ("push     %" AREG_T0);
 
318
        __asm__ __volatile__ ("push     %" AREG_st);
 
319
        T2 = (uint32_t) tea_ldc;
 
320
        __asm__ __volatile__ ("call     *%" AREG_T2);
 
321
        __asm__ __volatile__ ("addl     $0x10, %esp");
 
322
        if (st->trap) {
 
323
                __asm__ __volatile__ ("ret");
 
324
        }
 
325
        OP_END ("get_op_ldc_T0_T1");
 
326
        *len = end - begin;
 
327
 
 
328
        return ((uint8_t *) begin);
 
329
}
 
330
 
 
331
uint8_t *
 
332
get_op_stc_T0_T1 (int *len)
 
333
{
 
334
        unsigned int begin = 0, end = 0;
 
335
 
 
336
        OP_BEGIN ("get_op_stc_T0_T1");
 
337
        //tea_stc(st, T0, T1);
 
338
        __asm__ __volatile__ ("subl     $0x4, %esp");
 
339
        __asm__ __volatile__ ("push     %" AREG_T1);
 
340
        __asm__ __volatile__ ("push     %" AREG_T0);
 
341
        __asm__ __volatile__ ("push     %" AREG_st);
 
342
        T2 = (uint32_t) tea_stc;
 
343
        __asm__ __volatile__ ("call     *%" AREG_T2);
 
344
        __asm__ __volatile__ ("addl     $0x10, %esp");
 
345
        if (st->trap) {
 
346
                __asm__ __volatile__ ("ret");
 
347
        }
 
348
        OP_END ("get_op_stc_T0_T1");
 
349
        *len = end - begin;
 
350
 
 
351
        return ((uint8_t *) begin);
 
352
}
 
353
 
 
354
uint8_t *
 
355
get_op_mrc_T0_T1 (int *len)
 
356
{
 
357
        unsigned int begin = 0, end = 0;
 
358
 
 
359
        OP_BEGIN ("get_op_mrc_T0_T1");
 
360
        //tea_mrc(st, T0, T1);
 
361
        __asm__ __volatile__ ("subl     $0x4, %esp");
 
362
        __asm__ __volatile__ ("push     %" AREG_T1);
 
363
        __asm__ __volatile__ ("push     %" AREG_T0);
 
364
        __asm__ __volatile__ ("push     %" AREG_st);
 
365
        T2 = (uint32_t) tea_mrc;
 
366
        __asm__ __volatile__ ("call     *%" AREG_T2);
 
367
        __asm__ __volatile__ ("addl     $0x10, %esp");
 
368
        if (st->trap) {
 
369
                __asm__ __volatile__ ("ret");
 
370
        }
 
371
        OP_END ("get_op_mrc_T0_T1");
 
372
        *len = end - begin;
 
373
 
 
374
        return ((uint8_t *) begin);
 
375
}
 
376
 
 
377
uint8_t *
 
378
get_op_mcr_T0_T1 (int *len)
 
379
{
 
380
        unsigned int begin = 0, end = 0;
 
381
 
 
382
        OP_BEGIN ("get_op_mcr_T0_T1");
 
383
        //tea_mcr(st, T0, T1);
 
384
        __asm__ __volatile__ ("subl     $0x4, %esp");
 
385
        __asm__ __volatile__ ("push     %" AREG_T1);
 
386
        __asm__ __volatile__ ("push     %" AREG_T0);
 
387
        __asm__ __volatile__ ("push     %" AREG_st);
 
388
        T2 = (uint32_t) tea_mcr;
 
389
        __asm__ __volatile__ ("call     *%" AREG_T2);
 
390
        __asm__ __volatile__ ("addl     $0x10, %esp");
 
391
        if (st->trap) {
 
392
                __asm__ __volatile__ ("ret");
 
393
        }
 
394
        OP_END ("get_op_mcr_T0_T1");
 
395
        *len = end - begin;
 
396
 
 
397
        return ((uint8_t *) begin);
 
398
}
 
399
 
 
400
uint8_t *
 
401
get_op_cdp_T0_T1 (int *len)
 
402
{
 
403
        unsigned int begin = 0, end = 0;
 
404
 
 
405
        OP_BEGIN ("get_op_cdp_T0_T1");
 
406
        //tea_cdp(st, T0, T1);
 
407
        __asm__ __volatile__ ("subl     $0x4, %esp");
 
408
        __asm__ __volatile__ ("push     %" AREG_T1);
 
409
        __asm__ __volatile__ ("push     %" AREG_T0);
 
410
        __asm__ __volatile__ ("push     %" AREG_st);
 
411
        T2 = (uint32_t) tea_cdp;
 
412
        __asm__ __volatile__ ("call     *%" AREG_T2);
 
413
        __asm__ __volatile__ ("addl     $0x10, %esp");
 
414
        if (st->trap) {
 
415
                __asm__ __volatile__ ("ret");
 
416
        }
 
417
        OP_END ("get_op_cdp_T0_T1");
 
418
        *len = end - begin;
 
419
 
 
420
        return ((uint8_t *) begin);
 
421
}
 
422
 
 
423
op_table_t op_ldc_T0_T1;
 
424
op_table_t op_stc_T0_T1;
 
425
op_table_t op_mrc_T0_T1;
 
426
op_table_t op_mcr_T0_T1;
 
427
op_table_t op_cdp_T0_T1;
 
428
 
 
429
//--------------------------------------------------------------------------------------------------
 
430
int
 
431
arm2x86_coproc_init ()
 
432
{
 
433
        op_ldc_T0_T1.op = get_op_ldc_T0_T1 (&op_ldc_T0_T1.len);
 
434
        if (op_ldc_T0_T1.len <= 0)
 
435
                return (-1);
 
436
 
 
437
        op_stc_T0_T1.op = get_op_stc_T0_T1 (&op_stc_T0_T1.len);
 
438
        if (op_stc_T0_T1.len <= 0)
 
439
                return (-1);
 
440
 
 
441
        op_mrc_T0_T1.op = get_op_mrc_T0_T1 (&op_mrc_T0_T1.len);
 
442
        if (op_mrc_T0_T1.len <= 0)
 
443
                return (-1);
 
444
 
 
445
        op_mcr_T0_T1.op = get_op_mcr_T0_T1 (&op_mcr_T0_T1.len);
 
446
        if (op_mcr_T0_T1.len <= 0)
 
447
                return (-1);
 
448
 
 
449
        op_cdp_T0_T1.op = get_op_cdp_T0_T1 (&op_cdp_T0_T1.len);
 
450
        if (op_cdp_T0_T1.len <= 0)
 
451
                return (-1);
 
452
 
 
453
//teawater add for xscale(arm v5) 2005.09.12------------------------------------
 
454
        op_mar_T0_T1.op = get_op_mar_T0_T1 (&op_mar_T0_T1.len);
 
455
        if (op_mar_T0_T1.len <= 0)
 
456
                return (-1);
 
457
 
 
458
        op_mra_T0_T1.op = get_op_mra_T0_T1 (&op_mra_T0_T1.len);
 
459
        if (op_mra_T0_T1.len <= 0)
 
460
                return (-1);
 
461
 
 
462
        op_mia_T0_T1.op = get_op_mia_T0_T1 (&op_mia_T0_T1.len);
 
463
        if (op_mia_T0_T1.len <= 0)
 
464
                return (-1);
 
465
 
 
466
        op_miaph_T0_T1.op = get_op_miaph_T0_T1 (&op_miaph_T0_T1.len);
 
467
        if (op_miaph_T0_T1.len <= 0)
 
468
                return (-1);
 
469
 
 
470
        op_miaxy_T0_T1.op = get_op_miaxy_T0_T1 (&op_miaxy_T0_T1.len);
 
471
        if (op_miaxy_T0_T1.len <= 0)
 
472
                return (-1);
 
473
//AJ2D--------------------------------------------------------------------------
 
474
 
 
475
        return (0);
 
476
}