← Back to branch summary

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

« back to all changes in this revision

Viewing changes to arch/arm/dbct/arm2x86_dp.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_dp.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
uint8_t *
 
30
get_op_andl_T0_T1 (int *len)
 
31
{
 
32
        unsigned int begin = 0, end = 0;
 
33
 
 
34
        OP_BEGIN ("get_op_andl_T0_T1");
 
35
        T0 &= T1;
 
36
        OP_END ("get_op_andl_T0_T1");
 
37
        *len = end - begin;
 
38
 
 
39
        return ((uint8_t *) begin);
 
40
}
 
41
 
 
42
uint8_t *
 
43
get_op_eorl_T0_T1 (int *len)
 
44
{
 
45
        unsigned int begin = 0, end = 0;
 
46
 
 
47
        OP_BEGIN ("get_op_eorl_T0_T1");
 
48
        T0 ^= T1;
 
49
        OP_END ("get_op_eorl_T0_T1");
 
50
        *len = end - begin;
 
51
 
 
52
        return ((uint8_t *) begin);
 
53
}
 
54
 
 
55
uint8_t *
 
56
get_op_subl_T0_T1 (int *len)
 
57
{
 
58
        unsigned int begin = 0, end = 0;
 
59
 
 
60
        OP_BEGIN ("get_op_subl_T0_T1");
 
61
        T0 -= T1;
 
62
        OP_END ("get_op_subl_T0_T1");
 
63
        *len = end - begin;
 
64
 
 
65
        return ((uint8_t *) begin);
 
66
}
 
67
 
 
68
uint8_t *
 
69
get_op_subl_T0_T1_scv (int *len)
 
70
{
 
71
        unsigned int begin = 0, end = 0;
 
72
 
 
73
        OP_BEGIN ("get_op_subl_T0_T1_scv");
 
74
        T2 = T0 - T1;
 
75
        //CFLAG_reg = (T0<T1)?1:0;
 
76
        CFLAG_reg = (T0 >= T1) ? 1 : 0;
 
77
        //chy 2006-02-12 chage ! to ~
 
78
        //VFLAG_reg = !(T2 ^ T1);
 
79
        VFLAG_reg = ~(T2 ^ T1);
 
80
        VFLAG_reg &= (T0 ^ T1);
 
81
        VFLAG_reg >>= 31;
 
82
        T0 = T2;
 
83
        OP_END ("get_op_subl_T0_T1_scv");
 
84
        *len = end - begin;
 
85
 
 
86
        return ((uint8_t *) begin);
 
87
}
 
88
 
 
89
uint8_t *
 
90
get_op_rsbl_T0_T1 (int *len)
 
91
{
 
92
        unsigned int begin = 0, end = 0;
 
93
 
 
94
        OP_BEGIN ("get_op_rsbl_T0_T1");
 
95
        T0 = T1 - T0;
 
96
        OP_END ("get_op_rsbl_T0_T1");
 
97
        *len = end - begin;
 
98
 
 
99
        return ((uint8_t *) begin);
 
100
}
 
101
 
 
102
uint8_t *
 
103
get_op_rsbl_T0_T1_scv (int *len)
 
104
{
 
105
        unsigned int begin = 0, end = 0;
 
106
 
 
107
        OP_BEGIN ("get_op_rsbl_T0_T1_scv");
 
108
        T2 = T1 - T0;
 
109
        //CFLAG_reg = (T1<T0)?1:0;
 
110
        CFLAG_reg = (T1 >= T0) ? 1 : 0;
 
111
        //chy 2006-02-12 chage ! to ~
 
112
        //VFLAG_reg = !(T2 ^ T0);
 
113
        VFLAG_reg = ~(T2 ^ T0);
 
114
        VFLAG_reg &= (T0 ^ T1);
 
115
        VFLAG_reg >>= 31;
 
116
        T0 = T2;
 
117
        OP_END ("get_op_rsbl_T0_T1_scv");
 
118
        *len = end - begin;
 
119
 
 
120
        return ((uint8_t *) begin);
 
121
}
 
122
 
 
123
uint8_t *
 
124
get_op_addl_T0_T1 (int *len)
 
125
{
 
126
        unsigned int begin = 0, end = 0;
 
127
 
 
128
        OP_BEGIN ("get_op_addl_T0_T1");
 
129
        T0 += T1;
 
130
        OP_END ("get_op_addl_T0_T1");
 
131
        *len = end - begin;
 
132
 
 
133
        return ((uint8_t *) begin);
 
134
}
 
135
 
 
136
uint8_t *
 
137
get_op_addl_T0_T1_scv (int *len)
 
