Windows NT 4.0 source code leak
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

3619 lines
93 KiB

/***********************************************************************
* Microsoft Puma
*
* Microsoft Confidential. Copyright 1994-1996 Microsoft Corporation.
*
* Component:
*
* File: ppcdis.cpp
*
* File Comments:
*
*
***********************************************************************/
#include "pumap.h"
#include "ppc.h"
#include <ctype.h>
#include <iomanip.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <strstrea.h>
const TRMT DISPPC::mptrmtppctrmt[] =
{
trmtUnknown, // trmtppcUnknown,
trmtFallThrough, // trmtppcFallThrough,
trmtBra, // trmtppcBra,
#ifdef CASEJUMP
trmtBraCase, // trmtppcBraCase,
#endif
trmtBraInd, // trmtppcBraInd,
trmtBraCc, // trmtppcBraCc,
trmtBraCc, // trmtppcBraCcR,
trmtBraCcInd, // trmtppcBraCcInd,
trmtCall, // trmtppcCall,
trmtCallCc, // trmtppcCallCc,
trmtCallInd, // trmtppcCallInd,
trmtTrap, // trmtppcTrap,
trmtTrapCc, // trmtppcTrapCc,
#ifdef AFTERCATCH
trmtAfterCatch, // trmtppcAfterCatch
#endif
};
#define DEFCLS(trmtppc_, opcls1, opcls2, opcls3, opcls4, opcls5) \
{ trmtppc ## trmtppc_, { opcls ## opcls1, opcls ## opcls2, opcls ## opcls3, opcls ## opcls4, opcls ## opcls5 } }
const DISPPC::CLS DISPPC::rgcls[] =
{
DEFCLS(Unknown, None, None, None, None, None ), // iclsInvalid
DEFCLS(FallThrough, A_frD, A_frA, A_frB, None, None ), // iclsA_1
DEFCLS(FallThrough, A_frD, A_frA, A_frC, A_frB, None ), // iclsA_2
DEFCLS(FallThrough, A_frD, A_frB, None, None, None ), // iclsA_3
DEFCLS(FallThrough, A_frD, A_frA, A_frC, None, None ), // iclsA_4
DEFCLS(TrapCc, D_TO, D_rA, D_SIMM, None, None ), // iclsD_1
DEFCLS(FallThrough, D_rD, D_rA, D_SIMM, None, None ), // iclsD_2
DEFCLS(FallThrough, D_crfD, D_L, D_rA, D_UIMM, None ), // iclsD_3
DEFCLS(FallThrough, D_rA, D_rS, D_UIMM, None, None ), // iclsD_4
DEFCLS(FallThrough, D_rD, D_d, None, None, None ), // iclsD_5
DEFCLS(FallThrough, D_rS, D_d, None, None, None ), // iclsD_6
DEFCLS(FallThrough, D_frD, D_d, None, None, None ), // iclsD_7
DEFCLS(FallThrough, D_frS, D_d, None, None, None ), // iclsD_8
DEFCLS(FallThrough, D_rD, D_d, None, None, None ), // iclsD_9
DEFCLS(FallThrough, D_rD, D_d, None, None, None ), // iclsD_10
DEFCLS(FallThrough, D_frD, D_d, None, None, None ), // iclsD_11
DEFCLS(FallThrough, D_rS, D_d, None, None, None ), // iclsD_12
DEFCLS(FallThrough, D_frS, D_d, None, None, None ), // iclsD_13
DEFCLS(FallThrough, D_rD, D_SIMM, None, None, None ), // iclsD_14
DEFCLS(FallThrough, DS_rD, DS_ds, None, None, None ), // iclsDS_1
DEFCLS(FallThrough, DS_rS, DS_ds, None, None, None ), // iclsDS_2
DEFCLS(FallThrough, DS_rD, DS_ds, None, None, None ), // iclsDS_3
DEFCLS(FallThrough, DS_rS, DS_ds, None, None, None ), // iclsDS_4
DEFCLS(BraCc, B_BO, B_BI, B_BD, None, None ), // iclsBc
DEFCLS(Trap, None, None, None, None, None ), // iclsSc
DEFCLS(Bra, I_LI, None, None, None, None ), // iclsB
DEFCLS(FallThrough, M_rA, M_rS, M_SH, M_MB, M_ME ), // iclsM_1
DEFCLS(FallThrough, MD_rA, MD_rS, MD_SH, MD_MB, None ), // iclsMD_1
DEFCLS(FallThrough, MD_rA, MD_rS, MD_SH, MD_ME, None ), // iclsMD_2
DEFCLS(FallThrough, X_crfD, X_L, X_rA, X_rB, None ), // iclsX_1
DEFCLS(TrapCc, X_TO, X_rA, X_rB, None, None ), // iclsX_2
DEFCLS(FallThrough, X_rD, None, None, None, None ), // iclsX_3
DEFCLS(FallThrough, X_rD, X_rA, X_rB, None, None ), // iclsX_4
DEFCLS(FallThrough, X_rA, X_rS, X_rB, None, None ), // iclsX_5
DEFCLS(FallThrough, X_rA, X_rS, None, None, None ), // iclsX_6
DEFCLS(FallThrough, X_rA, X_rB, None, None, None ), // iclsX_7
DEFCLS(FallThrough, X_rS, X_rA, X_rB, None, None ), // iclsX_8
DEFCLS(FallThrough, X_SR, X_rS, None, None, None ), // iclsX_9
DEFCLS(FallThrough, X_rS, X_rB, None, None, None ), // iclsX_10
DEFCLS(FallThrough, X_rB, None, None, None, None ), // iclsX_11
DEFCLS(FallThrough, None, None, None, None, None ), // iclsX_12
DEFCLS(FallThrough, X_crfD, None, None, None, None ), // iclsX_13
DEFCLS(FallThrough, X_frD, X_rA, X_rB, None, None ), // iclsX_14
DEFCLS(FallThrough, X_rD, X_SR, None, None, None ), // iclsX_15
DEFCLS(FallThrough, X_rD, X_rA, X_NB, None, None ), // iclsX_16
DEFCLS(FallThrough, X_rD, X_rB, None, None, None ), // iclsX_17
DEFCLS(FallThrough, X_frS, X_rA, X_rB, None, None ), // iclsX_18
DEFCLS(FallThrough, X_rS, X_rA, X_NB, None, None ), // iclsX_19
DEFCLS(FallThrough, X_rA, X_rS, X_SH, None, None ), // iclsX_20
DEFCLS(FallThrough, X_rS, None, None, None, None ), // iclsX_21
DEFCLS(FallThrough, X_frD, X_frB, None, None, None ), // iclsX_22
DEFCLS(FallThrough, X_crfD, X_frA, X_frB, None, None ), // iclsX_23
DEFCLS(FallThrough, X_crbD, None, None, None, None ), // iclsX_24
DEFCLS(FallThrough, X_crfD, X_crfS, None, None, None ), // iclsX_25
DEFCLS(FallThrough, X_crfD, X_IMM, None, None, None ), // iclsX_26
DEFCLS(FallThrough, X_frD, None, None, None, None ), // iclsX_27
DEFCLS(FallThrough, X_rD, X_rA, None, None, None ), // iclsX_28
DEFCLS(FallThrough, X_rD, X_rA, X_rB, None, None ), // iclsX_29
DEFCLS(FallThrough, X_rA, X_rS, X_rB, None, None ), // iclsX_30
DEFCLS(FallThrough, X_rD, X_rA, X_rB, None, None ), // iclsX_31
DEFCLS(FallThrough, X_frD, X_rA, X_rB, None, None ), // iclsX_32
DEFCLS(FallThrough, X_rD, X_rA, X_rB, None, None ), // iclsX_33
DEFCLS(FallThrough, X_rS, X_rA, X_rB, None, None ), // iclsX_34
DEFCLS(FallThrough, X_frS, X_rA, X_rB, None, None ), // iclsX_35
DEFCLS(FallThrough, X_rS, X_rA, X_rB, None, None ), // iclsX_36
DEFCLS(FallThrough, XFL_FM, XFL_frB, None, None, None ), // iclsXFL_1
DEFCLS(FallThrough, XFX_CRM, XFX_rS, None, None, None ), // iclsXFX_1
DEFCLS(FallThrough, XFX_rD, XFX_SPR, None, None, None ), // iclsXFX_2
DEFCLS(FallThrough, XFX_rD, XFX_TBR, None, None, None ), // iclsXFX_3
DEFCLS(FallThrough, XFX_SPR, XFX_rS, None, None, None ), // iclsXFX_4
DEFCLS(FallThrough, XO_rD, XO_rA, XO_rB, None, None ), // iclsXO_1
DEFCLS(FallThrough, XO_rD, XO_rA, None, None, None ), // iclsXO_2
DEFCLS(FallThrough, XL_crfD, XL_crfS, None, None, None ), // iclsXL_1
DEFCLS(BraCcInd, XL_BO, XL_BI, None, None, None ), // iclsBclr
DEFCLS(FallThrough, XL_crbD, XL_crbA, XL_crbB, None, None ), // iclsXL_3
DEFCLS(BraInd, None, None, None, None, None ), // iclsXL_4
DEFCLS(FallThrough, None, None, None, None, None ), // iclsXL_5
DEFCLS(BraCcInd, XL_BO, XL_BI, None, None, None ), // iclsBcctr
DEFCLS(FallThrough, XS_rA, XS_rS, XS_SH, None, None ), // iclsXS_1
DEFCLS(Unknown, B_BI, B_BD, None, None, None ), // iclsBc2
DEFCLS(Unknown, B_CR, B_BD, None, None, None ), // iclsBc3
DEFCLS(Unknown, B_BD, None, None, None, None ), // iclsBc4
DEFCLS(Unknown, XL_BI, None, None, None, None ), // iclsBc5
DEFCLS(Unknown, XL_CR, None, None, None, None ), // iclsBc6
DEFCLS(Unknown, D_rA, D_SIMM, None, None, None ), // iclsTwi2
DEFCLS(Unknown, X_rA, X_rB, None, None, None ), // iclsTw2
};
#define DEFOPCD(szName, icls_) { szName, icls ## icls_ }
#define INVOPCD() DEFOPCD(NULL, Invalid)
// Main group identified by bits 31-26 of the instruction
const DISPPC::OPCD DISPPC::rgopcd[] =
{
INVOPCD(), // 0x0000 (Reserved)
INVOPCD(), // 0x0001 (Reserved)
DEFOPCD("~tdi", D_1 ), // 0x0002
DEFOPCD("~twi", D_1 ), // 0x0003
INVOPCD(), // 0x0004 (Reserved)
INVOPCD(), // 0x0005 (Reserved)
INVOPCD(), // 0x0006 (Reserved)
DEFOPCD("mulli", D_2 ), // 0x0007
DEFOPCD("subfic", D_2 ), // 0x0008
DEFOPCD("dozi", D_2 ), // 0x0009 Power
DEFOPCD("cmpli", D_3 ), // 0x000A
DEFOPCD("cmpi", D_3 ), // 0x000B
DEFOPCD("addic", D_2 ), // 0x000C
DEFOPCD("addic.", D_2 ), // 0x000D
DEFOPCD("~addi", D_2 ), // 0x000E
DEFOPCD("~addis", D_2 ), // 0x000F
DEFOPCD("~!@bc", Bc ), // 0x0010
DEFOPCD("sc", Sc ), // 0x0011
DEFOPCD("!@b", B ), // 0x0012
INVOPCD(), // 0x0013
DEFOPCD("#rlwimi", M_1 ), // 0x0014
DEFOPCD("#rlwinm", M_1 ), // 0x0015
DEFOPCD("#rlmi", M_1 ), // 0x0016 Power
DEFOPCD("#rlwnm", M_1 ), // 0x0017
DEFOPCD("~ori", D_4 ), // 0x0018
DEFOPCD("oris", D_4 ), // 0x0019
DEFOPCD("xori", D_4 ), // 0x001A
DEFOPCD("xoris", D_4 ), // 0x001B
DEFOPCD("andi.", D_4 ), // 0x001C
DEFOPCD("andis.", D_4 ), // 0x001D
INVOPCD(), // 0x001E
INVOPCD(), // 0x001F
DEFOPCD("lwz", D_5 ), // 0x0020
DEFOPCD("lwzu", D_10 ), // 0x0021
DEFOPCD("lbz", D_5 ), // 0x0022
DEFOPCD("lbzu", D_10 ), // 0x0023
DEFOPCD("stw", D_6 ), // 0x0024
DEFOPCD("stwu", D_12 ), // 0x0025
DEFOPCD("stb", D_6 ), // 0x0026
DEFOPCD("stbu", D_12 ), // 0x0027
DEFOPCD("lhz", D_5 ), // 0x0028
DEFOPCD("lhzu", D_10 ), // 0x0029
DEFOPCD("lha", D_5 ), // 0x002A
DEFOPCD("lhau", D_10 ), // 0x002B
DEFOPCD("sth", D_6 ), // 0x002C
DEFOPCD("sthu", D_12 ), // 0x002D
DEFOPCD("lmw", D_9 ), // 0x002E
DEFOPCD("stmw", D_6 ), // 0x002F
DEFOPCD("lfs", D_7 ), // 0x0030
DEFOPCD("lfsu", D_11 ), // 0x0031
DEFOPCD("lfd", D_7 ), // 0x0032
DEFOPCD("lfdu", D_11 ), // 0x0033
DEFOPCD("stfs", D_8 ), // 0x0034
DEFOPCD("stfsu", D_13 ), // 0x0035
DEFOPCD("stfd", D_8 ), // 0x0036
DEFOPCD("stfdu", D_13 ), // 0x0037
INVOPCD(), // 0x0038 (Reserved)
INVOPCD(), // 0x0039 (Reserved)
INVOPCD(), // 0x003A
INVOPCD(), // 0x003B
INVOPCD(), // 0x003C (Reserved)
INVOPCD(), // 0x003D (Reserved)
INVOPCD(), // 0x003E
INVOPCD(), // 0x003F
};
// Opcode 13 group identified by bits 10-1 of the instruction
const DISPPC::OPCD * const DISPPC::rgrgopcd13[] =
{
rgopcd13_00, //
rgopcd13_01, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
rgopcd13_10, //
NULL, //
rgopcd13_12, //
NULL, //
NULL, //
NULL, //
rgopcd13_16, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
};
const DISPPC::OPCD DISPPC::rgopcd13_00[] =
{
DEFOPCD("mcrf", XL_1 ), // 0x0000 0
INVOPCD(), // 0x0020 32
INVOPCD(), // 0x0040 64
INVOPCD(), // 0x0060 96
INVOPCD(), // 0x0080 128
INVOPCD(), // 0x00A0 160
INVOPCD(), // 0x00C0 192
INVOPCD(), // 0x00E0 224
INVOPCD(), // 0x0100 256
INVOPCD(), // 0x0120 288
INVOPCD(), // 0x0140 320
INVOPCD(), // 0x0160 352
INVOPCD(), // 0x0180 384
INVOPCD(), // 0x01A0 416
INVOPCD(), // 0x01C0 448
INVOPCD(), // 0x01E0 480
INVOPCD(), // 0x0200 512
INVOPCD(), // 0x0220 544
INVOPCD(), // 0x0240 576
INVOPCD(), // 0x0260 608
INVOPCD(), // 0x0280 640
INVOPCD(), // 0x02A0 672
INVOPCD(), // 0x02C0 704
INVOPCD(), // 0x02E0 736
INVOPCD(), // 0x0300 768
INVOPCD(), // 0x0320 800
INVOPCD(), // 0x0340 832
INVOPCD(), // 0x0360 864
INVOPCD(), // 0x0380 896
INVOPCD(), // 0x03A0 928
INVOPCD(), // 0x03C0 960
INVOPCD(), // 0x03E0 992
};
const DISPPC::OPCD DISPPC::rgopcd13_01[] =
{
INVOPCD(), // 0x0001 1
DEFOPCD("crnor", XL_3 ), // 0x0021 33
INVOPCD(), // 0x0041 65
INVOPCD(), // 0x0061 97
DEFOPCD("crandc", XL_3 ), // 0x0081 129
INVOPCD(), // 0x00A1 161
DEFOPCD("crxor", XL_3 ), // 0x00C1 193
DEFOPCD("crnand", XL_3 ), // 0x00E1 225
DEFOPCD("crand", XL_3 ), // 0x0101 257
DEFOPCD("creqv", XL_3 ), // 0x0121 289
INVOPCD(), // 0x0141 321
INVOPCD(), // 0x0161 353
INVOPCD(), // 0x0181 385
DEFOPCD("crorc", XL_3 ), // 0x01A1 417
DEFOPCD("cror", XL_3 ), // 0x01C1 449
INVOPCD(), // 0x01E1 481
INVOPCD(), // 0x0201 513
INVOPCD(), // 0x0221 545
INVOPCD(), // 0x0241 577
INVOPCD(), // 0x0261 609
INVOPCD(), // 0x0281 641
INVOPCD(), // 0x02A1 673
INVOPCD(), // 0x02C1 705
INVOPCD(), // 0x02E1 737
INVOPCD(), // 0x0301 769
INVOPCD(), // 0x0321 801
INVOPCD(), // 0x0341 833
INVOPCD(), // 0x0361 865
INVOPCD(), // 0x0381 897
INVOPCD(), // 0x03A1 929
INVOPCD(), // 0x03C1 961
INVOPCD(), // 0x03E1 993
};
const DISPPC::OPCD DISPPC::rgopcd13_10[] =
{
DEFOPCD("~!bclr", Bclr ), // 0x0010 16
INVOPCD(), // 0x0030 48
INVOPCD(), // 0x0050 80
INVOPCD(), // 0x0070 112
INVOPCD(), // 0x0090 144
INVOPCD(), // 0x00B0 176
INVOPCD(), // 0x00D0 208
INVOPCD(), // 0x00F0 240
INVOPCD(), // 0x0110 272
INVOPCD(), // 0x0130 304
INVOPCD(), // 0x0150 336
INVOPCD(), // 0x0170 368
INVOPCD(), // 0x0190 400
INVOPCD(), // 0x01B0 432
INVOPCD(), // 0x01D0 464
INVOPCD(), // 0x01F0 496
DEFOPCD("~!bcctr", Bcctr ), // 0x0210 528
INVOPCD(), // 0x0230 560
INVOPCD(), // 0x0250 592
INVOPCD(), // 0x0270 624
INVOPCD(), // 0x0290 656
INVOPCD(), // 0x02B0 688
INVOPCD(), // 0x02D0 720
INVOPCD(), // 0x02F0 752
INVOPCD(), // 0x0310 784
INVOPCD(), // 0x0330 816
INVOPCD(), // 0x0350 848
INVOPCD(), // 0x0370 880
INVOPCD(), // 0x0390 912
INVOPCD(), // 0x03B0 944
INVOPCD(), // 0x03D0 976
INVOPCD(), // 0x03F0 1008
};
const DISPPC::OPCD DISPPC::rgopcd13_12[] =
{
INVOPCD(), // 0x0012 18
DEFOPCD("rfi", XL_4 ), // 0x0032 50
INVOPCD(), // 0x0052 82
INVOPCD(), // 0x0072 114
INVOPCD(), // 0x0092 146
INVOPCD(), // 0x00B2 178
INVOPCD(), // 0x00D2 210
INVOPCD(), // 0x00F2 242
INVOPCD(), // 0x0112 274
INVOPCD(), // 0x0132 306
INVOPCD(), // 0x0152 338
INVOPCD(), // 0x0172 370
INVOPCD(), // 0x0192 402
INVOPCD(), // 0x01B2 434
INVOPCD(), // 0x01D2 466
INVOPCD(), // 0x01F2 498
INVOPCD(), // 0x0212 530
INVOPCD(), // 0x0232 562
INVOPCD(), // 0x0252 594
INVOPCD(), // 0x0272 626
INVOPCD(), // 0x0292 658
INVOPCD(), // 0x02B2 690
INVOPCD(), // 0x02D2 722
INVOPCD(), // 0x02F2 754
INVOPCD(), // 0x0312 786
INVOPCD(), // 0x0332 818
INVOPCD(), // 0x0352 850
INVOPCD(), // 0x0372 882
INVOPCD(), // 0x0392 914
INVOPCD(), // 0x03B2 946
INVOPCD(), // 0x03D2 978
INVOPCD(), // 0x03F2 1010
};
const DISPPC::OPCD DISPPC::rgopcd13_16[] =
{
INVOPCD(), // 0x0016 22
INVOPCD(), // 0x0036 54
INVOPCD(), // 0x0056 86
INVOPCD(), // 0x0076 118
DEFOPCD("isync", XL_5 ), // 0x0096 150
INVOPCD(), // 0x00B6 182
INVOPCD(), // 0x00D6 214
INVOPCD(), // 0x00F6 246
INVOPCD(), // 0x0116 278
INVOPCD(), // 0x0136 310
INVOPCD(), // 0x0156 342
INVOPCD(), // 0x0176 374
INVOPCD(), // 0x0196 406
INVOPCD(), // 0x01B6 438
INVOPCD(), // 0x01D6 470
INVOPCD(), // 0x01F6 502
INVOPCD(), // 0x0216 534
INVOPCD(), // 0x0236 566
INVOPCD(), // 0x0256 598
INVOPCD(), // 0x0276 630
INVOPCD(), // 0x0296 662
INVOPCD(), // 0x02B6 694
INVOPCD(), // 0x02D6 726
INVOPCD(), // 0x02F6 758
INVOPCD(), // 0x0316 790
INVOPCD(), // 0x0336 822
INVOPCD(), // 0x0356 854
INVOPCD(), // 0x0376 886
INVOPCD(), // 0x0396 918
INVOPCD(), // 0x03B6 950
INVOPCD(), // 0x03D6 982
INVOPCD(), // 0x03F6 1014
};
// Opcode 1E group identified by bits 5-1 of the instruction
const DISPPC::OPCD DISPPC::rgopcd1E[] =
{
DEFOPCD("#rldicl", MD_1 ), // 0x0000
DEFOPCD("#rldicl", MD_1 ), // 0x0001
DEFOPCD("#rldicr", MD_2 ), // 0x0002
DEFOPCD("#rldicr", MD_2 ), // 0x0003
DEFOPCD("#rldic", MD_1 ), // 0x0004
DEFOPCD("#rldic", MD_1 ), // 0x0005
DEFOPCD("#rldimi", MD_1 ), // 0x0006
DEFOPCD("#rldimi", MD_1 ), // 0x0007
DEFOPCD("#rldcl", MD_1 ), // 0x0008
DEFOPCD("#rldcr", MD_2 ), // 0x0009
INVOPCD(), // 0x000A (Reserved)
INVOPCD(), // 0x000B (Reserved)
INVOPCD(), // 0x000C (Reserved)
INVOPCD(), // 0x000D (Reserved)
INVOPCD(), // 0x000E (Reserved)
INVOPCD(), // 0x000F (Reserved)
};
// Opcode 1F group identified by bits 10-1 of the instruction
const DISPPC::OPCD * const DISPPC::rgrgopcd1F[] =
{
rgopcd1F_00, //
NULL, //
NULL, //
NULL, //
rgopcd1F_04, //
NULL, //
NULL, //
NULL, //
rgopcd1F_08, //
rgopcd1F_09, //
rgopcd1F_0A, //
rgopcd1F_0B, //
NULL, //
NULL, //
NULL, //
NULL, //
rgopcd1F_10, //
NULL, //
rgopcd1F_12, //
rgopcd1F_13, //
rgopcd1F_14, //
rgopcd1F_15, //
rgopcd1F_16, //
rgopcd1F_17, //
rgopcd1F_18, //
rgopcd1F_19, //
rgopcd1F_1A, //
rgopcd1F_1B, //
rgopcd1F_1C, //
rgopcd1F_1D, //
NULL, //
NULL, //
};
const DISPPC::OPCD DISPPC::rgopcd1F_00[] =
{
DEFOPCD("cmp", X_1 ), // 0x0000 0
DEFOPCD("cmpl", X_1 ), // 0x0020 32
INVOPCD(), // 0x0040 64
INVOPCD(), // 0x0060 96
INVOPCD(), // 0x0080 128
INVOPCD(), // 0x00A0 160
INVOPCD(), // 0x00C0 192
INVOPCD(), // 0x00E0 224
INVOPCD(), // 0x0100 256
INVOPCD(), // 0x0120 288
INVOPCD(), // 0x0140 320
INVOPCD(), // 0x0160 352
INVOPCD(), // 0x0180 384
INVOPCD(), // 0x01A0 416
INVOPCD(), // 0x01C0 448
INVOPCD(), // 0x01E0 480
DEFOPCD("mcrxr", X_13 ), // 0x0200 512
INVOPCD(), // 0x0220 544
INVOPCD(), // 0x0240 576
INVOPCD(), // 0x0260 608
INVOPCD(), // 0x0280 640
INVOPCD(), // 0x02A0 672
INVOPCD(), // 0x02C0 704
INVOPCD(), // 0x02E0 736
INVOPCD(), // 0x0300 768
INVOPCD(), // 0x0320 800
INVOPCD(), // 0x0340 832
INVOPCD(), // 0x0360 864
INVOPCD(), // 0x0380 896
INVOPCD(), // 0x03A0 928
INVOPCD(), // 0x03C0 960
INVOPCD(), // 0x03E0 992
};
const DISPPC::OPCD DISPPC::rgopcd1F_04[] =
{
DEFOPCD("~tw", X_2 ), // 0x0004 4
INVOPCD(), // 0x0024 36
DEFOPCD("~td", X_2 ), // 0x0044 68
INVOPCD(), // 0x0064 100
INVOPCD(), // 0x0084 132
INVOPCD(), // 0x00A4 164
INVOPCD(), // 0x00C4 196
INVOPCD(), // 0x00E4 228
INVOPCD(), // 0x0104 260
INVOPCD(), // 0x0124 292
INVOPCD(), // 0x0144 324
INVOPCD(), // 0x0164 356
INVOPCD(), // 0x0184 388
INVOPCD(), // 0x01A4 420
INVOPCD(), // 0x01C4 452
INVOPCD(), // 0x01E4 484
INVOPCD(), // 0x0204 516
INVOPCD(), // 0x0224 548
INVOPCD(), // 0x0244 580
INVOPCD(), // 0x0264 612
INVOPCD(), // 0x0284 644
INVOPCD(), // 0x02A4 676
INVOPCD(), // 0x02C4 708
INVOPCD(), // 0x02E4 740
INVOPCD(), // 0x0304 772
INVOPCD(), // 0x0324 804
INVOPCD(), // 0x0344 836
INVOPCD(), // 0x0364 868
INVOPCD(), // 0x0384 900
INVOPCD(), // 0x03A4 932
INVOPCD(), // 0x03C4 964
INVOPCD(), // 0x03E4 996
};
const DISPPC::OPCD DISPPC::rgopcd1F_08[] =
{
DEFOPCD("#subfc", XO_1 ), // 0x0008 8
DEFOPCD("#subf", XO_1 ), // 0x0028 40
INVOPCD(), // 0x0048 72
DEFOPCD("#neg", XO_2 ), // 0x0068 104
DEFOPCD("#subfe", XO_1 ), // 0x0088 136
INVOPCD(), // 0x00A8 168
DEFOPCD("#subfze", XO_2 ), // 0x00C8 200
DEFOPCD("#subfme", XO_2 ), // 0x00E8 232
DEFOPCD("#doz", XO_1 ), // 0x0108 264 Power
INVOPCD(), // 0x0128 296
INVOPCD(), // 0x0148 328
DEFOPCD("#abs", XO_2 ), // 0x0168 360 Power
INVOPCD(), // 0x0188 392
INVOPCD(), // 0x01A8 424
INVOPCD(), // 0x01C8 456
DEFOPCD("#nabs", XO_2 ), // 0x01E8 488 Power
DEFOPCD("#subfco", XO_1 ), // 0x0208 520
DEFOPCD("#subfo", XO_1 ), // 0x0228 552
INVOPCD(), // 0x0248 584
DEFOPCD("#nego", XO_2 ), // 0x0268 616
DEFOPCD("#subfeo", XO_1 ), // 0x0288 648
INVOPCD(), // 0x02A8 680
DEFOPCD("#subfzeo", XO_2 ), // 0x02C8 712
DEFOPCD("#subfmeo", XO_2 ), // 0x02E8 744
DEFOPCD("#dozo", XO_1 ), // 0x0308 776 Power
INVOPCD(), // 0x0328 808
INVOPCD(), // 0x0348 840
DEFOPCD("#abso", XO_2 ), // 0x0368 872 Power
INVOPCD(), // 0x0388 904
INVOPCD(), // 0x03A8 936
INVOPCD(), // 0x03C8 968
DEFOPCD("#nabso", XO_2 ), // 0x03E8 1000 Power
};
const DISPPC::OPCD DISPPC::rgopcd1F_09[] =
{
DEFOPCD("#mulhdu", XO_1 ), // 0x0009 9
INVOPCD(), // 0x0029 41
DEFOPCD("#mulhd", XO_1 ), // 0x0049 73
INVOPCD(), // 0x0069 105
INVOPCD(), // 0x0089 137
INVOPCD(), // 0x00A9 169
INVOPCD(), // 0x00C9 201
DEFOPCD("#mulld", XO_1 ), // 0x00E9 233
INVOPCD(), // 0x0109 265
INVOPCD(), // 0x0129 297
INVOPCD(), // 0x0149 329
INVOPCD(), // 0x0169 361
INVOPCD(), // 0x0189 393
INVOPCD(), // 0x01A9 425
DEFOPCD("#divdu", XO_1 ), // 0x01C9 457
DEFOPCD("#divd", XO_1 ), // 0x01E9 489
INVOPCD(), // 0x0209 521
INVOPCD(), // 0x0229 553
INVOPCD(), // 0x0249 585
INVOPCD(), // 0x0269 617
INVOPCD(), // 0x0289 649
INVOPCD(), // 0x02A9 681
INVOPCD(), // 0x02C9 713
DEFOPCD("#mulldo", XO_1 ), // 0x02E9 745
INVOPCD(), // 0x0309 777
INVOPCD(), // 0x0329 809
INVOPCD(), // 0x0349 841
INVOPCD(), // 0x0369 873
INVOPCD(), // 0x0389 905
INVOPCD(), // 0x03A9 937
DEFOPCD("#divduo", XO_1 ), // 0x03C9 969
DEFOPCD("#divdo", XO_1 ), // 0x03E9 1001
};
const DISPPC::OPCD DISPPC::rgopcd1F_0A[] =
{
DEFOPCD("#addc", XO_1 ), // 0x000A 10
INVOPCD(), // 0x002A 42
INVOPCD(), // 0x004A 74
INVOPCD(), // 0x006A 106
DEFOPCD("#adde", XO_1 ), // 0x008A 138
INVOPCD(), // 0x00AA 170
DEFOPCD("#addze", XO_2 ), // 0x00CA 202
DEFOPCD("#addme", XO_2 ), // 0x00EA 234
DEFOPCD("#add", XO_1 ), // 0x010A 266
INVOPCD(), // 0x012A 298
INVOPCD(), // 0x014A 330
INVOPCD(), // 0x016A 362
INVOPCD(), // 0x018A 394
INVOPCD(), // 0x01AA 426
INVOPCD(), // 0x01CA 458
INVOPCD(), // 0x01EA 490
DEFOPCD("#addco", XO_1 ), // 0x020A 522
INVOPCD(), // 0x022A 554
INVOPCD(), // 0x024A 586
INVOPCD(), // 0x026A 618
DEFOPCD("#addeo", XO_1 ), // 0x028A 650
INVOPCD(), // 0x02AA 682
DEFOPCD("#addzeo", XO_2 ), // 0x02CA 714
DEFOPCD("#addmeo", XO_2 ), // 0x02EA 746
DEFOPCD("#addo", XO_1 ), // 0x030A 778
INVOPCD(), // 0x032A 810
INVOPCD(), // 0x034A 842
INVOPCD(), // 0x036A 874
INVOPCD(), // 0x038A 906
INVOPCD(), // 0x03AA 938
INVOPCD(), // 0x03CA 970
INVOPCD(), // 0x03EA 1002
};
const DISPPC::OPCD DISPPC::rgopcd1F_0B[] =
{
DEFOPCD("#mulhwu", XO_1 ), // 0x000B 11
INVOPCD(), // 0x002B 43
DEFOPCD("#mulhw", XO_1 ), // 0x004B 75
DEFOPCD("#mul", XO_1 ), // 0x006B 107 Power
INVOPCD(), // 0x008B 139
INVOPCD(), // 0x00AB 171
INVOPCD(), // 0x00CB 203
DEFOPCD("#mullw", XO_1 ), // 0x00EB 235
INVOPCD(), // 0x010B 267
INVOPCD(), // 0x012B 299
DEFOPCD("#div", XO_1 ), // 0x014B 331
DEFOPCD("#divs", XO_1 ), // 0x016B 363 Power
INVOPCD(), // 0x018B 395
INVOPCD(), // 0x01AB 427
DEFOPCD("#divwu", XO_1 ), // 0x01CB 459
DEFOPCD("#divw", XO_1 ), // 0x01EB 491
INVOPCD(), // 0x020B 523
INVOPCD(), // 0x022B 555
INVOPCD(), // 0x024B 587
DEFOPCD("#mulo", XO_1 ), // 0x026B 619 Power
INVOPCD(), // 0x028B 651
INVOPCD(), // 0x02AB 683
INVOPCD(), // 0x02CB 715
DEFOPCD("#mullwo", XO_1 ), // 0x02EB 747
INVOPCD(), // 0x030B 779
INVOPCD(), // 0x032B 811
DEFOPCD("#divo", XO_1 ), // 0x034B 843 Power
DEFOPCD("#divso", XO_1 ), // 0x036B 875 Power
INVOPCD(), // 0x038B 907
INVOPCD(), // 0x03AB 939
DEFOPCD("#divwuo", XO_1 ), // 0x03CB 971
DEFOPCD("#divwo", XO_1 ), // 0x03EB 1003
};
const DISPPC::OPCD DISPPC::rgopcd1F_10[] =
{
INVOPCD(), // 0x0010 16
INVOPCD(), // 0x0030 48
INVOPCD(), // 0x0050 80
INVOPCD(), // 0x0070 112
DEFOPCD("mtcrf", XFX_1 ), // 0x0090 144
INVOPCD(), // 0x00B0 176
INVOPCD(), // 0x00D0 208
INVOPCD(), // 0x00F0 240
INVOPCD(), // 0x0110 272
INVOPCD(), // 0x0130 304
INVOPCD(), // 0x0150 336
INVOPCD(), // 0x0170 368
INVOPCD(), // 0x0190 400
INVOPCD(), // 0x01B0 432
INVOPCD(), // 0x01D0 464
INVOPCD(), // 0x01F0 496
INVOPCD(), // 0x0210 528
INVOPCD(), // 0x0230 560
INVOPCD(), // 0x0250 592
INVOPCD(), // 0x0270 624
INVOPCD(), // 0x0290 656
INVOPCD(), // 0x02B0 688
INVOPCD(), // 0x02D0 720
INVOPCD(), // 0x02F0 752
INVOPCD(), // 0x0310 784
INVOPCD(), // 0x0330 816
INVOPCD(), // 0x0350 848
INVOPCD(), // 0x0370 880
INVOPCD(), // 0x0390 912
INVOPCD(), // 0x03B0 944
INVOPCD(), // 0x03D0 976
INVOPCD(), // 0x03F0 1008
};
const DISPPC::OPCD DISPPC::rgopcd1F_12[] =
{
INVOPCD(), // 0x0012 18
INVOPCD(), // 0x0032 50
INVOPCD(), // 0x0052 82
INVOPCD(), // 0x0072 114
DEFOPCD("mtmsr", X_21 ), // 0x0092 146
INVOPCD(), // 0x00B2 178
DEFOPCD("mtsr", X_9 ), // 0x00D2 210
DEFOPCD("mtsrin", X_10 ), // 0x00F2 242
INVOPCD(), // 0x0112 274
DEFOPCD("tlbie", X_11 ), // 0x0132 306
INVOPCD(), // 0x0152 338
DEFOPCD("tlbia", X_12 ), // 0x0172 370
INVOPCD(), // 0x0192 402
DEFOPCD("slbie", X_11 ), // 0x01B2 434
INVOPCD(), // 0x01D2 466
DEFOPCD("slbia", X_12 ), // 0x01F2 498
INVOPCD(), // 0x0212 530
INVOPCD(), // 0x0232 562
INVOPCD(), // 0x0252 594
INVOPCD(), // 0x0272 626
INVOPCD(), // 0x0292 658
INVOPCD(), // 0x02B2 690
INVOPCD(), // 0x02D2 722
INVOPCD(), // 0x02F2 754
INVOPCD(), // 0x0312 786
INVOPCD(), // 0x0332 818
INVOPCD(), // 0x0352 850
INVOPCD(), // 0x0372 882
INVOPCD(), // 0x0392 914
INVOPCD(), // 0x03B2 946
INVOPCD(), // 0x03D2 978
INVOPCD(), // 0x03F2 1010
};
const DISPPC::OPCD DISPPC::rgopcd1F_13[] =
{
DEFOPCD("mfcr", X_3 ), // 0x0013 19
INVOPCD(), // 0x0033 51
DEFOPCD("mfmsr", X_3 ), // 0x0053 83
INVOPCD(), // 0x0073 115
INVOPCD(), // 0x0093 147
INVOPCD(), // 0x00B3 179
INVOPCD(), // 0x00D3 211
INVOPCD(), // 0x00F3 243
INVOPCD(), // 0x0113 275
INVOPCD(), // 0x0133 307
DEFOPCD("~mfspr", XFX_2 ), // 0x0153 339
DEFOPCD("mftb", XFX_3 ), // 0x0173 371
INVOPCD(), // 0x0193 403
INVOPCD(), // 0x01B3 435
DEFOPCD("~mtspr", XFX_4 ), // 0x01D3 467
INVOPCD(), // 0x01F3 499
DEFOPCD("clcs", X_28 ), // 0x0213 531 Power
INVOPCD(), // 0x0233 563
DEFOPCD("mfsr", X_15 ), // 0x0253 595
INVOPCD(), // 0x0273 627
DEFOPCD("mfsrin", X_17 ), // 0x0293 659
INVOPCD(), // 0x02B3 691
INVOPCD(), // 0x02D3 723
INVOPCD(), // 0x02F3 755
INVOPCD(), // 0x0313 787
INVOPCD(), // 0x0333 819
INVOPCD(), // 0x0353 851
INVOPCD(), // 0x0373 883
INVOPCD(), // 0x0393 915
INVOPCD(), // 0x03B3 947
INVOPCD(), // 0x03D3 979
INVOPCD(), // 0x03F3 1011
};
const DISPPC::OPCD DISPPC::rgopcd1F_14[] =
{
DEFOPCD("lwarx", X_4 ), // 0x0014 20
INVOPCD(), // 0x0034 52
DEFOPCD("ldarx", X_4 ), // 0x0054 84
INVOPCD(), // 0x0074 116
INVOPCD(), // 0x0094 148
INVOPCD(), // 0x00B4 180
INVOPCD(), // 0x00D4 212
INVOPCD(), // 0x00F4 244
INVOPCD(), // 0x0114 276
INVOPCD(), // 0x0134 308
INVOPCD(), // 0x0154 340
INVOPCD(), // 0x0174 372
INVOPCD(), // 0x0194 404
INVOPCD(), // 0x01B4 436
DEFOPCD("dcbi", X_7 ), // 0x01D4 468
INVOPCD(), // 0x01F4 500
INVOPCD(), // 0x0214 532
INVOPCD(), // 0x0234 564
INVOPCD(), // 0x0254 596
INVOPCD(), // 0x0274 628
INVOPCD(), // 0x0294 660
INVOPCD(), // 0x02B4 692
INVOPCD(), // 0x02D4 724
INVOPCD(), // 0x02F4 756
INVOPCD(), // 0x0314 788
INVOPCD(), // 0x0334 820
INVOPCD(), // 0x0354 852
INVOPCD(), // 0x0374 884
INVOPCD(), // 0x0394 916
INVOPCD(), // 0x03B4 948
INVOPCD(), // 0x03D4 980
INVOPCD(), // 0x03F4 1012
};
const DISPPC::OPCD DISPPC::rgopcd1F_15[] =
{
DEFOPCD("ldx", X_4 ), // 0x0015 21
DEFOPCD("ldux", X_31 ), // 0x0035 53
INVOPCD(), // 0x0055 85
INVOPCD(), // 0x0075 117
DEFOPCD("stdx", X_8 ), // 0x0095 149
DEFOPCD("stdux", X_34 ), // 0x00B5 181
INVOPCD(), // 0x00D5 213
INVOPCD(), // 0x00F5 245
DEFOPCD("#lscbx", X_33 ), // 0x0115 277 Power
INVOPCD(), // 0x0135 309
DEFOPCD("lwax", X_4 ), // 0x0155 341
DEFOPCD("lwaux", X_31 ), // 0x0175 373
INVOPCD(), // 0x0195 405
INVOPCD(), // 0x01B5 437
INVOPCD(), // 0x01D5 469
INVOPCD(), // 0x01F5 501
DEFOPCD("lswx", X_4 ), // 0x0215 533
INVOPCD(), // 0x0235 565
DEFOPCD("lswi", X_16 ), // 0x0255 597
INVOPCD(), // 0x0275 629
DEFOPCD("stswx", X_8 ), // 0x0295 661
INVOPCD(), // 0x02B5 693
DEFOPCD("stswi", X_19 ), // 0x02D5 725
INVOPCD(), // 0x02F5 757
INVOPCD(), // 0x0315 789
INVOPCD(), // 0x0335 821
INVOPCD(), // 0x0355 853
INVOPCD(), // 0x0375 885
INVOPCD(), // 0x0395 917
INVOPCD(), // 0x03B5 949
INVOPCD(), // 0x03D5 981
INVOPCD(), // 0x03F5 1013
};
const DISPPC::OPCD DISPPC::rgopcd1F_16[] =
{
INVOPCD(), // 0x0016 22
DEFOPCD("dcbst", X_7 ), // 0x0036 54
DEFOPCD("dcbf", X_7 ), // 0x0056 86
INVOPCD(), // 0x0076 118
DEFOPCD("stwcx.", X_36 ), // 0x0096 150
INVOPCD(), // 0x00B6 182
DEFOPCD("stdcx.", X_36 ), // 0x00D6 214
DEFOPCD("dcbtst", X_7 ), // 0x00F6 246
DEFOPCD("dcbt", X_7 ), // 0x0116 278
DEFOPCD("eciwx", X_29 ), // 0x0136 310
INVOPCD(), // 0x0156 342
INVOPCD(), // 0x0176 374
INVOPCD(), // 0x0196 406
DEFOPCD("ecowx", X_30 ), // 0x01B6 438
INVOPCD(), // 0x01D6 470
INVOPCD(), // 0x01F6 502
DEFOPCD("lwbrx", X_4 ), // 0x0216 534
DEFOPCD("tlbsync", X_12 ), // 0x0236 566
DEFOPCD("sync", X_12 ), // 0x0256 598
INVOPCD(), // 0x0276 630
DEFOPCD("stwbrx", X_8 ), // 0x0296 662
INVOPCD(), // 0x02B6 694
INVOPCD(), // 0x02D6 726
INVOPCD(), // 0x02F6 758
DEFOPCD("lhbrx", X_4 ), // 0x0316 790
INVOPCD(), // 0x0336 822
DEFOPCD("eieio", X_12 ), // 0x0356 854
INVOPCD(), // 0x0376 886
DEFOPCD("sthbrx", X_8 ), // 0x0396 918
INVOPCD(), // 0x03B6 950
DEFOPCD("icbi", X_7 ), // 0x03D6 982
DEFOPCD("dcbz", X_7 ), // 0x03F6 1014
};
const DISPPC::OPCD DISPPC::rgopcd1F_17[] =
{
DEFOPCD("lwzx", X_4 ), // 0x0017 23
DEFOPCD("lwzux", X_31 ), // 0x0037 55
DEFOPCD("lbzx", X_4 ), // 0x0057 87
DEFOPCD("lbzux", X_31 ), // 0x0077 119
DEFOPCD("stwx", X_8 ), // 0x0097 151
DEFOPCD("stwux", X_34 ), // 0x00B7 183
DEFOPCD("stbx", X_8 ), // 0x00D7 215
DEFOPCD("stbux", X_34 ), // 0x00F7 247
DEFOPCD("lhzx", X_4 ), // 0x0117 279
DEFOPCD("lhzux", X_31 ), // 0x0137 311
DEFOPCD("lhax", X_4 ), // 0x0157 343
DEFOPCD("lhaux", X_31 ), // 0x0177 375
DEFOPCD("sthx", X_8 ), // 0x0197 407
DEFOPCD("sthux", X_34 ), // 0x01B7 439
INVOPCD(), // 0x01D7 471
INVOPCD(), // 0x01F7 503
DEFOPCD("lfsx", X_14 ), // 0x0217 535
DEFOPCD("lfsux", X_32 ), // 0x0237 567
DEFOPCD("lfdx", X_14 ), // 0x0257 599
DEFOPCD("lfdux", X_32 ), // 0x0277 631
DEFOPCD("stfsx", X_18 ), // 0x0297 663
DEFOPCD("stfsux", X_35 ), // 0x02B7 695
DEFOPCD("stfdx", X_18 ), // 0x02D7 727
DEFOPCD("stfdux", X_35 ), // 0x02F7 759
INVOPCD(), // 0x0317 791
INVOPCD(), // 0x0337 823
INVOPCD(), // 0x0357 855
INVOPCD(), // 0x0377 887
INVOPCD(), // 0x0397 919
INVOPCD(), // 0x03B7 951
DEFOPCD("stfiwx", X_18 ), // 0x03D7 983
INVOPCD(), // 0x03F7 1015
};
const DISPPC::OPCD DISPPC::rgopcd1F_18[] =
{
DEFOPCD("#slw", X_5 ), // 0x0018 24
INVOPCD(), // 0x0038 56
INVOPCD(), // 0x0058 88
INVOPCD(), // 0x0078 120
DEFOPCD("#slq", X_5 ), // 0x0098 152 Power
DEFOPCD("#sliq", X_20 ), // 0x00B8 184 Power
DEFOPCD("#sllq", X_5 ), // 0x00D8 216 Power
DEFOPCD("#slliq", X_20 ), // 0x00F8 248 Power
INVOPCD(), // 0x0118 280
INVOPCD(), // 0x0138 312
INVOPCD(), // 0x0158 344
INVOPCD(), // 0x0178 376
INVOPCD(), // 0x0198 408
INVOPCD(), // 0x01B8 440
INVOPCD(), // 0x01D8 472
INVOPCD(), // 0x01F8 504
DEFOPCD("#srw", X_5 ), // 0x0218 536
INVOPCD(), // 0x0238 568
INVOPCD(), // 0x0258 600
INVOPCD(), // 0x0278 632
DEFOPCD("#srq", X_5 ), // 0x0298 664 Power
DEFOPCD("#sriq", X_20 ), // 0x02B8 696 Power
DEFOPCD("#srlq", X_5 ), // 0x02D8 728 Power
DEFOPCD("#srliq", X_20 ), // 0x02F8 760 Power
DEFOPCD("#sraw", X_5 ), // 0x0318 792
DEFOPCD("#srawi", X_20 ), // 0x0338 824
INVOPCD(), // 0x0358 856
INVOPCD(), // 0x0378 888
DEFOPCD("#sraq", X_5 ), // 0x0398 920 Power
DEFOPCD("#sraiq", X_20 ), // 0x03B8 952 Power
INVOPCD(), // 0x03D8 984
INVOPCD(), // 0x03F8 1016
};
const DISPPC::OPCD DISPPC::rgopcd1F_19[] =
{
INVOPCD(), // 0x0019 25
INVOPCD(), // 0x0039 57
INVOPCD(), // 0x0059 89
INVOPCD(), // 0x0079 121
DEFOPCD("#sle", X_5 ), // 0x0099 153 Power
INVOPCD(), // 0x00B9 185
DEFOPCD("#sleq", X_5 ), // 0x00D9 217 Power
INVOPCD(), // 0x00F9 249
INVOPCD(), // 0x0119 281
INVOPCD(), // 0x0139 313
INVOPCD(), // 0x0159 345
INVOPCD(), // 0x0179 377
INVOPCD(), // 0x0199 409
INVOPCD(), // 0x01B9 441
INVOPCD(), // 0x01D9 473
INVOPCD(), // 0x01F9 505
DEFOPCD("#rrib", X_5 ), // 0x0219 537 Power
INVOPCD(), // 0x0239 569
INVOPCD(), // 0x0259 601
INVOPCD(), // 0x0279 633
DEFOPCD("#sre", X_5 ), // 0x0299 665 Power
INVOPCD(), // 0x02B9 697
DEFOPCD("#sreq", X_5 ), // 0x02D9 729 Power
INVOPCD(), // 0x02F9 761
INVOPCD(), // 0x0319 793
INVOPCD(), // 0x0339 825
INVOPCD(), // 0x0359 857
INVOPCD(), // 0x0379 889
DEFOPCD("#srea", X_5 ), // 0x0399 921 Power
INVOPCD(), // 0x03B9 953
INVOPCD(), // 0x03D9 985
INVOPCD(), // 0x03F9 1017
};
const DISPPC::OPCD DISPPC::rgopcd1F_1A[] =
{
DEFOPCD("#cntlzw", X_6 ), // 0x001A 26
DEFOPCD("#cntlzd", X_6 ), // 0x003A 58
INVOPCD(), // 0x005A 90
INVOPCD(), // 0x007A 122
INVOPCD(), // 0x009A 154
INVOPCD(), // 0x00BA 186
INVOPCD(), // 0x00DA 218
INVOPCD(), // 0x00FA 250
INVOPCD(), // 0x011A 282
INVOPCD(), // 0x013A 314
INVOPCD(), // 0x015A 346
INVOPCD(), // 0x017A 378
INVOPCD(), // 0x019A 410
INVOPCD(), // 0x01BA 442
INVOPCD(), // 0x01DA 474
INVOPCD(), // 0x01FA 506
INVOPCD(), // 0x021A 538
INVOPCD(), // 0x023A 570
INVOPCD(), // 0x025A 602
INVOPCD(), // 0x027A 634
INVOPCD(), // 0x029A 666
INVOPCD(), // 0x02BA 698
INVOPCD(), // 0x02DA 730
INVOPCD(), // 0x02FA 762
DEFOPCD("#srad", X_5 ), // 0x031A 794
DEFOPCD("#sradi", XS_1 ), // 0x033A 826
INVOPCD(), // 0x035A 858
INVOPCD(), // 0x037A 890
DEFOPCD("#extsh", X_6 ), // 0x039A 922
DEFOPCD("#extsb", X_6 ), // 0x03BA 954
DEFOPCD("#extsw", X_6 ), // 0x03DA 986
INVOPCD(), // 0x03FA 1018
};
const DISPPC::OPCD DISPPC::rgopcd1F_1B[] =
{
DEFOPCD("#sld", X_5 ), // 0x001B 27
INVOPCD(), // 0x003B 59
INVOPCD(), // 0x005B 91
INVOPCD(), // 0x007B 123
INVOPCD(), // 0x009B 155
INVOPCD(), // 0x00BB 187
INVOPCD(), // 0x00DB 219
INVOPCD(), // 0x00FB 251
INVOPCD(), // 0x011B 283
INVOPCD(), // 0x013B 315
INVOPCD(), // 0x015B 347
INVOPCD(), // 0x017B 379
INVOPCD(), // 0x019B 411
INVOPCD(), // 0x01BB 443
INVOPCD(), // 0x01DB 475
INVOPCD(), // 0x01FB 507
DEFOPCD("#srd", X_5 ), // 0x021B 539
INVOPCD(), // 0x023B 571
INVOPCD(), // 0x025B 603
INVOPCD(), // 0x027B 635
INVOPCD(), // 0x029B 667
INVOPCD(), // 0x02BB 699
INVOPCD(), // 0x02DB 731
INVOPCD(), // 0x02FB 763
INVOPCD(), // 0x031B 795
DEFOPCD("#sradi", XS_1 ), // 0x033B 827
INVOPCD(), // 0x035B 859
INVOPCD(), // 0x037B 891
INVOPCD(), // 0x039B 923
INVOPCD(), // 0x03BB 955
INVOPCD(), // 0x03DB 987
INVOPCD(), // 0x03FB 1019
};
const DISPPC::OPCD DISPPC::rgopcd1F_1C[] =
{
DEFOPCD("#and", X_5 ), // 0x001C 28
DEFOPCD("#andc", X_5 ), // 0x003C 60
INVOPCD(), // 0x005C 92
DEFOPCD("~#nor", X_5 ), // 0x007C 124
INVOPCD(), // 0x009C 156
INVOPCD(), // 0x00BC 188
INVOPCD(), // 0x00DC 220
INVOPCD(), // 0x00FC 252
DEFOPCD("#eqv", X_5 ), // 0x011C 284
DEFOPCD("#xor", X_5 ), // 0x013C 316
INVOPCD(), // 0x015C 348
INVOPCD(), // 0x017C 380
DEFOPCD("#orc", X_5 ), // 0x019C 412
DEFOPCD("~#or", X_5 ), // 0x01BC 444
DEFOPCD("#nand", X_5 ), // 0x01DC 476
INVOPCD(), // 0x01FC 508
INVOPCD(), // 0x021C 540
INVOPCD(), // 0x023C 572
INVOPCD(), // 0x025C 604
INVOPCD(), // 0x027C 636
INVOPCD(), // 0x029C 668
INVOPCD(), // 0x02BC 700
INVOPCD(), // 0x02DC 732
INVOPCD(), // 0x02FC 764
INVOPCD(), // 0x031C 796
INVOPCD(), // 0x033C 828
INVOPCD(), // 0x035C 860
INVOPCD(), // 0x037C 892
INVOPCD(), // 0x039C 924
INVOPCD(), // 0x03BC 956
INVOPCD(), // 0x03DC 988
INVOPCD(), // 0x03FC 1020
};
const DISPPC::OPCD DISPPC::rgopcd1F_1D[] =
{
DEFOPCD("#maskg", X_5 ), // 0x001D 29 Power
INVOPCD(), // 0x003D 61
INVOPCD(), // 0x005D 93
INVOPCD(), // 0x007D 125
INVOPCD(), // 0x009D 157
INVOPCD(), // 0x00BD 189
INVOPCD(), // 0x00DD 221
INVOPCD(), // 0x00FD 253
INVOPCD(), // 0x011D 285
INVOPCD(), // 0x013D 317
INVOPCD(), // 0x015D 349
INVOPCD(), // 0x017D 381
INVOPCD(), // 0x019D 413
INVOPCD(), // 0x01BD 445
INVOPCD(), // 0x01DD 477
INVOPCD(), // 0x01FD 509
DEFOPCD("#maskir", X_5 ), // 0x021D 541 Power
INVOPCD(), // 0x023D 573
INVOPCD(), // 0x025D 605
INVOPCD(), // 0x027D 637
INVOPCD(), // 0x029D 669
INVOPCD(), // 0x02BD 701
INVOPCD(), // 0x02DD 733
INVOPCD(), // 0x02FD 765
INVOPCD(), // 0x031D 797
INVOPCD(), // 0x033D 829
INVOPCD(), // 0x035D 861
INVOPCD(), // 0x037D 893
INVOPCD(), // 0x039D 925
INVOPCD(), // 0x03BD 957
INVOPCD(), // 0x03DD 989
INVOPCD(), // 0x03FD 1021
};
// Opcode 3A group identified by bits 1-0 of the instruction
const DISPPC::OPCD DISPPC::rgopcd3A[] =
{
DEFOPCD("ld", DS_1 ), // 0x0000
DEFOPCD("ldu", DS_3 ), // 0x0001
DEFOPCD("lwa", DS_1 ), // 0x0002
INVOPCD(), // 0x0003 (Reserved)
};
// Opcode 3B group identified by bits 5-1 of the instruction
const DISPPC::OPCD DISPPC::rgopcd3B[] =
{
INVOPCD(), // 0x0000
INVOPCD(), // 0x0001
INVOPCD(), // 0x0002
INVOPCD(), // 0x0003
INVOPCD(), // 0x0004
INVOPCD(), // 0x0005
INVOPCD(), // 0x0006
INVOPCD(), // 0x0007
INVOPCD(), // 0x0008
INVOPCD(), // 0x0009
INVOPCD(), // 0x000A
INVOPCD(), // 0x000B
INVOPCD(), // 0x000C
INVOPCD(), // 0x000D
INVOPCD(), // 0x000E
INVOPCD(), // 0x000F
INVOPCD(), // 0x0010
INVOPCD(), // 0x0011
DEFOPCD("#fdivs", A_1 ), // 0x0012
INVOPCD(), // 0x0013
DEFOPCD("#fsubs", A_1 ), // 0x0014
DEFOPCD("#fadds", A_1 ), // 0x0015
DEFOPCD("#fsqrts", A_3 ), // 0x0016
INVOPCD(), // 0x0017
DEFOPCD("#fres", A_3 ), // 0x0018
DEFOPCD("#fmuls", A_4 ), // 0x0019
INVOPCD(), // 0x001A
INVOPCD(), // 0x001B
DEFOPCD("#fmsubs", A_2 ), // 0x001C
DEFOPCD("#fmadds", A_2 ), // 0x001D
DEFOPCD("#fnmsubs", A_2 ), // 0x001E
DEFOPCD("#fnmadds", A_2 ), // 0x001F
};
// Opcode 3E group identified by bits 1-0 of the instruction
const DISPPC::OPCD DISPPC::rgopcd3E[] =
{
DEFOPCD("std", DS_2 ), // 0x0000
DEFOPCD("stdu", DS_4 ), // 0x0001
INVOPCD(), // 0x0002 (Reserved)
INVOPCD(), // 0x0003 (Reserved)
};
// Opcode 3F group identified by bits 10-1 of the instruction
const DISPPC::OPCD DISPPC::rgopcd3F[] =
{
INVOPCD(), // 0x0000
INVOPCD(), // 0x0001
INVOPCD(), // 0x0002
INVOPCD(), // 0x0003
INVOPCD(), // 0x0004
INVOPCD(), // 0x0005
INVOPCD(), // 0x0006
INVOPCD(), // 0x0007
INVOPCD(), // 0x0008
INVOPCD(), // 0x0009
INVOPCD(), // 0x000A
INVOPCD(), // 0x000B
INVOPCD(), // 0x000C
INVOPCD(), // 0x000D
INVOPCD(), // 0x000E
INVOPCD(), // 0x000F
INVOPCD(), // 0x0010
INVOPCD(), // 0x0011
DEFOPCD("#fdiv", A_1 ), // 0x0012
INVOPCD(), // 0x0013
DEFOPCD("#fsub", A_1 ), // 0x0014
DEFOPCD("#fadd", A_1 ), // 0x0015
DEFOPCD("#fsqrt", A_3 ), // 0x0016
DEFOPCD("#fsel", A_2 ), // 0x0017
INVOPCD(), // 0x0018
DEFOPCD("#fmul", A_4 ), // 0x0019
DEFOPCD("#frsqrte", A_3 ), // 0x001A
INVOPCD(), // 0x001B
DEFOPCD("#fmsub", A_2 ), // 0x001C
DEFOPCD("#fmadd", A_2 ), // 0x001D
DEFOPCD("#fnmsub", A_2 ), // 0x001E
DEFOPCD("#fnmadd", A_2 ), // 0x001F
};
const DISPPC::OPCD * const DISPPC::rgrgopcd3F[] =
{
rgopcd3F_00, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
rgopcd3F_06, //
rgopcd3F_07, //
rgopcd3F_08, //
NULL, //
NULL, //
NULL, //
rgopcd3F_0C, //
NULL, //
rgopcd3F_0E, //
rgopcd3F_0F, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
NULL, //
};
const DISPPC::OPCD DISPPC::rgopcd3F_00[] =
{
DEFOPCD("fcmpu", X_23 ), // 0x0000 0
DEFOPCD("fcmpo", X_23 ), // 0x0020 32
DEFOPCD("mcrfs", X_25 ), // 0x0040 64
INVOPCD(), // 0x0060 96
INVOPCD(), // 0x0080 128
INVOPCD(), // 0x00A0 160
INVOPCD(), // 0x00C0 192
INVOPCD(), // 0x00E0 224
INVOPCD(), // 0x0100 256
INVOPCD(), // 0x0120 288
INVOPCD(), // 0x0140 320
INVOPCD(), // 0x0160 352
INVOPCD(), // 0x0180 384
INVOPCD(), // 0x01A0 416
INVOPCD(), // 0x01C0 448
INVOPCD(), // 0x01E0 480
INVOPCD(), // 0x0200 512
INVOPCD(), // 0x0220 544
INVOPCD(), // 0x0240 576
INVOPCD(), // 0x0260 608
INVOPCD(), // 0x0280 640
INVOPCD(), // 0x02A0 672
INVOPCD(), // 0x02C0 704
INVOPCD(), // 0x02E0 736
INVOPCD(), // 0x0300 768
INVOPCD(), // 0x0320 800
INVOPCD(), // 0x0340 832
INVOPCD(), // 0x0360 864
INVOPCD(), // 0x0380 896
INVOPCD(), // 0x03A0 928
INVOPCD(), // 0x03C0 960
INVOPCD(), // 0x03E0 992
};
const DISPPC::OPCD DISPPC::rgopcd3F_06[] =
{
INVOPCD(), // 0x0006 6
DEFOPCD("#mtfsb1", X_24 ), // 0x0026 38
DEFOPCD("#mtfsb0", X_24 ), // 0x0046 70
INVOPCD(), // 0x0066 102
DEFOPCD("#mtfsfi", X_26 ), // 0x0086 134
INVOPCD(), // 0x00A6 166
INVOPCD(), // 0x00C6 198
INVOPCD(), // 0x00E6 230
INVOPCD(), // 0x0106 262
INVOPCD(), // 0x0126 294
INVOPCD(), // 0x0146 326
INVOPCD(), // 0x0166 358
INVOPCD(), // 0x0186 390
INVOPCD(), // 0x01A6 422
INVOPCD(), // 0x01C6 454
INVOPCD(), // 0x01E6 486
INVOPCD(), // 0x0206 518
INVOPCD(), // 0x0226 550
INVOPCD(), // 0x0246 582
INVOPCD(), // 0x0266 614
INVOPCD(), // 0x0286 646
INVOPCD(), // 0x02A6 678
INVOPCD(), // 0x02C6 710
INVOPCD(), // 0x02E6 742
INVOPCD(), // 0x0306 774
INVOPCD(), // 0x0326 806
INVOPCD(), // 0x0346 838
INVOPCD(), // 0x0366 870
INVOPCD(), // 0x0386 902
INVOPCD(), // 0x03A6 934
INVOPCD(), // 0x03C6 966
INVOPCD(), // 0x03E6 998
};
const DISPPC::OPCD DISPPC::rgopcd3F_07[] =
{
INVOPCD(), // 0x0007 7
INVOPCD(), // 0x0027 39
INVOPCD(), // 0x0047 71
INVOPCD(), // 0x0067 103
INVOPCD(), // 0x0087 135
INVOPCD(), // 0x00A7 167
INVOPCD(), // 0x00C7 199
INVOPCD(), // 0x00E7 231
INVOPCD(), // 0x0107 263
INVOPCD(), // 0x0127 295
INVOPCD(), // 0x0147 327
INVOPCD(), // 0x0167 359
INVOPCD(), // 0x0187 391
INVOPCD(), // 0x01A7 423
INVOPCD(), // 0x01C7 455
INVOPCD(), // 0x01E7 487
INVOPCD(), // 0x0207 519
INVOPCD(), // 0x0227 551
DEFOPCD("#mffs", X_27 ), // 0x0247 583
INVOPCD(), // 0x0267 615
INVOPCD(), // 0x0287 647
INVOPCD(), // 0x02A7 679
DEFOPCD("#mtfsf", XFL_1 ), // 0x02C7 711
INVOPCD(), // 0x02E7 743
INVOPCD(), // 0x0307 775
INVOPCD(), // 0x0327 807
INVOPCD(), // 0x0347 839
INVOPCD(), // 0x0367 871
INVOPCD(), // 0x0387 903
INVOPCD(), // 0x03A7 935
INVOPCD(), // 0x03C7 967
INVOPCD(), // 0x03E7 999
};
const DISPPC::OPCD DISPPC::rgopcd3F_08[] =
{
INVOPCD(), // 0x0008 8
DEFOPCD("#fneg", X_22 ), // 0x0028 40
DEFOPCD("#fmr", X_22 ), // 0x0048 72
INVOPCD(), // 0x0068 104
DEFOPCD("#fnabs", X_22 ), // 0x0088 136
INVOPCD(), // 0x00A8 168
INVOPCD(), // 0x00C8 200
INVOPCD(), // 0x00E8 232
DEFOPCD("#fabs", X_22 ), // 0x0108 264
INVOPCD(), // 0x0128 296
INVOPCD(), // 0x0148 328
INVOPCD(), // 0x0168 360
INVOPCD(), // 0x0188 392
INVOPCD(), // 0x01A8 424
INVOPCD(), // 0x01C8 456
INVOPCD(), // 0x01E8 488
INVOPCD(), // 0x0208 520
INVOPCD(), // 0x0228 552
INVOPCD(), // 0x0248 584
INVOPCD(), // 0x0268 616
INVOPCD(), // 0x0288 648
INVOPCD(), // 0x02A8 680
INVOPCD(), // 0x02C8 712
INVOPCD(), // 0x02E8 744
INVOPCD(), // 0x0308 776
INVOPCD(), // 0x0328 808
INVOPCD(), // 0x0348 840
INVOPCD(), // 0x0368 872
INVOPCD(), // 0x0388 904
INVOPCD(), // 0x03A8 936
INVOPCD(), // 0x03C8 968
INVOPCD(), // 0x03E8 1000
};
const DISPPC::OPCD DISPPC::rgopcd3F_0C[] =
{
DEFOPCD("#frsp", X_22 ), // 0x000C 12
INVOPCD(), // 0x002C 44
INVOPCD(), // 0x004C 76
INVOPCD(), // 0x006C 108
INVOPCD(), // 0x008C 140
INVOPCD(), // 0x00AC 172
INVOPCD(), // 0x00CC 204
INVOPCD(), // 0x00EC 236
INVOPCD(), // 0x010C 268
INVOPCD(), // 0x012C 300
INVOPCD(), // 0x014C 332
INVOPCD(), // 0x016C 364
INVOPCD(), // 0x018C 396
INVOPCD(), // 0x01AC 428
INVOPCD(), // 0x01CC 460
INVOPCD(), // 0x01EC 492
INVOPCD(), // 0x020C 524
INVOPCD(), // 0x022C 556
INVOPCD(), // 0x024C 588
INVOPCD(), // 0x026C 620
INVOPCD(), // 0x028C 652
INVOPCD(), // 0x02AC 684
INVOPCD(), // 0x02CC 716
INVOPCD(), // 0x02EC 748
INVOPCD(), // 0x030C 780
INVOPCD(), // 0x032C 812
INVOPCD(), // 0x034C 844
INVOPCD(), // 0x036C 876
INVOPCD(), // 0x038C 908
INVOPCD(), // 0x03AC 940
INVOPCD(), // 0x03CC 972
INVOPCD(), // 0x03EC 1004
};
const DISPPC::OPCD DISPPC::rgopcd3F_0E[] =
{
DEFOPCD("#fctiw", X_22 ), // 0x000E 14
INVOPCD(), // 0x002E 46
INVOPCD(), // 0x004E 78
INVOPCD(), // 0x006E 110
INVOPCD(), // 0x008E 142
INVOPCD(), // 0x00AE 174
INVOPCD(), // 0x00CE 206
INVOPCD(), // 0x00EE 238
INVOPCD(), // 0x010E 270
INVOPCD(), // 0x012E 302
INVOPCD(), // 0x014E 334
INVOPCD(), // 0x016E 366
INVOPCD(), // 0x018E 398
INVOPCD(), // 0x01AE 430
INVOPCD(), // 0x01CE 462
INVOPCD(), // 0x01EE 494
INVOPCD(), // 0x020E 526
INVOPCD(), // 0x022E 558
INVOPCD(), // 0x024E 590
INVOPCD(), // 0x026E 622
INVOPCD(), // 0x028E 654
INVOPCD(), // 0x02AE 686
INVOPCD(), // 0x02CE 718
INVOPCD(), // 0x02EE 750
INVOPCD(), // 0x030E 782
DEFOPCD("#fctid", X_22 ), // 0x032E 814
DEFOPCD("#fcfid", X_22 ), // 0x034E 846
INVOPCD(), // 0x036E 878
INVOPCD(), // 0x038E 910
INVOPCD(), // 0x03AE 942
INVOPCD(), // 0x03CE 974
INVOPCD(), // 0x03EE 1006
};
const DISPPC::OPCD DISPPC::rgopcd3F_0F[] =
{
DEFOPCD("#fctiwz", X_22 ), // 0x000F 15
INVOPCD(), // 0x002F 47
INVOPCD(), // 0x004F 79
INVOPCD(), // 0x006F 111
INVOPCD(), // 0x008F 143
INVOPCD(), // 0x00AF 175
INVOPCD(), // 0x00CF 207
INVOPCD(), // 0x00EF 239
INVOPCD(), // 0x010F 271
INVOPCD(), // 0x012F 303
INVOPCD(), // 0x014F 335
INVOPCD(), // 0x016F 367
INVOPCD(), // 0x018F 399
INVOPCD(), // 0x01AF 431
INVOPCD(), // 0x01CF 463
INVOPCD(), // 0x01EF 495
INVOPCD(), // 0x020F 527
INVOPCD(), // 0x022F 559
INVOPCD(), // 0x024F 591
INVOPCD(), // 0x026F 623
INVOPCD(), // 0x028F 655
INVOPCD(), // 0x02AF 687
INVOPCD(), // 0x02CF 719
INVOPCD(), // 0x02EF 751
INVOPCD(), // 0x030F 783
DEFOPCD("#fctidz", X_22 ), // 0x032F 815
INVOPCD(), // 0x034F 847
INVOPCD(), // 0x036F 879
INVOPCD(), // 0x038F 911
INVOPCD(), // 0x03AF 943
INVOPCD(), // 0x03CF 975
INVOPCD(), // 0x03EF 1007
};
const char * const DISPPC::szBIFalse[4] =
{
"ge",
"le",
"ne",
"ns", // or "nu"
};
const char * const DISPPC::szBITrue[4] =
{
"lt",
"gt",
"eq",
"so", // or "un"
};
const char * const DISPPC::szBO[] =
{
"dnzf", // 0
"dzf", // 2
"f", // 4
NULL, // 6
"dnzt", // 8
"dzt", // 10
"t", // 12
NULL, // 14
"dnz", // 16
"dz", // 18
"", // 20
};
const char * const DISPPC::szTO[32] =
{
NULL, // 0
"lgt", // 1
"llt", // 2
NULL, // 3
"eq", // 4
"lge", // 5 or "lnl"
"lle", // 6 or "lng"
NULL, // 7
"gt", // 8
NULL, // 9
NULL, // 10
NULL, // 11
"ge", // 12 or "nl"
NULL, // 13
NULL, // 14
NULL, // 15
"lt", // 16
NULL, // 17
NULL, // 18
NULL, // 19
"le", // 20 or "ng"
NULL, // 21
NULL, // 22
NULL, // 23
"ne", // 24
NULL, // 25
NULL, // 26
NULL, // 27
NULL, // 28
NULL, // 29
NULL, // 30
NULL, // 31
};
const DISPPC::OPCD DISPPC::opcdLi =
DEFOPCD("li", D_14 );
const DISPPC::OPCD DISPPC::opcdLis =
DEFOPCD("lis", D_14 );
const DISPPC::OPCD DISPPC::opcdNop =
DEFOPCD("nop", X_12 );
const DISPPC::OPCD DISPPC::opcdNot =
DEFOPCD("#not", X_6 );
const DISPPC::OPCD DISPPC::opcdMr =
DEFOPCD("#mr", X_6 );
const DISPPC::OPCD DISPPC::opcdTrap =
DEFOPCD("trap", Sc );
const DWORD DISPPC::dwValidBO = 0x001F3F3F;
const DWORD DISPPC::dwValidBO_CTR = 0x00103030;
const DISPPC::SPRMAP DISPPC::rgsprmap[] =
{
{ sprregMq, "mq" },
{ sprregXer, "xer" },
{ sprregRtcu, "rtcu" },
{ sprregRtcl, "rtcl" },
{ sprregLr, "lr" },
{ sprregCtr, "ctr" },
{ sprregDsisr, "dsisr" },
{ sprregDar, "dar" },
{ sprregDec, "dec" },
{ sprregSdr1, "sdr1" },
{ sprregSrr0, "srr0" },
{ sprregSrr1, "srr1" },
{ sprregSprg0, "sprg0" },
{ sprregSprg1, "sprg1" },
{ sprregSprg2, "sprg2" },
{ sprregSprg3, "sprg3" },
{ sprregAsr, "asr" },
{ sprregEar, "ear" },
{ sprregTbl, "tbl" }, // 604 (UNDONE: 603?)
{ sprregTbu, "tbu" }, // 604 (UNDONE: 603?)
{ sprregPvr, "pvr" },
{ sprregIbat0u, "ibat0u" },
{ sprregIbat0l, "ibat0l" },
{ sprregIbat1u, "ibat1u" },
{ sprregIbat1l, "ibat1l" },
{ sprregIbat2u, "ibat2u" },
{ sprregIbat2l, "ibat2l" },
{ sprregIbat3u, "ibat3u" },
{ sprregIbat3l, "ibat3l" },
{ sprregDbat0u, "dbat0u" },
{ sprregDbat0l, "dbat0l" },
{ sprregDbat1u, "dbat1u" },
{ sprregDbat1l, "dbat1l" },
{ sprregDbat2u, "dbat2u" },
{ sprregDbat2l, "dbat2l" },
{ sprregDbat3u, "dbat3u" },
{ sprregDbat3l, "dbat3l" },
{ sprregMmcr0, "mmcr0" }, // 604
{ sprregPmc1, "pmc1" }, // 604
{ sprregPmc2, "pmc2" }, // 604
{ sprregSia, "sia" }, // 604
{ sprregSda, "sda" }, // 604
{ sprregDmiss, "dmiss" }, // 603
{ sprregImiss, "imiss" }, // 603
{ sprregIcmp, "icmp" }, // 603
{ sprregRpa, "rpa" }, // 603
{ sprregHid0, "hid0" }, // 601, 603 and 604
{ sprregHid1, "hid1" },
{ sprregHid2, "hid2" }, // 601, 603 and 604 (iabr)
{ sprregHid5, "hid5" }, // 601 and 604 (dabr)
{ sprregHid15, "hid15" },
};
const size_t DISPPC::csprmap = sizeof(rgsprmap) / sizeof(SPRMAP);
DISPPC::DISPPC(ARCHT archt) : DIS(archt)
{
}
// -----------------------------------------------------------------
// Public Methods
// -----------------------------------------------------------------
ADDR DISPPC::AddrAddress() const
{
// UNDONE
return(addrNil);
}
ADDR DISPPC::AddrJumpTable() const
{
return(addrNil);
}
ADDR DISPPC::AddrOperand(size_t ioperand) const
{
if (m_pfndwgetreg == 0)
{
return(addrNil);
}
if (ioperand == 0)
{
// Implicit operand if any
return(addrNil);
}
if (!FValidOperand(ioperand))
{
return(addrNil);
}
ICLS icls = (ICLS) m_popcd->icls;
Assert(icls != iclsInvalid);
ADDR addr = addrNil;
OPCLS opcls = (OPCLS) rgcls[icls].rgopcls[ioperand-1];
switch (opcls)
{
DWORD dwDisp;
case opclsD_d : // lmw rD,d(rA) (op 2)
if (m_ppciw.D.rA != 0)
{
addr = (ADDR) (*m_pfndwgetreg)(this, (int) m_ppciw.D.rA);
}
dwDisp = m_ppciw.D.d;
if ((dwDisp & 0x8000) != 0)
{
dwDisp |= 0xFFFF0000;
}
addr += dwDisp;
break;
case opclsDS_ds : // ld rD,ds(rA) (op 2)
if (m_ppciw.DS.rA != 0)
{
addr = (ADDR) (*m_pfndwgetreg)(this, (int) m_ppciw.DS.rA);
}
dwDisp = m_ppciw.DS.ds << 2;
if ((dwDisp & 0x8000) != 0)
{
dwDisp |= 0xFFFF0000;
}
addr += dwDisp;
break;
}
return(addr);
}
ADDR DISPPC::AddrTarget() const
{
ICLS icls = (ICLS) m_popcd->icls;
Assert(icls != iclsInvalid);
ADDR addrTarget;
switch (icls)
{
DWORD dwDisp;
case iclsB :
dwDisp = m_ppciw.I.LI << 2;
if ((dwDisp & 0x2000000) != 0)
{
dwDisp |= 0xFC000000; // Sign extend
}
if (m_ppciw.I.AA)
{
addrTarget = dwDisp;
}
else
{
addrTarget = m_addr + dwDisp;
}
break;
case iclsBc :
dwDisp = m_ppciw.B.BD << 2;
if ((dwDisp & 0x8000) != 0)
{
dwDisp |= 0xFFFF0000; // Sign extend
}
if (m_ppciw.B.AA)
{
addrTarget = dwDisp;
}
else
{
addrTarget = m_addr + dwDisp;
}
break;
default :
addrTarget = addrNil;
}
return(addrTarget);
}
size_t DISPPC::Cb() const
{
return(sizeof(PPCIW));
}
size_t DISPPC::CbDisassemble(ADDR addr, const BYTE *pb, size_t cbMax)
{
m_addr = addr;
if ((addr & 3) != 0)
{
// Instruction address not aligned
m_popcd = NULL;
return(0);
}
if (cbMax < sizeof(PPCIW))
{
// Buffer not large enough for single instruction
m_popcd = NULL;
return(0);
}
if (m_archt == archtPowerPc)
{
m_ppciw = *(PPCIW UNALIGNED *) pb;
}
else
{
// Load and byte swap instruction word. PPC instruction is in
// big endian format and we are executing in little endian mode.
m_ppciw.dw = ((DWORD) pb[0] << 24) | ((DWORD) pb[1] << 16) | ((DWORD) pb[2] << 8) | pb[3];
}
m_popcd = PopcdDecode(m_ppciw);
if (m_popcd == NULL)
{
return(0);
}
return(sizeof(PPCIW));
}
size_t DISPPC::CbGenerateLoadAddress(BYTE *, size_t, size_t *) const
{
// UNDONE
return(0);
}
size_t DISPPC::CbJumpEntry() const
{
return(sizeof(DWORD));
}
size_t DISPPC::CbMemoryReference() const
{
// UNDONE
return(0);
}
size_t DISPPC::CchFormatAddr(ADDR addr, char *sz, size_t cchMax) const
{
if (cchMax > INT_MAX)
{
cchMax = INT_MAX;
}
ostrstream ostr(sz, (int) cchMax);
FormatAddr(ostr, addr);
ostr << ends;
if (ostr.fail())
{
return(0);
}
return((size_t) ostr.pcount());
}
size_t DISPPC::CchFormatBytes(char *sz, size_t cchMax) const
{
if (cchMax <= 8)
{
// Caller's buffer is too small
return(0);
}
size_t cch = (size_t) sprintf(sz, "%08X", m_ppciw.dw);
Assert(cch == 8);
return(8);
}
size_t DISPPC::CchFormatBytesMax() const
{
return(8);
}
size_t DISPPC::CchFormatInstr(char *sz, size_t cchMax) const
{
if (cchMax > INT_MAX)
{
cchMax = INT_MAX;
}
ostrstream ostr(sz, (int) cchMax);
FormatInstr(ostr);
ostr << ends;
if (ostr.fail())
{
return(0);
}
return((size_t) ostr.pcount());
}
size_t DISPPC::Coperand() const
{
ICLS icls = (ICLS) m_popcd->icls;
Assert(icls != iclsInvalid);
for (size_t coperand = 5; coperand > 0; coperand--)
{
if (rgcls[icls].rgopcls[coperand-1] != opclsNone)
{
break;
}
}
return(coperand);
}
void DISPPC::FormatAddr(ostream& ostr, ADDR addr) const
{
long lFlags = ostr.setf(ios::uppercase);
char chFill = ostr.fill('0');
ostr << hex << setw(8) << addr;
ostr.fill(chFill);
ostr.flags(lFlags);
}
void DISPPC::FormatInstr(ostream& ostr) const
{
long lFlags = ostr.setf(ios::uppercase);
char chFill = ostr.fill('0');
ICLS icls = (ICLS) m_popcd->icls;
Assert(icls != iclsInvalid);
const char *szMnemonic = m_popcd->szMnemonic;
// If the mnemonic begins with '~' than there
// may be a pseudo-op that should be used.
char szPseudo[32];
if (szMnemonic[0] == '~')
{
OPCD opcd;
opcd.szMnemonic = szPseudo;
const OPCD *popcd = PopcdPseudoOp(&opcd, szPseudo);
if (popcd != NULL)
{
icls = (ICLS) popcd->icls;
Assert(icls != iclsInvalid);
szMnemonic = popcd->szMnemonic;
}
else
{
szMnemonic++;
}
}
// If the mnemonic begins with '!' than the LK bit should be checked.
// If set, an 'l' is append to the end of the mnemonic.
bool fAppendLk = (szMnemonic[0] == '!');
if (fAppendLk)
{
szMnemonic++;
}
// If the mnemonic begins with '@' than the AA bit should be checked.
// If set, an 'a' is append to the end of the mnemonic.
bool fAppendAa = (szMnemonic[0] == '@');
if (fAppendAa)
{
szMnemonic++;
}
// If the mnemonic begins with '#' than the Rc bit should be checked.
// If set, a period is append to the end of the mnemonic.
bool fAppendRc = (szMnemonic[0] == '#');
if (fAppendRc)
{
szMnemonic++;
}
ostr << szMnemonic;
size_t cch = 0;
if (fAppendLk)
{
if (m_ppciw.I.LK)
{
ostr << 'l';
cch++;
}
}
if (fAppendAa)
{
if (m_ppciw.I.AA)
{
ostr << 'a';
cch++;
}
}
if (fAppendRc)
{
if (m_ppciw.X.Rc)
{
ostr << '.';
cch++;
}
}
for (size_t ioperand = 0; ioperand < 5; ioperand++)
{
OPCLS opcls = (OPCLS) rgcls[icls].rgopcls[ioperand];
if (opcls == opclsNone)
{
break;
}
if (ioperand == 0)
{
// Pad opcode field to 12 characters
cch += strlen(szMnemonic);
do
{
ostr << ' ';
}
while (++cch < 12);
}
else
{
ostr << ',';
}
FormatOperand(ostr, opcls);
}
ostr.fill(chFill);
ostr.flags(lFlags);
}
DIS::MEMREFT DISPPC::Memreft() const
{
// UNDONE
return(memreftNone);
}
TRMT DISPPC::Trmt() const
{
TRMTPPC trmtppc = Trmtppc();
return(mptrmtppctrmt[trmtppc]);
}
TRMTA DISPPC::Trmta() const
{
TRMTPPC trmtppc = Trmtppc();
return((TRMTA) trmtppc);
}
// -----------------------------------------------------------------
// Private Methods
// -----------------------------------------------------------------
void DISPPC::FormatHex(ostream& ostr, DWORD dw) const
{
if (dw <= 9)
{
ostr << dw;
return;
}
char szHex[11];
sprintf(szHex, "%lX", dw);
if (!isdigit(szHex[0]))
{
ostr << '0';
}
ostr << szHex << 'h';
}
void DISPPC::FormatOperand(ostream& ostr, OPCLS opcls) const
{
size_t cch;
char szSymbol[1024];
DWORD dwDisp;
size_t isprmap;
switch (opcls)
{
case opclsNone : // No operand
AssertSz(false, "Unexpected PPC operand class");
break;
case opclsI_LI : // b target (op 1)
case opclsB_BD : // bc BO,BI,target (op 3)
if (m_pfncchaddr != 0)
{
cch = (*m_pfncchaddr)(this, AddrTarget(), szSymbol, sizeof(szSymbol), &dwDisp);
}
else
{
cch = 0;
}
if (cch != 0)
{
ostr << szSymbol;
if (dwDisp != 0)
{
ostr << '+';
FormatHex(ostr, dwDisp);
}
}
else
{
ostr << hex << setw(8) << AddrTarget();
}
break;
case opclsB_BI : // bc BO,BI,target (op 2)
case opclsXL_BI : // bcctr BO,BI (op 2)
ostr << (unsigned) m_ppciw.B.BI;
break;
case opclsB_BO : // bc BO,BI,target (op 1)
case opclsXL_BO : // bcctr BO,BI (op 1)
ostr << (unsigned) m_ppciw.B.BO;
break;
case opclsB_CR : // ble cr,target (op 1)
case opclsXL_CR : // blectr cr (op 1)
ostr << "cr" << (unsigned) (m_ppciw.B.BI >> 2);
break;
case opclsD_d : // lmw rD,d(rA) (op 2)
if (m_pfncchfixup != 0)
{
cch = (*m_pfncchfixup)(this, m_addr, sizeof(WORD), szSymbol, sizeof(szSymbol), &dwDisp);
if (cch != 0)
{
ostr << szSymbol;
if (dwDisp != 0)
{
ostr << '+';
FormatHex(ostr, dwDisp);
}
ostr << "(r" << (unsigned) m_ppciw.D.rA << ')';
break;
}
}
dwDisp = m_ppciw.D.d;
if ((dwDisp & 0x8000) != 0)
{
dwDisp |= 0xFFFF0000;
}
FormatRegRel(ostr, (REG) m_ppciw.D.rA, dwDisp);
break;
case opclsD_SIMM : // addi rD,rA,SIMM (op 3)
case opclsD_UIMM : // andi. rA,rS,UIMM (op 3)
if (m_pfncchfixup != 0)
{
cch = (*m_pfncchfixup)(this, m_addr, sizeof(WORD), szSymbol, sizeof(szSymbol), &dwDisp);
if (cch != 0)
{
ostr << szSymbol;
if (dwDisp != 0)
{
ostr << '+';
FormatHex(ostr, dwDisp);
}
break;
}
}
FormatHex(ostr, m_ppciw.D.d);
break;
case opclsD_rA : // andi. rA,rS,UIMM (op 1)
case opclsX_rA : // cmp crfD,L,rA,rB (op 3)
case opclsXS_rA : // sradi rA,rS,SH (op 1)
case opclsXO_rA : // add rD,rA,rB (op 2)
case opclsM_rA : // rlwimi rA,rS,SH,MB,ME (op 1)
case opclsMD_rA : // rldicr rA,rS,SH,MB (op 1)
case opclsMDS_rA : // rldcr rA,rS,rB,ME (op 1)
ostr << 'r' << (unsigned) m_ppciw.D.rA;
break;
case opclsD_rD : // lmw rD,d(rA) (op 1)
case opclsD_rS : // andi. rA,rS,UIMM (op 2)
case opclsDS_rD : // ld rD,ds(rA) (op 1)
case opclsDS_rS : // std rS,ds(rA) (op 1)
case opclsX_rD : // lbzux rD,rA,rB (op 1)
case opclsX_rS : // and rA,rS,rB (op 2)
case opclsXFX_rD : // mfspr rD,SPR (op 1)
case opclsXFX_rS : // mtcrf CRM,rS (op 2)
case opclsXS_rS : // sradi rA,rS,SH (op 2)
case opclsXO_rD : // add rD,rA,rB (op 1)
case opclsM_rS : // rlwimi rA,rS,SH,MB,ME (op 2)
case opclsMD_rS : // rldicr rA,rS,SH,MB (op 2)
case opclsMDS_rS : // rldcr rA,rS,rB,ME (op 2)
ostr << 'r' << (unsigned) m_ppciw.D.rD;
break;
case opclsD_frS : // stfd frS,d(rA) (op 1)
case opclsD_frD : // lfd frD,d(rA) (op 1)
case opclsX_frD : // lfdux frD,rA,rB (op 1)
case opclsX_frS : // stfdux frS,rA,rB (op 1)
case opclsA_frD : // fmadd frD,frA,frC,frB (op 1)
ostr << 'f' << (unsigned) m_ppciw.D.rD;
break;
case opclsD_TO : // twi TO,rA,SIMM (op 1)
case opclsX_TO : // tw TO,rA,rB (op 1)
ostr << (unsigned) m_ppciw.D.rD;
break;
case opclsD_crfD : // cmpi crfD,L,rA,SIMM (op 1)
case opclsX_crfD : // mtfsfi crfD,IMM (op 1)
case opclsXL_crfD : // mcrf crfD,crfS (op 1)
ostr << "cr" << (unsigned) (m_ppciw.D.rD >> 2);
break;
case opclsD_L : // cmpi crfD,L,rA,SIMM (op 2)
case opclsX_L : // cmp crfD,L,rA,rB (op 2)
ostr << (unsigned) (m_ppciw.D.rD & 1);
break;
case opclsDS_ds : // ld rD,ds(rA) (op 2)
if (m_pfncchfixup != 0)
{
cch = (*m_pfncchfixup)(this, m_addr, sizeof(WORD), szSymbol, sizeof(szSymbol), &dwDisp);
if (cch != 0)
{
ostr << szSymbol;
if (dwDisp != 0)
{
ostr << '+';
FormatHex(ostr, dwDisp);
}
ostr << "(r" << (unsigned) m_ppciw.DS.rA << ')';
break;
}
}
dwDisp = m_ppciw.DS.ds << 2;
if ((dwDisp & 0x8000) != 0)
{
dwDisp |= 0xFFFF0000;
}
FormatRegRel(ostr, (REG) m_ppciw.DS.rA, dwDisp);
break;
case opclsX_rB : // cmp crfD,L,rA,rB (op 4)
case opclsXO_rB : // add rD,rA,rB (op 3)
case opclsM_rB : // rlwnm rA,rS,rB,MB,ME (op 3)
case opclsMDS_rB : // rldcr rA,rS,rB,ME (op 3)
ostr << 'r' << (unsigned) m_ppciw.X.rB;
break;
case opclsX_frB : // fcmpu crfD,frA,frB (op 3)
case opclsXFL_frB : // mtfsf FM,frB (op 2)
case opclsA_frB : // fmadd frD,frA,frC,frB (op 4)
ostr << 'f' << (unsigned) m_ppciw.X.rB;
break;
case opclsX_SH : // srawi rA,rS,SH (op 3)
case opclsX_NB : // lswi rD,rA,NB (op 3)
case opclsM_SH : // rlwimi rA,rS,SH,MB,ME (op 3)
ostr << (unsigned) m_ppciw.X.rB;
break;
case opclsX_IMM : // mtfsfi crfD,IMM (op 2)
ostr << (unsigned) (m_ppciw.X.rB >> 1);
break;
case opclsX_frA : // fcmpu crfD,frA,frB (op 2)
case opclsA_frA : // fmadd frD,frA,frC,frB (op 2)
ostr << 'f' << (unsigned) m_ppciw.X.rA;
break;
case opclsX_crfS : // mcrfs crfD,crfS (op 2)
case opclsXL_crfS : // mcrf crfD,crfS (op 2)
ostr << "cr" << (unsigned) (m_ppciw.X.rA >> 2);
break;
case opclsX_SR : // mtsr SR,rS (op 1)
ostr << (unsigned) (m_ppciw.X.rA & 0xF);
break;
case opclsX_crbD : // mtfsb0 crbD (op 1)
case opclsXL_crbD : // crand crbD,crbA,crbB (op 1)
ostr << "crb" << (unsigned) m_ppciw.X.rD;
break;
case opclsXL_crbB : // crand crbD,crbA,crbB (op 3)
ostr << "crb" << (unsigned) m_ppciw.XL.crbB;
break;
case opclsXL_crbA : // crand crbD,crbA,crbB (op 2)
ostr << "crb" << (unsigned) m_ppciw.XL.crbA;
break;
case opclsXFX_SPR : // mfspr rD,SPR (op 2)
for (isprmap = 0; isprmap < csprmap; isprmap++)
{
if (rgsprmap[isprmap].sprreg == (SPRREG) (((m_ppciw.XFX.SPR & 0x1F) << 5) + (m_ppciw.XFX.SPR >> 5)))
{
ostr << rgsprmap[isprmap].szName;
break;
}
}
if (isprmap == csprmap)
{
ostr << "spr" << (unsigned) (((m_ppciw.XFX.SPR & 0x1F) << 5) + (m_ppciw.XFX.SPR >> 5));
}
break;
case opclsXFX_TBR : // mftb rD,TBR (op 2)
// UNDONE: Use names
ostr << "spr" << (unsigned) (((m_ppciw.XFX.SPR & 0x1F) << 5) + (m_ppciw.XFX.SPR >> 5));
break;
case opclsXFX_CRM : // mtcrf CRM,rS (op 1)
FormatHex(ostr, (m_ppciw.XFX.SPR >> 1) & 0xFF);
break;
case opclsXFL_FM : // mtfsf FM,frB (op 1)
FormatHex(ostr, m_ppciw.XFL.FM);
break;
case opclsXS_SH : // sradi rA,rS,SH (op 3)
case opclsMD_SH : // rldicr rA,rS,SH,MB (op 3)
ostr << (unsigned) ((m_ppciw.XS.SH5 << 5) + m_ppciw.XS.SH);
break;
case opclsA_frC : // fmadd frD,frA,frC,frB (op 3)
ostr << 'f' << (unsigned) m_ppciw.A.frC;
break;
case opclsM_ME : // rlwnm rA,rS,rB,MB,ME (op 5)
ostr << (unsigned) m_ppciw.M.ME;
break;
case opclsM_MB : // rlwnm rA,rS,rB,MB,ME (op 4)
ostr << (unsigned) m_ppciw.M.MB;
break;
case opclsMD_MB : // rldic rA,rS,SH,MB (op 4)
case opclsMD_ME : // rldicr rA,rS,SH,MB (op 4)
case opclsMDS_MB : // rldcl rA,rS,rB,MB (op 4)
case opclsMDS_ME : // rldcr rA,rS,rB,ME (op 4)
ostr << (unsigned) (((m_ppciw.MD.MB & 1) << 4) + (m_ppciw.MD.MB >> 1));
break;
default :
AssertSz(false, "Unexpected PPC operand class");
break;
}
}
void DISPPC::FormatRegRel(ostream& ostr, REG reg, DWORD dwDisp) const
{
if (m_pfncchregrel != 0)
{
char sz[1024];
size_t cch = (*m_pfncchregrel)(this, (int) reg, dwDisp, sz, sizeof(sz), &dwDisp);
if (cch != 0)
{
ostr << sz;
if (dwDisp != 0)
{
ostr << '+';
FormatHex(ostr, dwDisp);
}
return;
}
}
FormatHex(ostr, (WORD) dwDisp);
ostr << "(r" << (unsigned) reg << ')';
}
bool DISPPC::FValidOperand(size_t ioperand) const
{
if (ioperand == 0)
{
// Implicit operand if any
return(true);
}
if (ioperand > 5)
{
return(false);
}
ICLS icls = (ICLS) m_popcd->icls;
Assert(icls != iclsInvalid);
OPCLS opcls = (OPCLS) rgcls[icls].rgopcls[ioperand-1];
return(opcls != opclsNone);
}
const DISPPC::OPCD *DISPPC::PopcdDecode(PPCIW ppciw)
{
const OPCD *popcd = rgopcd + ppciw.I.opcd;
if ((ICLS) popcd->icls == iclsInvalid)
{
switch (ppciw.I.opcd)
{
case 0x13 :
popcd = rgrgopcd13[ppciw.XL.XO & 0x1F];
if (popcd == NULL)
{
return(NULL);
}
popcd += (ppciw.XL.XO >> 5);
break;
case 0x1F :
popcd = rgrgopcd1F[ppciw.X.XO & 0x1F];
if (popcd == NULL)
{
return(NULL);
}
popcd += (ppciw.X.XO >> 5);
break;
case 0x3A :
popcd = rgopcd3A + ppciw.DS.XO;
break;
case 0x3B :
popcd = rgopcd3B + ppciw.A.XO;
break;
case 0x3E :
popcd = rgopcd3E + ppciw.DS.XO;
break;
case 0x3F :
popcd = rgopcd3F + ppciw.A.XO;
if ((ICLS) popcd->icls != iclsInvalid)
{
break;
}
popcd = rgrgopcd3F[ppciw.X.XO & 0x1F];
if (popcd == NULL)
{
return(NULL);
}
popcd += (ppciw.X.XO >> 5);
break;
default :
return(NULL);
}
}
ICLS icls = (ICLS) popcd->icls;
switch (icls)
{
case iclsInvalid :
return(NULL);
case iclsA_1 :
if (ppciw.A.frC != 0)
{
return(NULL);
}
break;
case iclsA_2 :
// No Restrictions
break;
case iclsA_3 :
if ((ppciw.A.frC != 0) || (ppciw.A.frA != 0))
{
return(NULL);
}
break;
case iclsA_4 :
if (ppciw.A.frB != 0)
{
return(NULL);
}
break;
case iclsD_1 :
// No Restrictions
break;
case iclsD_2 :
// No Restrictions
break;
case iclsD_3 :
if ((ppciw.D.rD & 2) != 0)
{
return(NULL);
}
break;
case iclsD_4 :
// No Restrictions
break;
case iclsD_5 :
// No Restrictions
break;
case iclsD_6 :
// No Restrictions
break;
case iclsD_7 :
// No Restrictions
break;
case iclsD_8 :
// No Restrictions
break;
case iclsD_9 :
// UNDONE: The 601 manual claims that rA is skipped so that this shouldn't be a problem
if (ppciw.D.rA >= ppciw.D.rD)
{
return(NULL);
}
break;
case iclsD_10 :
if ((ppciw.D.rA == 0) || (ppciw.D.rA == ppciw.D.rD))
{
return(NULL);
}
break;
case iclsD_11 :
case iclsD_12 :
case iclsD_13 :
if (ppciw.D.rA == 0)
{
return(NULL);
}
break;
case iclsDS_1 :
// No Restrictions
break;
case iclsDS_2 :
// No Restrictions
break;
case iclsDS_3 :
if ((ppciw.DS.rA == 0) || (ppciw.DS.rA == ppciw.DS.rD))
{
return(NULL);
}
break;
case iclsDS_4 :
if (ppciw.DS.rA == 0)
{
return(NULL);
}
break;
case iclsBc :
if (((dwValidBO >> ppciw.B.BO) & 1) == 0)
{
return(NULL);
}
break;
case iclsSc :
if ((ppciw.SC.mbz1 != 0) ||
(ppciw.SC.XO != 1) ||
(ppciw.SC.mbz2 != 0) ||
(ppciw.SC.mbz3 != 0) ||
(ppciw.SC.mbz4 != 0))
{
return(NULL);
}
break;
case iclsB :
// No Restrictions
break;
case iclsM_1 :
// No Restrictions
break;
case iclsMD_1 :
// No Restrictions
break;
case iclsMD_2 :
// No Restrictions
break;
case iclsX_1 :
if ((ppciw.X.rD & 2) != 0)
{
return(NULL);
}
break;
case iclsX_2 :
if (ppciw.X.Rc != 0)
{
return(NULL);
}
break;
case iclsX_3 :
if ((ppciw.X.rA != 0) || (ppciw.X.rB != 0) || (ppciw.X.Rc != 0))
{
return(NULL);
}
break;
case iclsX_4 :
if (ppciw.X.Rc != 0)
{
return(NULL);
}
break;
case iclsX_5 :
// No Restrictions
break;
case iclsX_6 :
if (ppciw.X.rB != 0)
{
return(NULL);
}
break;
case iclsX_7 :
if ((ppciw.X.rD != 0) || (ppciw.X.Rc != 0))
{
return(NULL);
}
break;
case iclsX_8 :
if (ppciw.X.Rc != 0)
{
return(NULL);
}
break;
case iclsX_9 :
if (((ppciw.X.rA & 16) != 0) || (ppciw.X.rB != 0) || (ppciw.X.Rc != 0))
{
return(NULL);
}
break;
case iclsX_10 :
if ((ppciw.X.rA != 0) || (ppciw.X.Rc != 0))
{
return(NULL);
}
break;
case iclsX_11 :
break;
case iclsX_12 :
if ((ppciw.X.rD != 0) ||
(ppciw.X.rA != 0) ||
(ppciw.X.rB != 0) ||
(ppciw.X.Rc != 0))
{
return(NULL);
}
break;
case iclsX_13 :
if (((ppciw.X.rD & 3) != 0) ||
(ppciw.X.rA != 0) ||
(ppciw.X.rB != 0) ||
(ppciw.X.Rc != 0))
{
return(NULL);
}
break;
case iclsX_14 :
if (ppciw.X.Rc != 0)
{
return(NULL);
}
break;
case iclsX_15 :
if (((ppciw.X.rA & 1) != 0) || (ppciw.X.rB != 0) || (ppciw.X.Rc != 0))
{
return(NULL);
}
break;
case iclsX_16 :
if (ppciw.X.Rc != 0)
{
return(NULL);
}
break;
case iclsX_17 :
if ((ppciw.X.rA != 0) || (ppciw.X.Rc != 0))
{
return(NULL);
}
break;
case iclsX_18 :
if (ppciw.X.Rc != 0)
{
return(NULL);
}
break;
case iclsX_19 :
break;
case iclsX_20 :
// No Restrictions
break;
case iclsX_21 :
if ((ppciw.X.rB != 0) || (ppciw.X.rA != 0))
{
return(NULL);
}
break;
case iclsX_22 :
if (ppciw.X.rA != 0)
{
return(NULL);
}
break;
case iclsX_23 :
if (((ppciw.X.rD & 3) != 0) || (ppciw.X.Rc != 0))
{
return(NULL);
}
break;
case iclsX_24 :
if (ppciw.XFX.SPR != 0)
{
return(NULL);
}
break;
case iclsX_25 :
if (((ppciw.X.rD & 3) != 0) ||
((ppciw.X.rA & 3) != 0) ||
(ppciw.X.rB != 0) ||
(ppciw.X.Rc != 0))
{
return(NULL);
}
break;
case iclsX_26 :
if (((ppciw.X.rB & 1) != 0) ||
(ppciw.X.rA != 0) ||
((ppciw.X.rD & 3) != 0))
{
return(NULL);
}
break;
case iclsX_27 :
if ((ppciw.X.rA != 0) || (ppciw.X.rB != 0))
{
return(NULL);
}
break;
case iclsX_28 :
if (ppciw.X.rB != 0)
{
return(NULL);
}
break;
case iclsX_29 :
case iclsX_30 :
if (ppciw.X.Rc != 0)
{
return(NULL);
}
break;
case iclsX_31 :
if ((ppciw.X.rA == 0) || (ppciw.X.rA == ppciw.X.rD))
{
return(NULL);
}
if (ppciw.X.Rc != 0)
{
return(NULL);
}
break;
case iclsX_32 :
if ((ppciw.X.rA == 0) || (ppciw.X.Rc != 0))
{
return(NULL);
}
break;
case iclsX_33 :
// No Restrictions
break;
case iclsX_34 :
case iclsX_35 :
if ((ppciw.X.rA == 0) || (ppciw.X.Rc != 0))
{
return(NULL);
}
break;
case iclsX_36 :
if (ppciw.X.Rc != 1)
{
return(NULL);
}
break;
case iclsXFL_1 :
if ((ppciw.XFL.mbz1 != 0) || (ppciw.XFL.mbz2 != 0))
{
return(NULL);
}
break;
case iclsXFX_1 :
if (((ppciw.XFX.SPR & 0x201) != 0) || (ppciw.XFX.Rc != 0))
{
return(NULL);
}
break;
case iclsXFX_2 :
// UNDONE: Validate SPR encodings
if (ppciw.XFX.Rc != 0)
{
return(NULL);
}
break;
case iclsXFX_3 :
// UNDONE: Validate TBR encodings
if (ppciw.XFX.Rc != 0)
{
return(NULL);
}
break;
case iclsXFX_4 :
// UNDONE: Validate SPR encodings
if (ppciw.XFX.Rc != 0)
{
return(NULL);
}
break;
case iclsXO_1 :
// No Restrictions
break;
case iclsXO_2 :
if (ppciw.XO.rB != 0)
{
return(NULL);
}
break;
case iclsXL_1 :
if (((ppciw.XL.crbD & 3) != 0) ||
((ppciw.XL.crbA & 3) != 0) ||
(ppciw.XL.crbB != 0) ||
(ppciw.XL.LK != 0))
{
return(NULL);
}
break;
case iclsBclr :
if (((dwValidBO >> ppciw.XL.crbD) & 1) == 0)
{
return(NULL);
}
if (ppciw.XL.crbB != 0)
{
return(NULL);
}
break;
case iclsXL_3 :
if (ppciw.XL.LK != 0)
{
return(NULL);
}
break;
case iclsXL_4 :
case iclsXL_5 :
if ((ppciw.XL.crbD != 0) ||
(ppciw.XL.crbA != 0) ||
(ppciw.XL.crbB != 0) ||
(ppciw.XL.LK != 0))
{
return(NULL);
}
break;
case iclsBcctr :
if (((dwValidBO_CTR >> ppciw.XL.crbD) & 1) == 0)
{
return(NULL);
}
if (ppciw.XL.crbB != 0)
{
return(NULL);
}
break;
case iclsXS_1 :
// No Restrictions
break;
}
return(popcd);
}
const DISPPC::OPCD *DISPPC::PopcdPseudoOp(OPCD *popcd, char *szMnemonic) const
{
// UNDONE: PAS supports extended mnemonics for the following
// UNDONE:
// UNDONE: cmp -> cmpw, cmpd
// UNDONE: cmpi -> cmpwi, cmpdi
// UNDONE: cmpl -> cmplw, cmpld
// UNDONE: cmpli -> cmplwi, cmpldi
// UNDONE:
// UNDONE: crxor -> crclr
// UNDONE: cror -> crmove
// UNDONE: creqv -> crset
// UNDONE:
// UNDONE: mftb -> mftb, mftbu
if (m_popcd == rgopcd+0x0002)
{
// tdi TO,rA,SIMM
if (szTO[m_ppciw.D.rD] != NULL)
{
popcd->icls = iclsTw2;
strcpy(szMnemonic, "td");
strcat(szMnemonic, szTO[m_ppciw.D.rD]);
strcat(szMnemonic, "i");
return(popcd);
}
}
else if (m_popcd == rgopcd+0x0003)
{
// twi TO,rA,SIMM
if (szTO[m_ppciw.D.rD] != NULL)
{
popcd->icls = iclsTw2;
strcpy(szMnemonic, "tw");
strcat(szMnemonic, szTO[m_ppciw.D.rD]);
strcat(szMnemonic, "i");
return(popcd);
}
}
else if (m_popcd == rgopcd+0x000E)
{
// addi rD,rA,SIMM
if (m_ppciw.D.rA == 0)
{
return(&opcdLi);
}
}
else if (m_popcd == rgopcd+0x000F)
{
// addis rD,rA,SIMM
if (m_ppciw.D.rA == 0)
{
return(&opcdLis);
}
}
else if (m_popcd == rgopcd+0x0010)
{
// bc BO,BI,target
switch (m_ppciw.B.BO & 0x1E)
{
case 0 : // Dec CTR, Branch NZ and cond is false
case 2 : // Dec CTR, Branch Z and cond is false
case 8 : // Dec CTR, Branch NZ and cond is true
case 10 : // Dec CTR, Branch Z and cond is true
popcd->icls = iclsBc2;
strcpy(szMnemonic, "!@b");
strcat(szMnemonic, szBO[m_ppciw.B.BO >> 1]);
return(popcd);
case 4 : // Branch condition is false
popcd->icls = ((m_ppciw.B.BI >> 2) == 0) ? iclsBc4 : iclsBc3;
strcpy(szMnemonic, "!@b");
strcat(szMnemonic, szBIFalse[m_ppciw.B.BI & 3]);
return(popcd);
case 12 : // Branch condition is true
popcd->icls = ((m_ppciw.B.BI >> 2) == 0) ? iclsBc4 : iclsBc3;
strcpy(szMnemonic, "!@b");
strcat(szMnemonic, szBITrue[m_ppciw.B.BI & 3]);
return(popcd);
case 16 : // Dec CTR, Branch if non-zero
case 18 : // Dec CTR, Branch if zero
popcd->icls = iclsBc4;
strcpy(szMnemonic, "!@b");
strcat(szMnemonic, szBO[m_ppciw.B.BO >> 1]);
return(popcd);
}
}
else if (m_popcd == rgopcd+0x0018)
{
// ori rA,rS,UIMM
if ((m_ppciw.D.rD == 0) &&
(m_ppciw.D.rA == 0) &&
(m_ppciw.D.d == 0))
{
return(&opcdNop);
}
}
else if (m_popcd == rgopcd13_10+0x0000)
{
// bclr BO,BI
switch (m_ppciw.B.BO & 0x1E)
{
case 0 : // Dec CTR, Branch NZ and cond is false
case 2 : // Dec CTR, Branch Z and cond is false
case 8 : // Dec CTR, Branch NZ and cond is true
case 10 : // Dec CTR, Branch Z and cond is true
popcd->icls = iclsBc5;
strcpy(szMnemonic, "!b");
strcat(szMnemonic, szBO[m_ppciw.B.BO >> 1]);
strcat(szMnemonic, "lr");
return(popcd);
case 4 : // Branch condition is false
popcd->icls = ((m_ppciw.B.BI >> 2) == 0) ? iclsXL_4 : iclsBc6;
strcpy(szMnemonic, "!b");
strcat(szMnemonic, szBIFalse[m_ppciw.B.BI & 3]);
strcat(szMnemonic, "lr");
return(popcd);
case 12 : // Branch condition is true
popcd->icls = ((m_ppciw.B.BI >> 2) == 0) ? iclsXL_4 : iclsBc6;
strcpy(szMnemonic, "!b");
strcat(szMnemonic, szBITrue[m_ppciw.B.BI & 3]);
strcat(szMnemonic, "lr");
return(popcd);
case 16 : // Dec CTR, Branch if non-zero
case 18 : // Dec CTR, Branch if zero
case 20 : // Branch unconditionally
popcd->icls = iclsXL_4;
strcpy(szMnemonic, "!b");
strcat(szMnemonic, szBO[m_ppciw.B.BO >> 1]);
strcat(szMnemonic, "lr");
return(popcd);
}
}
else if (m_popcd == rgopcd13_10+0x0010)
{
// bcctr BO,BI
switch (m_ppciw.B.BO & 0x1E)
{
case 4 : // Branch condition is false
popcd->icls = ((m_ppciw.B.BI >> 2) == 0) ? iclsXL_4 : iclsBc6;
strcpy(szMnemonic, "!b");
strcat(szMnemonic, szBIFalse[m_ppciw.B.BI & 3]);
strcat(szMnemonic, "ctr");
return(popcd);
case 12 : // Branch condition is true
popcd->icls = ((m_ppciw.B.BI >> 2) == 0) ? iclsXL_4 : iclsBc6;
strcpy(szMnemonic, "!b");
strcat(szMnemonic, szBITrue[m_ppciw.B.BI & 3]);
strcat(szMnemonic, "ctr");
return(popcd);
case 20 : // Branch unconditionally
popcd->icls = iclsXL_4;
strcpy(szMnemonic, "!b");
strcat(szMnemonic, szBO[m_ppciw.B.BO >> 1]);
strcat(szMnemonic, "ctr");
return(popcd);
}
}
else if (m_popcd == rgopcd1F_04+0x0000)
{
// tw TO,rA,rB
if ((m_ppciw.X.rD == 31) &&
(m_ppciw.X.rA == 0) &&
(m_ppciw.X.rB == 0))
{
return(&opcdTrap);
}
if (szTO[m_ppciw.X.rD] != NULL)
{
popcd->icls = iclsTw2;
strcpy(szMnemonic, "tw");
strcat(szMnemonic, szTO[m_ppciw.X.rD]);
return(popcd);
}
}
else if (m_popcd == rgopcd1F_04+0x0002)
{
// td TO,rA,rB
if (szTO[m_ppciw.X.rD] != NULL)
{
popcd->icls = iclsTw2;
strcpy(szMnemonic, "td");
strcat(szMnemonic, szTO[m_ppciw.X.rD]);
return(popcd);
}
}
else if (m_popcd == rgopcd1F_13+0x000A)
{
// mfspr rD,SPR
SPRREG sprreg = (SPRREG) (((m_ppciw.XFX.SPR & 0x1F) << 5) + (m_ppciw.XFX.SPR >> 5));
switch (sprreg)
{
size_t isprmap;
case sprregXer :
case sprregLr :
case sprregCtr :
case sprregDsisr :
case sprregDar :
case sprregDec :
case sprregSdr1 :
case sprregSrr0 :
case sprregSrr1 :
case sprregAsr :
case sprregEar :
case sprregPvr :
case sprregSia :
case sprregSda :
popcd->icls = iclsX_3;
strcpy(szMnemonic, "mf");
for (isprmap = 0; isprmap < csprmap; isprmap++)
{
if (rgsprmap[isprmap].sprreg == sprreg)
{
strcat(szMnemonic, rgsprmap[isprmap].szName);
break;
}
}
return(popcd);
case sprregMmcr0 :
// UNDONE: Need new operand type for MMCR number
break;
case sprregPmc1 :
case sprregPmc2 :
// UNDONE: Need new operand type for PMC number
break;
case sprregSprg0 :
case sprregSprg1 :
case sprregSprg2 :
case sprregSprg3 :
// UNDONE: Need new operand type for SPRG number
break;
case sprregIbat0u :
case sprregIbat0l :
case sprregIbat1u :
case sprregIbat1l :
case sprregIbat2u :
case sprregIbat2l :
case sprregIbat3u :
case sprregIbat3l :
case sprregDbat0u :
case sprregDbat0l :
case sprregDbat1u :
case sprregDbat1l :
case sprregDbat2u :
case sprregDbat2l :
case sprregDbat3u :
case sprregDbat3l :
// UNDONE: Need new operand type for BAT number
break;
}
}
else if (m_popcd == rgopcd1F_13+0x000E)
{
// mtspr rD,SPR
SPRREG sprreg = (SPRREG) (((m_ppciw.XFX.SPR & 0x1F) << 5) + (m_ppciw.XFX.SPR >> 5));
switch (sprreg)
{
size_t isprmap;
case sprregXer :
case sprregLr :
case sprregCtr :
case sprregDsisr :
case sprregDar :
case sprregDec :
case sprregSdr1 :
case sprregSrr0 :
case sprregSrr1 :
case sprregAsr :
case sprregEar :
case sprregTbl :
case sprregTbu :
popcd->icls = iclsX_21;
strcpy(szMnemonic, "mt");
for (isprmap = 0; isprmap < csprmap; isprmap++)
{
if (rgsprmap[isprmap].sprreg == sprreg)
{
strcat(szMnemonic, rgsprmap[isprmap].szName);
break;
}
}
return(popcd);
case sprregMmcr0 :
// UNDONE: Need new operand type for MMCR number
break;
case sprregPmc1 :
case sprregPmc2 :
// UNDONE: Need new operand type for PMC number
break;
case sprregSprg0 :
case sprregSprg1 :
case sprregSprg2 :
case sprregSprg3 :
// UNDONE: Need new operand type for SPRG number
break;
case sprregIbat0u :
case sprregIbat0l :
case sprregIbat1u :
case sprregIbat1l :
case sprregIbat2u :
case sprregIbat2l :
case sprregIbat3u :
case sprregIbat3l :
case sprregDbat0u :
case sprregDbat0l :
case sprregDbat1u :
case sprregDbat1l :
case sprregDbat2u :
case sprregDbat2l :
case sprregDbat3u :
case sprregDbat3l :
// UNDONE: Need new operand type for BAT number
break;
}
}
else if (m_popcd == rgopcd1F_1C+0x0003)
{
// nor rA,rS,rB
if (m_ppciw.X.rD == m_ppciw.X.rB)
{
return(&opcdNot);
}
}
else if (m_popcd == rgopcd1F_1C+0x000D)
{
// or rA,rS,rB
if (m_ppciw.X.rD == m_ppciw.X.rB)
{
return(&opcdMr);
}
}
return(NULL);
}
TRMTPPC DISPPC::Trmtppc() const
{
ICLS icls = (ICLS) m_popcd->icls;
Assert(icls != iclsInvalid);
// Overrides
switch (icls)
{
case iclsB :
if (m_ppciw.B.LK == 1)
{
return(trmtppcCall);
}
break;
case iclsBc :
if (m_ppciw.B.LK == 1)
{
return(trmtppcCallCc);
}
switch(m_ppciw.B.BO & 0x1E)
{
case 0x04 :
case 0x0C :
case 0x10 :
case 0x12 :
return(trmtppcBraCcR); // Reversable BraCc
}
break;
case iclsBcctr :
case iclsBclr :
if ((m_ppciw.B.BO & 0x1E) == 20)
{
// Unconditional
if (m_ppciw.B.LK == 1)
{
return(trmtppcCallInd);
}
return(trmtppcBraInd);
}
break;
}
// Just return the regular TRMT
TRMTPPC trmtppc = (TRMTPPC) rgcls[icls].trmtppc;
return(trmtppc);
}