← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mupen64plus/quantal

« back to all changes in this revision

Viewing changes to r4300/pure_interp.c

  • Committer: Bazaar Package Importer
  • Author(s): Sven Eckelmann, Sven Eckelmann, Piotr Ożarowski
  • Date: 2010-05-06 11:34:46 UTC
  • mfrom: (3.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20100506113446-jfcd6uk7waudel82
Tags: 1.5+dfsg1-10
http://bugs.debian.org/580480
https://launchpad.net/bugs/575968
[ Sven Eckelmann ]
* debian/patches:
  - Add rsp_ucode2_reset.patch, Reset status of specific ucode2 hacks after
    starting again
  - Add rsp_hle_bigendian.patch, Fix wrong high level emulation of rsp on big
    endian systems
  - Add rice-crash-vendorstring.patch, Don't crash on long OpenGL vendor
    string (Closes: #580480, LP: #575968)

[ Piotr Ożarowski ]
* DMUA flag set to yes

Show diffs side-by-side

added added

removed removed

Lines of Context:
r4300/pure_interp.c
34
34
#include "../debugger/debugger.h"
35
35
#endif
36
36
 
 
37
#define check_r0_rd() { if (PC->f.r.rd == reg) { interp_addr+=4; return; } }
 
38
#define check_r0_rt() { if (PC->f.r.rt == reg) { interp_addr+=4; return; } }
 
39
#define check_r0_irt() { if (PC->f.i.rt == reg) { interp_addr+=4; return; } }
 
40
 
37
41
unsigned int interp_addr;
38
42
unsigned int op;
39
43
static int skip;
52
56
 
53
57
static void SLL()
54
58
{
 
59
   check_r0_rd();
55
60
   rrd32 = (unsigned int)(rrt32) << rsa;
56
61
   sign_extended(rrd);
57
62
   interp_addr+=4;
59
64
 
60
65
static void SRL()
61
66
{
 
67
   check_r0_rd();
62
68
   rrd32 = (unsigned int)rrt32 >> rsa;
63
69
   sign_extended(rrd);
64
70
   interp_addr+=4;
66
72
 
67
73
static void SRA()
68
74
{
 
75
   check_r0_rd();
69
76
   rrd32 = (signed int)rrt32 >> rsa;
70
77
   sign_extended(rrd);
71
78
   interp_addr+=4;
73
80
 
74
81
static void SLLV()
75
82
{
 
83
   check_r0_rd();
76
84
   rrd32 = (unsigned int)(rrt32) << (rrs32&0x1F);
77
85
   sign_extended(rrd);
78
86
   interp_addr+=4;
80
88
 
81
89
static void SRLV()
82
90
{
 
91
   check_r0_rd();
83
92
   rrd32 = (unsigned int)rrt32 >> (rrs32 & 0x1F);
84
93
   sign_extended(rrd);
85
94
   interp_addr+=4;
87
96
 
88
97
static void SRAV()
89
98
{
 
99
   check_r0_rd();
90
100
   rrd32 = (signed int)rrt32 >> (rrs32 & 0x1F);
91
101
   sign_extended(rrd);
92
102
   interp_addr+=4;
140
150
 
141
151
static void MFHI()
142
152
{
 
153
   check_r0_rd();
143
154
   rrd = hi;
144
155
   interp_addr+=4;
145
156
}
152
163
 
153
164
static void MFLO()
154
165
{
 
166
   check_r0_rd();
155
167
   rrd = lo;
156
168
   interp_addr+=4;
157
169
}
164
176
 
165
177
static void DSLLV()
166
178
{
 
179
   check_r0_rd();
167
180
   rrd = rrt << (rrs32&0x3F);
168
181
   interp_addr+=4;
169
182
}
170
183
 
171
184
static void DSRLV()
172
185
{
 
186
   check_r0_rd();
173
187
   rrd = (unsigned long long)rrt >> (rrs32 & 0x3F);
174
188
   interp_addr+=4;
175
189
}
176
190
 
177
191
static void DSRAV()
178
192
{
 
193
   check_r0_rd();
179
194
   rrd = (long long)rrt >> (rrs32 & 0x3F);
180
195
   interp_addr+=4;
181
196
}
323
338
 
324
339
static void ADD()
325
340
{
 
341
   check_r0_rd();
326
342
   rrd32 = rrs32 + rrt32;
327
343
   sign_extended(rrd);
328
344
   interp_addr+=4;
330
346
 
331
347
static void ADDU()
332
348
{
 
349
   check_r0_rd();
333
350
   rrd32 = rrs32 + rrt32;
334
351
   sign_extended(rrd);
335
352
   interp_addr+=4;
337
354
 
338
355
static void SUB()
339
356
{
 
357
   check_r0_rd();
340
358
   rrd32 = rrs32 - rrt32;
341
359
   sign_extended(rrd);
342
360
   interp_addr+=4;
344
362
 
345
363
static void SUBU()
346
364
{
 
365
   check_r0_rd();
347
366
   rrd32 = rrs32 - rrt32;
348
367
   sign_extended(rrd);
349
368
   interp_addr+=4;
351
370
 
352
371
static void AND()
353
372
{
 
373
   check_r0_rd();
354
374
   rrd = rrs & rrt;
355
375
   interp_addr+=4;
356
376
}
357
377
 
358
378
static void OR()
359
379
{
 
380
   check_r0_rd();
360
381
   rrd = rrs | rrt;
361
382
   interp_addr+=4;
362
383
}
363
384
 
364
385
static void XOR()
365
386
{
 
387
   check_r0_rd();
366
388
   rrd = rrs ^ rrt;
367
389
   interp_addr+=4;
368
390
}
369
391
 
370
392
static void NOR()
371
393
{
 
394
   check_r0_rd();
372
395
   rrd = ~(rrs | rrt);
373
396
   interp_addr+=4;
374
397
}
375
398
 
376
399
static void SLT()
377
400
{
 
401
   check_r0_rd();
378
402
   if (rrs < rrt) rrd = 1;
379
403
   else rrd = 0;
380
404
   interp_addr+=4;
382
406
 
383
407
static void SLTU()
384
408
{
 
409
   check_r0_rd();
385
410
   if ((unsigned long long)rrs < (unsigned long long)rrt)
386
411
     rrd = 1;
387
412
   else rrd = 0;
390
415
 
391
416
static void DADD()
392
417
{
 
418
   check_r0_rd();
393
419
   rrd = rrs + rrt;
394
420
   interp_addr+=4;
395
421
}
396
422
 
397
423
static void DADDU()
398
424
{
 
425
   check_r0_rd();
399
426
   rrd = rrs + rrt;
400
427
   interp_addr+=4;
401
428
}
402
429
 
403
430
static void DSUB()
404
431
{
 
432
   check_r0_rd();
405
433
   rrd = rrs - rrt;
406
434
   interp_addr+=4;
407
435
}
408
436
 
409
437
static void DSUBU()
410
438
{
 
439
   check_r0_rd();
411
440
   rrd = rrs - rrt;
412
441
   interp_addr+=4;
413
442
}
424
453
 
425
454
static void DSLL()
426
455
{
 
456
   check_r0_rd();
427
457
   rrd = rrt << rsa;
428
458
   interp_addr+=4;
429
459
}
430
460
 
431
461
static void DSRL()
432
462
{
 
463
   check_r0_rd();
433
464
   rrd = (unsigned long long)rrt >> rsa;
434
465
   interp_addr+=4;
435
466
}
436
467
 
437
468
static void DSRA()
438
469
{
 
470
   check_r0_rd();
439
471
   rrd = rrt >> rsa;
440
472
   interp_addr+=4;
441
473
}
442
474
 
443
475
static void DSLL32()
444
476
{
 
477
   check_r0_rd();
445
478
   rrd = rrt << (32+rsa);
446
479
   interp_addr+=4;
447
480
}
448
481
 
449
482
static void DSRL32()
450
483
{
 
484
   check_r0_rd();
451
485
   rrd = (unsigned long long int)rrt >> (32+rsa);
452
486
   interp_addr+=4;
453
487
}
454
488
 
455
489
static void DSRA32()
456
490
{
 
491
   check_r0_rd();
457
492
   rrd = (signed long long int)rrt >> (32+rsa);
458
493
   interp_addr+=4;
459
494
}
982
1017
    printf("lecture de Random\n");
983
1018
    stop=1;
984
1019
      default:
 
1020
    check_r0_rt();
985
1021
    rrt32 = reg_cop0[PC->f.r.nrd];
986
1022
    sign_extended(rrt);
987
1023
     }
1040
1076
    break;
1041
1077
      case 12:   // Status
1042
1078
    if((rrt & 0x04000000) != (Status & 0x04000000))
1043
 
      {
1044
 
         if (rrt & 0x04000000)
1045
 
           {
1046
 
          int i;
1047
 
          for (i=0; i<32; i++)
1048
 
            {
1049
 
               //reg_cop1_fgr_64[i]=reg_cop1_fgr_32[i];
1050
 
               reg_cop1_double[i]=(double*)&reg_cop1_fgr_64[i];
1051
 
               reg_cop1_simple[i]=(float*)&reg_cop1_fgr_64[i];
1052
 
            }
1053
 
           }
1054
 
         else
1055
 
           {
1056
 
          int i;
1057
 
          for (i=0; i<32; i++)
1058
 
            {
1059
 
               //reg_cop1_fgr_32[i]=reg_cop1_fgr_64[i]&0xFFFFFFFF;
1060
 
               //if (i<16) reg_cop1_double[i*2]=(double*)&reg_cop1_fgr_32[i*2];
1061
 
               //reg_cop1_double[i]=(double*)&reg_cop1_fgr_64[i & 0xFFFE];
1062
 
               if(!(i&1))
1063
 
             reg_cop1_double[i]=(double*)&reg_cop1_fgr_64[i>>1];
1064
 
               //reg_cop1_double[i]=(double*)&reg_cop1_fgr_64[i];
1065
 
               //reg_cop1_simple[i]=(float*)&reg_cop1_fgr_32[i];
1066
 
               //reg_cop1_simple[i]=(float*)&reg_cop1_fgr_64[i & 0xFFFE]+(i&1);
1067
 
#ifndef _BIG_ENDIAN
1068
 
               reg_cop1_simple[i]=(float*)&reg_cop1_fgr_64[i>>1]+(i&1);
1069
 
#else
1070
 
               reg_cop1_simple[i]=(float*)&reg_cop1_fgr_64[i>>1]+(1-(i&1));
1071
 
#endif
1072
 
            }
1073
 
           }
1074
 
      }
 
1079
    {
 
1080
      shuffle_fpr_data(Status, rrt);
 
1081
      set_fpr_pointers(rrt);
 
1082
    }
1075
1083
    Status = rrt;
1076
1084
    interp_addr+=4;
1077
1085
    check_interupt();
1960
1968
 
1961
1969
static void MFC1()
1962
1970
{
 
1971
   check_r0_rt();
1963
1972
   rrt32 = *((int*)reg_cop1_simple[rfs]);
1964
1973
   sign_extended(rrt);
1965
1974
   interp_addr+=4;
1967
1976
 
1968
1977
static void DMFC1()
1969
1978
{
 
1979
   check_r0_rt();
1970
1980
   rrt = *((long long*)(reg_cop1_double[rfs]));
1971
1981
   interp_addr+=4;
1972
1982
}
1973
1983
 
1974
1984
static void CFC1()
1975
1985
{
 
1986
   check_r0_rt();
1976
1987
   if (rfs==31)
1977
1988
     {
1978
1989
    rrt32 = FCR31;
2249
2260
 
2250
2261
static void ADDI()
2251
2262
{
 
2263
   check_r0_irt();
2252
2264
   irt32 = irs32 + iimmediate;
2253
2265
   sign_extended(irt);
2254
2266
   interp_addr+=4;
2256
2268
 
2257
2269
static void ADDIU()
2258
2270
{
 
2271
   check_r0_irt();
2259
2272
   irt32 = irs32 + iimmediate;
2260
2273
   sign_extended(irt);
2261
2274
   interp_addr+=4;
2263
2276
 
2264
2277
static void SLTI()
2265
2278
{
 
2279
   check_r0_irt();
2266
2280
   if (irs < iimmediate) irt = 1;
2267
2281
   else irt = 0;
2268
2282
   interp_addr+=4;
2270
2284
 
2271
2285
static void SLTIU()
2272
2286
{
 
2287
   check_r0_irt();
2273
2288
   if ((unsigned long long)irs < (unsigned long long)((long long)iimmediate))
2274
2289
     irt = 1;
2275
2290
   else irt = 0;
2278
2293
 
2279
2294
static void ANDI()
2280
2295
{
 
2296
   check_r0_irt();
2281
2297
   irt = irs & (unsigned short)iimmediate;
2282
2298
   interp_addr+=4;
2283
2299
}
2284
2300
 
2285
2301
static void ORI()
2286
2302
{
 
2303
   check_r0_irt();
2287
2304
   irt = irs | (unsigned short)iimmediate;
2288
2305
   interp_addr+=4;
2289
2306
}
2290
2307
 
2291
2308
static void XORI()
2292
2309
{
 
2310
   check_r0_irt();
2293
2311
   irt = irs ^ (unsigned short)iimmediate;
2294
2312
   interp_addr+=4;
2295
2313
}
2296
2314
 
2297
2315
static void LUI()
2298
2316
{
 
2317
   check_r0_irt();
2299
2318
   irt32 = iimmediate << 16;
2300
2319
   sign_extended(irt);
2301
2320
   interp_addr+=4;
2464
2483
 
2465
2484
static void DADDI()
2466
2485
{
 
2486
   check_r0_irt();
2467
2487
   irt = irs + iimmediate;
2468
2488
   interp_addr+=4;
2469
2489
}
2470
2490
 
2471
2491
static void DADDIU()
2472
2492
{
 
2493
   check_r0_irt();
2473
2494
   irt = irs + iimmediate;
2474
2495
   interp_addr+=4;
2475
2496
}
2477
2498
static void LDL()
2478
2499
{
2479
2500
   unsigned long long int word = 0;
 
2501
   check_r0_irt();
2480
2502
   interp_addr+=4;
2481
2503
   switch ((iimmediate + irs32) & 7)
2482
2504
     {
2533
2555
static void LDR()
2534
2556
{
2535
2557
   unsigned long long int word = 0;
 
2558
   check_r0_irt();
2536
2559
   interp_addr+=4;
2537
2560
   switch ((iimmediate + irs32) & 7)
2538
2561
     {
2588
2611
 
2589
2612
static void LB()
2590
2613
{
 
2614
   check_r0_irt();
2591
2615
   interp_addr+=4;
2592
2616
   address = iimmediate + irs32;
2593
2617
   rdword = (unsigned long long *) &irt;
2597
2621
 
2598
2622
static void LH()
2599
2623
{
 
2624
   check_r0_irt();
2600
2625
   interp_addr+=4;
2601
2626
   address = iimmediate + irs32;
2602
2627
   rdword = (unsigned long long *) &irt;
2607
2632
static void LWL()
2608
2633
{
2609
2634
   unsigned long long int word = 0;
 
2635
   check_r0_irt();
2610
2636
   interp_addr+=4;
2611
2637
   switch ((iimmediate + irs32) & 3)
2612
2638
     {
2639
2665
 
2640
2666
static void LW()
2641
2667
{
 
2668
   check_r0_irt();
2642
2669
   address = iimmediate + irs32;
2643
2670
   rdword = (unsigned long long *) &irt;
2644
2671
   interp_addr+=4;
2648
2675
 
2649
2676
static void LBU()
2650
2677
{
 
2678
   check_r0_irt();
2651
2679
   interp_addr+=4;
2652
2680
   address = iimmediate + irs32;
2653
2681
   rdword = (unsigned long long *) &irt;
2656
2684
 
2657
2685
static void LHU()
2658
2686
{
 
2687
   check_r0_irt();
2659
2688
   interp_addr+=4;
2660
2689
   address = iimmediate + irs32;
2661
2690
   rdword = (unsigned long long *) &irt;
2665
2694
static void LWR()
2666
2695
{
2667
2696
   unsigned long long int word = 0;
 
2697
   check_r0_irt();
2668
2698
   interp_addr+=4;
2669
2699
   switch ((iimmediate + irs32) & 3)
2670
2700
     {
2696
2726
 
2697
2727
static void LWU()
2698
2728
{
 
2729
   check_r0_irt();
2699
2730
   address = iimmediate + irs32;
2700
2731
   rdword = (unsigned long long *) &irt;
2701
2732
   interp_addr+=4;
2927
2958
 
2928
2959
static void LL()
2929
2960
{
 
2961
   check_r0_irt();
2930
2962
   address = iimmediate + irs32;
2931
2963
   rdword = (unsigned long long *) &irt;
2932
2964
   interp_addr+=4;
2957
2989
 
2958
2990
static void LD()
2959
2991
{
 
2992
   check_r0_irt();
2960
2993
   interp_addr+=4;
2961
2994
   address = iimmediate + irs32;
2962
2995
   rdword = (unsigned long long *) &irt;
2965
2998
 
2966
2999
static void SC()
2967
3000
{
 
3001
   check_r0_irt();
2968
3002
   interp_addr+=4;
2969
3003
   if(llbit)
2970
3004
     {