138
{
 
139
        unsigned int begin = 0, end = 0;
 
140
 
 
141
        OP_BEGIN ("get_op_addl_T0_T1_scv");
 
142
        T2 = T0 + T1;
 
143
        CFLAG_reg = (T2 < T0);
 
144
        VFLAG_reg = ~(T0 ^ T1);
 
145
        VFLAG_reg &= (T2 ^ T1);
 
146
        VFLAG_reg >>= 31;
 
147
        T0 = T2;
 
148
        OP_END ("get_op_addl_T0_T1_scv");
 
149
        *len = end - begin;
 
150
 
 
151
        return ((uint8_t *) begin);
 
152
}
 
153
 
 
154
uint8_t *
 
155
get_op_adcl_T0_T1 (int *len)
 
156
{
 
157
        unsigned int begin = 0, end = 0;
 
158
 
 
159
        OP_BEGIN ("get_op_adcl_T0_T1");
 
160
        T0 += T1 + CFLAG_reg;
 
161
        OP_END ("get_op_adcl_T0_T1");
 
162
        *len = end - begin;
 
163
 
 
164
        return ((uint8_t *) begin);
 
165
}
 
166
 
 
167
uint8_t *
 
168
get_op_adcl_T0_T1_scv (int *len)
 
169
{
 
170
        unsigned int begin = 0, end = 0;
 
171
 
 
172
        OP_BEGIN ("get_op_adcl_T0_T1_scv");
 
173
        T2 = T0 + T1 + CFLAG_reg;
 
174
        if (!CFLAG_reg) {
 
175
                CFLAG_reg = (T2 < T0);
 
176
        }
 
177
        else {
 
178
                CFLAG_reg = (T2 <= T0);
 
179
        }
 
180
        VFLAG_reg = ~(T0 ^ T1);
 
181
        VFLAG_reg &= (T2 ^ T1);
 
182
        VFLAG_reg >>= 31;
 
183
        T0 = T2;
 
184
        OP_END ("get_op_adcl_T0_T1_scv");
 
185
        *len = end - begin;
 
186
 
 
187
        return ((uint8_t *) begin);
 
188
}
 
189
 
 
190
uint8_t *
 
191
get_op_sbcl_T0_T1 (int *len)
 
192
{
 
193
        unsigned int begin = 0, end = 0;
 
194
 
 
195
        OP_BEGIN ("get_op_sbcl_T0_T1");
 
196
        //T0 -= (T1 + !CFLAG_reg);
 
197
        T0 = T0 - T1 + CFLAG_reg - 1;
 
198
        OP_END ("get_op_sbcl_T0_T1");
 
199
        *len = end - begin;
 
200
 
 
201
        return ((uint8_t *) begin);
 
202
}
 
203
 
 
204
uint8_t *
 
205
get_op_sbcl_T0_T1_scv (int *len)
 
206
{
 
207
        unsigned int begin = 0, end = 0;
 
208
 
 
209
        OP_BEGIN ("get_op_sbcl_T0_T1_scv");
 
210
        T2 = T0 - T1 + CFLAG_reg - 1;
 
211
        if (!CFLAG_reg) {
 
212
                CFLAG_reg = (T0 > T1);
 
213
        }
 
214
        else {
 
215
                CFLAG_reg = (T0 >= T1);
 
216
        }
 
217
        //chy 2006-02-12 chage ! to ~
 
218
        //VFLAG_reg = !(T2 ^ T1);
 
219
        VFLAG_reg = ~(T2 ^ T1);
 
220
        VFLAG_reg &= (T0 ^ T1);
 
221
        VFLAG_reg >>= 31;
 
222
        T0 = T2;
 
223
        OP_END ("get_op_sbcl_T0_T1_scv");
 
224
        *len = end - begin;
 
225
 
 
226
        return ((uint8_t *) begin);
 
227
}
 
228
 
 
229
uint8_t *
 
230
get_op_rscl_T0_T1 (int *len)
 
231
{
 
232
        unsigned int begin = 0, end = 0;
 
233
 
 
234
        OP_BEGIN ("get_op_rscl_T0_T1");
 
235
        //T0 = T1 - T0 - !CFLAG_reg;
 
236
        T0 = T1 - T0 + CFLAG_reg - 1;
 
237
        OP_END ("get_op_rscl_T0_T1");
 
238
        *len = end - begin;
 
239
 
 
240
        return ((uint8_t *) begin);
 
241
}
 
242
 
 
243
uint8_t *
 
244
get_op_rscl_T0_T1_scv (int *len)
 
245
{
 
246
        unsigned int begin = 0, end = 0;
 
247
 
 
248
        OP_BEGIN ("get_op_rscl_T0_T1_scv");
 
249
        T0 += !CFLAG_reg;
 
250
        T2 = T1 - T0;
 
251
        //CFLAG_reg = (T1<T0)?1:0;
 
252
        //CFLAG_reg = (T1 >= T0)?1:0;
 
253
        if (!CFLAG_reg) {
 
254
                CFLAG_reg = (T1 > T0);
 
255
        }
 
256
        else {
 
257
                CFLAG_reg = (T1 >= T0);
 
258
        }
 
259
        //chy 2006-02-12 chage ! to ~
 
260
        //VFLAG_reg = !(T2 ^ T0);
 
261
        VFLAG_reg = ~(T2 ^ T0);
 
262
        VFLAG_reg &= (T0 ^ T1);
 
263
        VFLAG_reg >>= 31;
 
264
        T0 = T2;
 
265
        OP_END ("get_op_rscl_T0_T1_scv");
 
266
        *len = end - begin;
 
267
 
 
268
        return ((uint8_t *) begin);
 
269
}
 
270
 
 
271
uint8_t *
 
272
get_op_orrl_T0_T1 (int *len)
 
273
{
 
274
        unsigned int begin = 0, end = 0;
 
275
 
 
276
        OP_BEGIN ("get_op_orrl_T0_T1");
 
277
        T0 |= T1;
 
278
        OP_END ("get_op_orrl_T0_T1");
 
279
        *len = end - begin;
 
280
 
 
281
        return ((uint8_t *) begin);
 
282
}
 
283
 
 
284
uint8_t *
 
285
get_op_movl_T0_T1 (int *len)
 
286
{
 
287
        unsigned int begin = 0, end = 0;
 
288
 
 
289
        OP_BEGIN ("get_op_movl_T0_T1");
 
290
        T0 = T1;
 
291
        OP_END ("get_op_movl_T0_T1");
 
292
        *len = end - begin;
 
293
 
 
294
        return ((uint8_t *) begin);
 
295
}
 
296
 
 
297
uint8_t *
 
298
get_op_bicl_T0_T1 (int *len)
 
299
{
 
300
        unsigned int begin = 0, end = 0;
 
301
 
 
302
        OP_BEGIN ("get_op_bicl_T0_T1");
 
303
        T0 &= ~T1;
 
304
        OP_END ("get_op_bicl_T0_T1");
 
305
        *len = end - begin;
 
306
 
 
307
        return ((uint8_t *) begin);
 
308
}
 
309
 
 
310
uint8_t *
 
311
get_op_notl_T0_T1 (int *len)
 
312
{
 
313
        unsigned int begin = 0, end = 0;
 
314
 
 
315
        OP_BEGIN ("get_op_notl_T0_T1");
 
316
        T0 = ~T1;
 
317
        OP_END ("get_op_notl_T0_T1");
 
318
        *len = end - begin;
 
319
 
 
320
        return ((uint8_t *) begin);
 
321
}
 
322
 
 
323
uint8_t *
 
324
get_op_addl_T1_im (int *len)
 
325
{
 
326
        unsigned int begin = 0, end = 0;
 
327
 
 
328
        OP_BEGIN ("get_op_addl_T1_im");
 
329
        T1 += INT32_MAX;
 
330
        OP_END ("get_op_addl_T1_im");
 
331
        *len = end - begin;
 
332
        if (*len <= sizeof (ULONG_MAX)) {
 
333
                return (NULL);
 
334
        }
 
335
        else {
 
336
                *len -= sizeof (ULONG_MAX);
 
337
        }
 
338
 
 
339
        return ((uint8_t *) begin);
 
340
}
 
341
 
 
342
uint8_t *
 
343
get_op_subl_T1_T2 (int *len)
 
344
{
 
345
        unsigned int begin = 0, end = 0;
 
346
 
 
347
        OP_BEGIN ("get_op_subl_T1_T2");
 
348
        T1 -= T2;
 
349
        OP_END ("get_op_subl_T1_T2");
 
350
        *len = end - begin;
 
351
 
 
352
        return ((uint8_t *) begin);
 
353
}
 
354
 
 
355
uint8_t *
 
356
get_op_addl_T1_T2 (int *len)
 
357
{
 
358
        unsigned int begin = 0, end = 0;
 
359
 
 
360
        OP_BEGIN ("get_op_addl_T1_T2");
 
361
        T1 += T2;
 
362
        OP_END ("get_op_addl_T1_T2");
 
363
        *len = end - begin;
 
364
 
 
365
        return ((uint8_t *) begin);
 
366
}
 
367
 
 
368
//teawater add for xscale(arm v5) 2005.09.01------------------------------------
 
369
uint8_t *
 
370
get_op_clzl_T0_T1 (int *len)
 
371
{
 
372
        unsigned int begin = 0, end = 0;
 
373
 
 
374
        OP_BEGIN ("get_op_clzl_T0_T1");
 
375
        //chy 2006-02-12 fix a bug
 
376
        if(T1){
 
377
                for (T0 = 0; (T1 & 0x80000000) == 0; T1 <<= 1) {
 
378
                        T0++;
 
379
                }
 
380
        }
 
381
        OP_END ("get_op_clzl_T0_T1");
 
382
        *len = end - begin;
 
383
 
 
384
        return ((uint8_t *) begin);
 
385
}
 
386
 
 
387
uint8_t *
 
388
get_op_qaddl_T0_T1_sq (int *len)
 
389
{
 
390
        unsigned int begin = 0, end = 0;
 
391
 
 
392
        OP_BEGIN ("get_op_qaddl_T0_T1_sq");
 
393
        T2 = T0 + T1;
 
394
        QFLAG_reg = ~(T0 ^ T1);
 
395
        QFLAG_reg &= (T2 ^ T1);
 
396
        QFLAG_reg >>= 31;
 
397
        T0 = T2;
 
398
        if (QFLAG_reg) {
 
399
                T0 = (T0 >> 31) ? 0x7fffffff : 0x80000000;
 
400
        }
 
401
        OP_END ("get_op_qaddl_T0_T1_sq");
 
402
        *len = end - begin;
 
403
 
 
404
        return ((uint8_t *) begin);
 
405
}
 
406
 
 
407
uint8_t *
 
408
get_op_qsubl_T0_T1_sq (int *len)
 
409
{
 
410
        unsigned int begin = 0, end = 0;
 
411
 
 
412
        OP_BEGIN ("get_op_qsubl_T0_T1_sq");
 
413
        T2 = T0 - T1;
 
414
        //chy 2006-02-12 chage ! to ~
 
415
        //QFLAG_reg = !(T2 ^ T1);
 
416
        QFLAG_reg = ~(T2 ^ T1);
 
417
        QFLAG_reg &= (T0 ^ T1);
 
418
        QFLAG_reg >>= 31;
 
419
        T0 = T2;
 
420
        if (QFLAG_reg) {
 
421
                T0 = (T0 >> 31) ? 0x7fffffff : 0x80000000;
 
422
        }
 
423
        OP_END ("get_op_qsubl_T0_T1_sq");
 
424
        *len = end - begin;
 
425
 
 
426
        return ((uint8_t *) begin);
 
427
}
 
428
 
 
429
uint8_t *
 
430
get_op_addl_T0_T1_sq (int *len)
 
431
{
 
432
        unsigned int begin = 0, end = 0;
 
433
 
 
434
        OP_BEGIN ("get_op_addl_T0_T1_sq");
 
435
        T2 = T0 + T1;
 
436
        QFLAG_reg = ~(T0 ^ T1);
 
437
        QFLAG_reg &= (T2 ^ T1);
 
438
        QFLAG_reg >>= 31;
 
439
        T0 = T2;
 
440
        OP_END ("get_op_addl_T0_T1_sq");
 
441
        *len = end - begin;
 
442
 
 
443
        return ((uint8_t *) begin);
 
444
}
 
445
 
 
446
//AJ2D--------------------------------------------------------------------------
 
447
 
 
448
op_table_t op_andl_T0_T1;
 
449
op_table_t op_eorl_T0_T1;
 
450
op_table_t op_subl_T0_T1;
 
451
op_table_t op_subl_T0_T1_scv;
 
452
op_table_t op_rsbl_T0_T1;
 
453
op_table_t op_rsbl_T0_T1_scv;
 
454
op_table_t op_addl_T0_T1;
 
455
op_table_t op_addl_T0_T1_scv;
 
456
op_table_t op_adcl_T0_T1;
 
457
op_table_t op_adcl_T0_T1_scv;
 
458
op_table_t op_sbcl_T0_T1;
 
459
op_table_t op_sbcl_T0_T1_scv;
 
460
op_table_t op_rscl_T0_T1;
 
461
op_table_t op_rscl_T0_T1_scv;
 
462
op_table_t op_orrl_T0_T1;
 
463
op_table_t op_movl_T0_T1;
 
464
op_table_t op_bicl_T0_T1;
 
465
op_table_t op_notl_T0_T1;
 
466
op_table_t op_addl_T1_im;
 
467
op_table_t op_subl_T1_T2;
 
468
op_table_t op_addl_T1_T2;
 
469
//teawater add for xscale(arm v5) 2005.09.01------------------------------------
 
470
op_table_t op_clzl_T0_T1;
 
471
op_table_t op_qaddl_T0_T1_sq;
 
472
op_table_t op_qsubl_T0_T1_sq;
 
473
op_table_t op_addl_T0_T1_sq;
 
474
//AJ2D--------------------------------------------------------------------------
 
475
 
 
476
int
 
477
op_dp_T0_T1 ()
 
478
{
 
479
        op_andl_T0_T1.op = get_op_andl_T0_T1 (&op_andl_T0_T1.len);
 
480
        if (op_andl_T0_T1.len <= 0)
 
481
                return (-1);
 
482
 
 
483
        op_eorl_T0_T1.op = get_op_eorl_T0_T1 (&op_eorl_T0_T1.len);
 
484
        if (op_eorl_T0_T1.len <= 0)
 
485
                return (-1);
 
486
 
 
487
        op_subl_T0_T1.op = get_op_subl_T0_T1 (&op_subl_T0_T1.len);
 
488
        if (op_subl_T0_T1.len <= 0)
 
489
                return (-1);
 
490
 
 
491
        op_subl_T0_T1_scv.op = get_op_subl_T0_T1_scv (&op_subl_T0_T1_scv.len);
 
492
        if (op_subl_T0_T1_scv.len <= 0)
 
493
                return (-1);
 
494
 
 
495
        op_rsbl_T0_T1.op = get_op_rsbl_T0_T1 (&op_rsbl_T0_T1.len);
 
496
        if (op_rsbl_T0_T1.len <= 0)
 
497
                return (-1);
 
498
 
 
499
        op_rsbl_T0_T1_scv.op = get_op_rsbl_T0_T1_scv (&op_rsbl_T0_T1_scv.len);
 
500
        if (op_rsbl_T0_T1_scv.len <= 0)
 
501
                return (-1);
 
502
 
 
503
        op_addl_T0_T1.op = get_op_addl_T0_T1 (&op_addl_T0_T1.len);
 
504
        if (op_addl_T0_T1.len <= 0)
 
505
                return (-1);
 
506
 
 
507
        op_addl_T0_T1_scv.op = get_op_addl_T0_T1_scv (&op_addl_T0_T1_scv.len);
 
508
        if (op_addl_T0_T1_scv.len <= 0)
 
509
                return (-1);
 
510
 
 
511
        op_adcl_T0_T1.op = get_op_adcl_T0_T1 (&op_adcl_T0_T1.len);
 
512
        if (op_adcl_T0_T1.len <= 0)
 
513
                return (-1);
 
514
 
 
515
        op_adcl_T0_T1_scv.op = get_op_adcl_T0_T1_scv (&op_adcl_T0_T1_scv.len);
 
516
        if (op_adcl_T0_T1_scv.len <= 0)
 
517
                return (-1);
 
518
 
 
519
        op_sbcl_T0_T1.op = get_op_sbcl_T0_T1 (&op_sbcl_T0_T1.len);
 
520
        if (op_sbcl_T0_T1.len <= 0)
 
521
                return (-1);
 
522
 
 
523
        op_sbcl_T0_T1_scv.op = get_op_sbcl_T0_T1_scv (&op_sbcl_T0_T1_scv.len);
 
524
        if (op_sbcl_T0_T1_scv.len <= 0)
 
525
                return (-1);
 
526
 
 
527
        op_rscl_T0_T1.op = get_op_rscl_T0_T1 (&op_rscl_T0_T1.len);
 
528
        if (op_rscl_T0_T1.len <= 0)
 
529
                return (-1);
 
530
 
 
531
        op_rscl_T0_T1_scv.op = get_op_rscl_T0_T1_scv (&op_rscl_T0_T1_scv.len);
 
532
        if (op_rscl_T0_T1_scv.len <= 0)
 
533
                return (-1);
 
534
 
 
535
        op_orrl_T0_T1.op = get_op_orrl_T0_T1 (&op_orrl_T0_T1.len);
 
536
        if (op_orrl_T0_T1.len <= 0)
 
537
                return (-1);
 
538
 
 
539
        op_movl_T0_T1.op = get_op_movl_T0_T1 (&op_movl_T0_T1.len);
 
540
        if (op_movl_T0_T1.len <= 0)
 
541
                return (-1);
 
542
 
 
543
        op_bicl_T0_T1.op = get_op_bicl_T0_T1 (&op_bicl_T0_T1.len);
 
544
        if (op_bicl_T0_T1.len <= 0)
 
545
                return (-1);
 
546
 
 
547
        op_notl_T0_T1.op = get_op_notl_T0_T1 (&op_notl_T0_T1.len);
 
548
        if (op_notl_T0_T1.len <= 0)
 
549
                return (-1);
 
550
 
 
551
        op_addl_T1_im.op = get_op_addl_T1_im (&op_addl_T1_im.len);
 
552
        if (op_addl_T1_im.len <= 0)
 
553
                return (-1);
 
554
 
 
555
        op_subl_T1_T2.op = get_op_subl_T1_T2 (&op_subl_T1_T2.len);
 
556
        if (op_subl_T1_T2.len <= 0)
 
557
                return (-1);
 
558
 
 
559
        op_addl_T1_T2.op = get_op_addl_T1_T2 (&op_addl_T1_T2.len);
 
560
        if (op_addl_T1_T2.len <= 0)
 
561
                return (-1);
 
562
 
 
563
//teawater add for xscale(arm v5) 2005.09.01------------------------------------
 
564
        op_clzl_T0_T1.op = get_op_clzl_T0_T1 (&op_clzl_T0_T1.len);
 
565
        if (op_clzl_T0_T1.len <= 0)
 
566
                return (-1);
 
567
 
 
568
        op_qaddl_T0_T1_sq.op = get_op_qaddl_T0_T1_sq (&op_qaddl_T0_T1_sq.len);
 
569
        if (op_qaddl_T0_T1_sq.len <= 0)
 
570
                return (-1);
 
571
 
 
572
        op_qsubl_T0_T1_sq.op = get_op_qsubl_T0_T1_sq (&op_qsubl_T0_T1_sq.len);
 
573
        if (op_qsubl_T0_T1_sq.len <= 0)
 
574
                return (-1);
 
575
 
 
576
        op_addl_T0_T1_sq.op = get_op_addl_T0_T1_sq (&op_addl_T0_T1_sq.len);
 
577
        if (op_addl_T0_T1_sq.len <= 0)
 
578
                return (-1);
 
579
//AJ2D--------------------------------------------------------------------------
 
580
 
 
581
        return (0);
 
582
}
 
583
 
 
584
//--------------------------------------------------------------------------------------------------
 
585
void
 
586
arm2x86_get_op_and (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
587
                    ARMword set_cc, ARMword rd)
 
588
{
 
589
        GEN_OP (*tbpp, *plen, op_andl_T0_T1);
 
590
}
 
591
 
 
592
void
 
593
arm2x86_get_op_eor (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
594
                    ARMword set_cc, ARMword rd)
 
595
{
 
596
        GEN_OP (*tbpp, *plen, op_eorl_T0_T1);
 
597
}
 
598
 
 
599
void
 
600
arm2x86_get_op_sub (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
601
                    ARMword set_cc, ARMword rd)
 
602
{
 
603
        if (set_cc && rd != 15) {
 
604
                GEN_OP (*tbpp, *plen, op_subl_T0_T1_scv);
 
605
        }
 
606
        else {
 
607
                GEN_OP (*tbpp, *plen, op_subl_T0_T1);
 
608
        }
 
609
}
 
610
 
 
611
void
 
612
arm2x86_get_op_rsb (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
613
                    ARMword set_cc, ARMword rd)
 
614
{
 
615
        if (set_cc && rd != 15) {
 
616
                GEN_OP (*tbpp, *plen, op_rsbl_T0_T1_scv);
 
617
        }
 
618
        else {
 
619
                GEN_OP (*tbpp, *plen, op_rsbl_T0_T1);
 
620
        }
 
621
}
 
622
 
 
623
void
 
624
arm2x86_get_op_add (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
625
                    ARMword set_cc, ARMword rd)
 
626
{
 
627
        if (set_cc && rd != 15) {
 
628
                GEN_OP (*tbpp, *plen, op_addl_T0_T1_scv);
 
629
        }
 
630
        else {
 
631
                GEN_OP (*tbpp, *plen, op_addl_T0_T1);
 
632
        }
 
633
}
 
634
 
 
635
void
 
636
arm2x86_get_op_adc (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
637
                    ARMword set_cc, ARMword rd)
 
638
{
 
639
        if (set_cc && rd != 15) {
 
640
                GEN_OP (*tbpp, *plen, op_adcl_T0_T1_scv);
 
641
        }
 
642
        else {
 
643
                GEN_OP (*tbpp, *plen, op_adcl_T0_T1);
 
644
        }
 
645
}
 
646
 
 
647
void
 
648
arm2x86_get_op_sbc (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
649
                    ARMword set_cc, ARMword rd)
 
650
{
 
651
        if (set_cc && rd != 15) {
 
652
                GEN_OP (*tbpp, *plen, op_sbcl_T0_T1_scv);
 
653
        }
 
654
        else {
 
655
                GEN_OP (*tbpp, *plen, op_sbcl_T0_T1);
 
656
        }
 
657
}
 
658
 
 
659
void
 
660
arm2x86_get_op_rsc (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
661
                    ARMword set_cc, ARMword rd)
 
662
{
 
663
        if (set_cc && rd != 15) {
 
664
                GEN_OP (*tbpp, *plen, op_rscl_T0_T1_scv);
 
665
        }
 
666
        else {
 
667
                GEN_OP (*tbpp, *plen, op_rscl_T0_T1);
 
668
        }
 
669
}
 
670
 
 
671
void
 
672
arm2x86_get_op_tst (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
673
                    ARMword set_cc, ARMword rd)
 
674
{
 
675
        if (set_cc) {
 
676
                GEN_OP (*tbpp, *plen, op_andl_T0_T1);
 
677
        }
 
678
}
 
679
 
 
680
void
 
681
arm2x86_get_op_teq (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
682
                    ARMword set_cc, ARMword rd)
 
683
{
 
684
        if (set_cc) {
 
685
                GEN_OP (*tbpp, *plen, op_eorl_T0_T1);
 
686
        }
 
687
}
 
688
 
 
689
void
 
690
arm2x86_get_op_cmp (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
691
                    ARMword set_cc, ARMword rd)
 
692
{
 
693
        if (set_cc) {
 
694
                GEN_OP (*tbpp, *plen, op_subl_T0_T1_scv);
 
695
        }
 
696
}
 
697
 
 
698
void
 
699
arm2x86_get_op_cmn (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
700
                    ARMword set_cc, ARMword rd)
 
701
{
 
702
        if (set_cc) {
 
703
                GEN_OP (*tbpp, *plen, op_addl_T0_T1_scv);
 
704
        }
 
705
}
 
706
 
 
707
void
 
708
arm2x86_get_op_orr (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
709
                    ARMword set_cc, ARMword rd)
 
710
{
 
711
        GEN_OP (*tbpp, *plen, op_orrl_T0_T1);
 
712
}
 
713
 
 
714
void
 
715
arm2x86_get_op_mov (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
716
                    ARMword set_cc, ARMword rd)
 
717
{
 
718
        GEN_OP (*tbpp, *plen, op_movl_T0_T1);
 
719
}
 
720
 
 
721
void
 
722
arm2x86_get_op_bic (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
723
                    ARMword set_cc, ARMword rd)
 
724
{
 
725
        GEN_OP (*tbpp, *plen, op_bicl_T0_T1);
 
726
}
 
727
 
 
728
void
 
729
arm2x86_get_op_mvn (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
730
                    ARMword set_cc, ARMword rd)
 
731
{
 
732
        GEN_OP (*tbpp, *plen, op_notl_T0_T1);
 
733
}
 
734
 
 
735
arm2x86_get_dp_op_t *arm2x86_get_dp_op[16] = {
 
736
        arm2x86_get_op_and,
 
737
        arm2x86_get_op_eor,
 
738
        arm2x86_get_op_sub,
 
739
        arm2x86_get_op_rsb,
 
740
        arm2x86_get_op_add,
 
741
        arm2x86_get_op_adc,
 
742
        arm2x86_get_op_sbc,
 
743
        arm2x86_get_op_rsc,
 
744
        arm2x86_get_op_tst,
 
745
        arm2x86_get_op_teq,
 
746
        arm2x86_get_op_cmp,
 
747
        arm2x86_get_op_cmn,
 
748
        arm2x86_get_op_orr,
 
749
        arm2x86_get_op_mov,
 
750
        arm2x86_get_op_bic,
 
751
        arm2x86_get_op_mvn,
 
752
};
 
753
 
 
754
void
 
755
arm2x86_get_op_setcpsr_nzc (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
756
                            ARMword set_cc, ARMword rd)
 
757
{
 
758
        if (set_cc) {
 
759
                //set cpsr nf
 
760
                GEN_OP (*tbpp, *plen, op_logic_T0_sn);
 
761
                //GEN_OP(*tbpp, *plen, op_set_nf);
 
762
                //set cpsr zf
 
763
                GEN_OP (*tbpp, *plen, op_logic_T0_sz);
 
764
                //GEN_OP(*tbpp, *plen, op_set_zf);
 
765
                //set cpsr cf
 
766
                //GEN_OP(*tbpp, *plen, op_set_cf);
 
767
                GEN_OP (*tbpp, *plen, op_set_nzcf);
 
768
        }
 
769
}
 
770
 
 
771
void
 
772
arm2x86_get_op_setcpsr_nzc_setreg (ARMul_State * state, uint8_t ** tbpp,
 
773
                                   int *plen, ARMword set_cc, ARMword rd)
 
774
{
 
775
        if (set_cc && rd != 15) {
 
776
                //set cpsr nf
 
777
                GEN_OP (*tbpp, *plen, op_logic_T0_sn);
 
778
                //GEN_OP(*tbpp, *plen, op_set_nf);
 
779
                //set cpsr zf
 
780
                GEN_OP (*tbpp, *plen, op_logic_T0_sz);
 
781
                //GEN_OP(*tbpp, *plen, op_set_zf);
 
782
                //set cpsr cf
 
783
                //GEN_OP(*tbpp, *plen, op_set_cf);
 
784
                GEN_OP (*tbpp, *plen, op_set_nzcf);
 
785
        }
 
786
        gen_op_movl_reg_Tx (state, tbpp, plen, rd, 0);
 
787
        if (rd == 15 && set_cc) {
 
788
                //change pc & set spsr to cpsr
 
789
                gen_op_movl_trap_im_use_T2 (state, tbpp, plen, TRAP_SETS_R15);
 
790
        }
 
791
}
 
792
 
 
793
void
 
794
arm2x86_get_op_setcpsr_nzcv (ARMul_State * state, uint8_t ** tbpp, int *plen,
 
795
                             ARMword set_cc, ARMword rd)
 
796
{
 
797
        if (set_cc) {
 
798
                //set cpsr nf
 
799
                GEN_OP (*tbpp, *plen, op_logic_T0_sn);
 
800
                //GEN_OP(*tbpp, *plen, op_set_nf);
 
801
                //set cpsr zf
 
802
                GEN_OP (*tbpp, *plen, op_logic_T0_sz);
 
803
                //GEN_OP(*tbpp, *plen, op_set_zf);
 
804
                //set cpsr cf
 
805
                //GEN_OP(*tbpp, *plen, op_set_cf);
 
806
                //set cpsr vf
 
807
                //GEN_OP(*tbpp, *plen, op_set_vf);
 
808
                GEN_OP (*tbpp, *plen, op_set_nzcvf);
 
809
        }
 
810
}
 
811
 
 
812
void
 
813
arm2x86_get_op_setcpsr_nzcv_setreg (ARMul_State * state, uint8_t ** tbpp,
 
814
                                    int *plen, ARMword set_cc, ARMword rd)
 
815
{
 
816
        if (set_cc && rd != 15) {
 
817
                //set cpsr cf
 
818
                //GEN_OP(*tbpp, *plen, op_set_cf);
 
819
                //set cpsr vf
 
820
                //GEN_OP(*tbpp, *plen, op_set_vf);
 
821
                //set cpsr nf
 
822
                GEN_OP (*tbpp, *plen, op_logic_T0_sn);
 
823
                //GEN_OP(*tbpp, *plen, op_set_nf);
 
824
                //set cpsr zf
 
825
                GEN_OP (*tbpp, *plen, op_logic_T0_sz);
 
826
                //GEN_OP(*tbpp, *plen, op_set_zf);
 
827
                GEN_OP (*tbpp, *plen, op_set_nzcvf);
 
828
        }
 
829
        gen_op_movl_reg_Tx (state, tbpp, plen, rd, 0);
 
830
        if (rd == 15 && set_cc) {
 
831
                //change pc & set spsr to cpsr
 
832
                gen_op_movl_trap_im_use_T2 (state, tbpp, plen, TRAP_SETS_R15);
 
833
        }
 
834
}
 
835
 
 
836
arm2x86_get_dp_op_t *arm2x86_get_dp_op_setcpsr[16] = {
 
837
        arm2x86_get_op_setcpsr_nzc_setreg,      //and
 
838
        arm2x86_get_op_setcpsr_nzc_setreg,      //eor
 
839
        arm2x86_get_op_setcpsr_nzcv_setreg,     //sub
 
840
        arm2x86_get_op_setcpsr_nzcv_setreg,     //rsb
 
841
        arm2x86_get_op_setcpsr_nzcv_setreg,     //add
 
842
        arm2x86_get_op_setcpsr_nzcv_setreg,     //adc
 
843
        arm2x86_get_op_setcpsr_nzcv_setreg,     //sbc
 
844
        arm2x86_get_op_setcpsr_nzcv_setreg,     //rsc
 
845
        arm2x86_get_op_setcpsr_nzc,     //tst
 
846
        arm2x86_get_op_setcpsr_nzc,     //teq
 
847
        arm2x86_get_op_setcpsr_nzcv,    //cmp
 
848
        arm2x86_get_op_setcpsr_nzcv,    //cmn
 
849
        arm2x86_get_op_setcpsr_nzc_setreg,      //orr
 
850
        arm2x86_get_op_setcpsr_nzc_setreg,      //mov
 
851
        arm2x86_get_op_setcpsr_nzc_setreg,      //bic
 
852
        arm2x86_get_op_setcpsr_nzc_setreg,      //mvn
 
853
};
 
854
 
 
855
//--------------------------------------------------------------------------------------------------
 
856
int
 
857
arm2x86_dp_init ()
 
858
{
 
859
        if (op_dp_T0_T1 ()) {
 
860
                return (-1);
 
861
        }
 
862
 
 
863
        return (0);
 
864
}