← Back to branch summary

~registry/dolphin-emu/triforce

« back to all changes in this revision

Viewing changes to Source/Core/Core/Src/PowerPC/Jit64/Jit64_Tables.cpp

  • Committer: Sérgio Benjamim
  • Date: 2015-02-13 05:54:40 UTC
  • Revision ID: sergio_br2@yahoo.com.br-20150213055440-ey2rt3sjpy27km78
Dolphin Triforce branch from code.google, commit b957980 (4.0-315).

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/Core/Core/Src/PowerPC/Jit64/Jit64_Tables.cpp
 
1
// Copyright 2013 Dolphin Emulator Project
 
2
// Licensed under GPLv2
 
3
// Refer to the license.txt file included.
 
4
 
 
5
#include "Jit.h"
 
6
#include "Jit64_Tables.h"
 
7
 
 
8
// Should be moved in to the Jit class
 
9
typedef void (Jit64::*_Instruction) (UGeckoInstruction instCode);
 
10
 
 
11
static _Instruction dynaOpTable[64];
 
12
static _Instruction dynaOpTable4[1024];
 
13
static _Instruction dynaOpTable19[1024];
 
14
static _Instruction dynaOpTable31[1024];
 
15
static _Instruction dynaOpTable59[32];
 
16
static _Instruction dynaOpTable63[1024];
 
17
void Jit64::DynaRunTable4(UGeckoInstruction _inst)  {(this->*dynaOpTable4 [_inst.SUBOP10])(_inst);}
 
18
void Jit64::DynaRunTable19(UGeckoInstruction _inst) {(this->*dynaOpTable19[_inst.SUBOP10])(_inst);}
 
19
void Jit64::DynaRunTable31(UGeckoInstruction _inst) {(this->*dynaOpTable31[_inst.SUBOP10])(_inst);}
 
20
void Jit64::DynaRunTable59(UGeckoInstruction _inst) {(this->*dynaOpTable59[_inst.SUBOP5 ])(_inst);}
 
21
void Jit64::DynaRunTable63(UGeckoInstruction _inst) {(this->*dynaOpTable63[_inst.SUBOP10])(_inst);}
 
22
 
 
23
struct GekkoOPTemplate
 
24
{
 
25
        int opcode;
 
26
        _Instruction Inst;
 
27
        //GekkoOPInfo opinfo; // Doesn't need opinfo, Interpreter fills it out
 
28
};
 
29
 
 
30
static GekkoOPTemplate primarytable[] = 
 
31
{
 
32
        {4,  &Jit64::DynaRunTable4}, //"RunTable4",  OPTYPE_SUBTABLE | (4<<24), 0}},
 
33
        {19, &Jit64::DynaRunTable19}, //"RunTable19", OPTYPE_SUBTABLE | (19<<24), 0}},
 
34
        {31, &Jit64::DynaRunTable31}, //"RunTable31", OPTYPE_SUBTABLE | (31<<24), 0}},
 
35
        {59, &Jit64::DynaRunTable59}, //"RunTable59", OPTYPE_SUBTABLE | (59<<24), 0}},
 
36
        {63, &Jit64::DynaRunTable63}, //"RunTable63", OPTYPE_SUBTABLE | (63<<24), 0}},
 
37
 
 
38
        {16, &Jit64::bcx}, //"bcx", OPTYPE_SYSTEM, FL_ENDBLOCK}},
 
39
        {18, &Jit64::bx}, //"bx",  OPTYPE_SYSTEM, FL_ENDBLOCK}},
 
40
 
 
41
        {1,  &Jit64::HLEFunction}, //"HLEFunction", OPTYPE_SYSTEM, FL_ENDBLOCK}},
 
42
        {2,  &Jit64::Default}, //"DynaBlock",   OPTYPE_SYSTEM, 0}},
 
43
        {3,  &Jit64::twx}, //"twi",         OPTYPE_SYSTEM, FL_ENDBLOCK}},
 
44
        {17, &Jit64::sc}, //"sc",          OPTYPE_SYSTEM, FL_ENDBLOCK, 1}},
 
45
 
 
46
        {7,  &Jit64::mulli}, //"mulli",    OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_RC_BIT, 2}},
 
47
        {8,  &Jit64::subfic}, //"subfic",   OPTYPE_INTEGER, FL_OUT_D | FL_IN_A |        FL_SET_CA}},
 
48
        {10, &Jit64::cmpXX}, //"cmpli",    OPTYPE_INTEGER, FL_IN_A | FL_SET_CRn}},
 
49
        {11, &Jit64::cmpXX}, //"cmpi",     OPTYPE_INTEGER, FL_IN_A | FL_SET_CRn}},
 
50
        {12, &Jit64::reg_imm}, //"addic",    OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_SET_CA}},
 
51
        {13, &Jit64::reg_imm}, //"addic_rc", OPTYPE_INTEGER, FL_OUT_D | FL_IN_A | FL_SET_CR0}},
 
52
        {14, &Jit64::reg_imm}, //"addi",     OPTYPE_INTEGER, FL_OUT_D | FL_IN_A0}},
 
53
        {15, &Jit64::reg_imm}, //"addis",    OPTYPE_INTEGER, FL_OUT_D | FL_IN_A0}},
 
54
 
 
55
        {20, &Jit64::rlwimix}, //"rlwimix",  OPTYPE_INTEGER, FL_OUT_A | FL_IN_A | FL_IN_S | FL_RC_BIT}},
 
56
        {21, &Jit64::rlwinmx}, //"rlwinmx",  OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_RC_BIT}},
 
57
        {23, &Jit64::rlwnmx}, //"rlwnmx",   OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_IN_B | FL_RC_BIT}},
 
58
 
 
59
        {24, &Jit64::reg_imm}, //"ori",      OPTYPE_INTEGER, FL_OUT_A | FL_IN_S}},
 
60
        {25, &Jit64::reg_imm}, //"oris",     OPTYPE_INTEGER, FL_OUT_A | FL_IN_S}},
 
61
        {26, &Jit64::reg_imm}, //"xori",     OPTYPE_INTEGER, FL_OUT_A | FL_IN_S}},
 
62
        {27, &Jit64::reg_imm}, //"xoris",    OPTYPE_INTEGER, FL_OUT_A | FL_IN_S}},
 
63
        {28, &Jit64::reg_imm}, //"andi_rc",  OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_SET_CR0}},
 
64
        {29, &Jit64::reg_imm}, //"andis_rc", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_SET_CR0}},
 
65
 
 
66
        {32, &Jit64::lXXx}, //"lwz",  OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
 
67
        {33, &Jit64::lXXx}, //"lwzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
 
68
        {34, &Jit64::lXXx}, //"lbz",  OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
 
69
        {35, &Jit64::lXXx}, //"lbzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
 
70
        {40, &Jit64::lXXx}, //"lhz",  OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
 
71
        {41, &Jit64::lXXx}, //"lhzu", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
 
72
        {42, &Jit64::lXXx}, //"lha",  OPTYPE_LOAD, FL_OUT_D | FL_IN_A}},
 
73
        {43, &Jit64::lXXx}, //"lhau", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A}},
 
74
 
 
75
        {44, &Jit64::stX}, //"sth",  OPTYPE_STORE, FL_IN_A | FL_IN_S}},
 
76
        {45, &Jit64::stX}, //"sthu", OPTYPE_STORE, FL_OUT_A | FL_IN_A | FL_IN_S}},
 
77
        {36, &Jit64::stX}, //"stw",  OPTYPE_STORE, FL_IN_A | FL_IN_S}},
 
78
        {37, &Jit64::stX}, //"stwu", OPTYPE_STORE, FL_OUT_A | FL_IN_A | FL_IN_S}},
 
79
        {38, &Jit64::stX}, //"stb",  OPTYPE_STORE, FL_IN_A | FL_IN_S}},
 
80
        {39, &Jit64::stX}, //"stbu", OPTYPE_STORE, FL_OUT_A | FL_IN_A | FL_IN_S}},
 
81
 
 
82
        {46, &Jit64::lmw}, //"lmw",   OPTYPE_SYSTEM, FL_EVIL, 10}},
 
83
        {47, &Jit64::stmw}, //"stmw",  OPTYPE_SYSTEM, FL_EVIL, 10}},
 
84
 
 
85
        {48, &Jit64::lfs}, //"lfs",  OPTYPE_LOADFP, FL_IN_A}},
 
86
        {49, &Jit64::Default}, //"lfsu", OPTYPE_LOADFP, FL_OUT_A | FL_IN_A}},
 
87
        {50, &Jit64::lfd}, //"lfd",  OPTYPE_LOADFP, FL_IN_A}},
 
88
        {51, &Jit64::Default}, //"lfdu", OPTYPE_LOADFP, FL_OUT_A | FL_IN_A}},
 
89
 
 
90
        {52, &Jit64::stfs}, //"stfs",  OPTYPE_STOREFP, FL_IN_A}},
 
91
        {53, &Jit64::stfs}, //"stfsu", OPTYPE_STOREFP, FL_OUT_A | FL_IN_A}},
 
92
        {54, &Jit64::stfd}, //"stfd",  OPTYPE_STOREFP, FL_IN_A}},
 
93
        {55, &Jit64::Default}, //"stfdu", OPTYPE_STOREFP, FL_OUT_A | FL_IN_A}},
 
94
 
 
95
        {56, &Jit64::psq_l}, //"psq_l",   OPTYPE_PS, FL_IN_A}},
 
96
        {57, &Jit64::psq_l}, //"psq_lu",  OPTYPE_PS, FL_OUT_A | FL_IN_A}},
 
97
        {60, &Jit64::psq_st}, //"psq_st",  OPTYPE_PS, FL_IN_A}},
 
98
        {61, &Jit64::psq_st}, //"psq_stu", OPTYPE_PS, FL_OUT_A | FL_IN_A}},
 
99
 
 
100
        //missing: 0, 5, 6, 9, 22, 30, 62, 58
 
101
        {0,  &Jit64::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
 
102
        {5,  &Jit64::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
 
103
        {6,  &Jit64::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
 
104
        {9,  &Jit64::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
 
105
        {22, &Jit64::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
 
106
        {30, &Jit64::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
 
107
        {62, &Jit64::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
 
108
        {58, &Jit64::Default}, //"unknown_instruction", OPTYPE_UNKNOWN, 0}},
 
109
};
 
110
 
 
111
static GekkoOPTemplate table4[] = 
 
112
{    //SUBOP10
 
113
        {0,    &Jit64::Default}, //"ps_cmpu0",   OPTYPE_PS, FL_SET_CRn}},
 
114
        {32,   &Jit64::Default}, //"ps_cmpo0",   OPTYPE_PS, FL_SET_CRn}},
 
115
        {40,   &Jit64::ps_sign}, //"ps_neg",     OPTYPE_PS, FL_RC_BIT}},
 
116
        {136,  &Jit64::ps_sign}, //"ps_nabs",    OPTYPE_PS, FL_RC_BIT}},
 
117
        {264,  &Jit64::ps_sign}, //"ps_abs",     OPTYPE_PS, FL_RC_BIT}},
 
118
        {64,   &Jit64::Default}, //"ps_cmpu1",   OPTYPE_PS, FL_RC_BIT}},
 
119
        {72,   &Jit64::ps_mr}, //"ps_mr",      OPTYPE_PS, FL_RC_BIT}},
 
120
        {96,   &Jit64::Default}, //"ps_cmpo1",   OPTYPE_PS, FL_RC_BIT}},
 
121
        {528,  &Jit64::ps_mergeXX}, //"ps_merge00", OPTYPE_PS, FL_RC_BIT}},
 
122
        {560,  &Jit64::ps_mergeXX}, //"ps_merge01", OPTYPE_PS, FL_RC_BIT}},
 
123
        {592,  &Jit64::ps_mergeXX}, //"ps_merge10", OPTYPE_PS, FL_RC_BIT}},
 
124
        {624,  &Jit64::ps_mergeXX}, //"ps_merge11", OPTYPE_PS, FL_RC_BIT}},
 
125
 
 
126
        {1014, &Jit64::Default}, //"dcbz_l",     OPTYPE_SYSTEM, 0}},
 
127
};              
 
128
 
 
129
static GekkoOPTemplate table4_2[] = 
 
130
{
 
131
        {10, &Jit64::ps_sum}, //"ps_sum0",   OPTYPE_PS, 0}},
 
132
        {11, &Jit64::ps_sum}, //"ps_sum1",   OPTYPE_PS, 0}},
 
133
        {12, &Jit64::ps_muls}, //"ps_muls0",  OPTYPE_PS, 0}},
 
134
        {13, &Jit64::ps_muls}, //"ps_muls1",  OPTYPE_PS, 0}},
 
135
        {14, &Jit64::ps_maddXX}, //"ps_madds0", OPTYPE_PS, 0}},
 
136
        {15, &Jit64::ps_maddXX}, //"ps_madds1", OPTYPE_PS, 0}},
 
137
        {18, &Jit64::ps_arith}, //"ps_div",    OPTYPE_PS, 0, 16}},
 
138
        {20, &Jit64::ps_arith}, //"ps_sub",    OPTYPE_PS, 0}},
 
139
        {21, &Jit64::ps_arith}, //"ps_add",    OPTYPE_PS, 0}},
 
140
        {23, &Jit64::ps_sel}, //"ps_sel",    OPTYPE_PS, 0}},
 
141
        {24, &Jit64::Default}, //"ps_res",    OPTYPE_PS, 0}},
 
142
        {25, &Jit64::ps_arith}, //"ps_mul",    OPTYPE_PS, 0}},
 
143
        {26, &Jit64::ps_rsqrte}, //"ps_rsqrte", OPTYPE_PS, 0, 1}},
 
144
        {28, &Jit64::ps_maddXX}, //"ps_msub",   OPTYPE_PS, 0}},
 
145
        {29, &Jit64::ps_maddXX}, //"ps_madd",   OPTYPE_PS, 0}},
 
146
        {30, &Jit64::ps_maddXX}, //"ps_nmsub",  OPTYPE_PS, 0}},
 
147
        {31, &Jit64::ps_maddXX}, //"ps_nmadd",  OPTYPE_PS, 0}},
 
148
};
 
149
 
 
150
 
 
151
static GekkoOPTemplate table4_3[] = 
 
152
{
 
153
        {6,  &Jit64::Default}, //"psq_lx",   OPTYPE_PS, 0}},
 
154
        {7,  &Jit64::Default}, //"psq_stx",  OPTYPE_PS, 0}},
 
155
        {38, &Jit64::Default}, //"psq_lux",  OPTYPE_PS, 0}},
 
156
        {39, &Jit64::Default}, //"psq_stux", OPTYPE_PS, 0}}, 
 
157
};
 
158
 
 
159
static GekkoOPTemplate table19[] = 
 
160
{
 
161
        {528, &Jit64::bcctrx}, //"bcctrx", OPTYPE_BRANCH, FL_ENDBLOCK}},
 
162
        {16,  &Jit64::bclrx}, //"bclrx",  OPTYPE_BRANCH, FL_ENDBLOCK}},
 
163
        {257, &Jit64::crXXX}, //"crand",  OPTYPE_CR, FL_EVIL}},
 
164
        {129, &Jit64::crXXX}, //"crandc", OPTYPE_CR, FL_EVIL}},
 
165
        {289, &Jit64::crXXX}, //"creqv",  OPTYPE_CR, FL_EVIL}},
 
166
        {225, &Jit64::crXXX}, //"crnand", OPTYPE_CR, FL_EVIL}},
 
167
        {33,  &Jit64::crXXX}, //"crnor",  OPTYPE_CR, FL_EVIL}},
 
168
        {449, &Jit64::crXXX}, //"cror",   OPTYPE_CR, FL_EVIL}},
 
169
        {417, &Jit64::crXXX}, //"crorc",  OPTYPE_CR, FL_EVIL}},
 
170
        {193, &Jit64::crXXX}, //"crxor",  OPTYPE_CR, FL_EVIL}},
 
171
                                                                                                   
 
172
        {150, &Jit64::DoNothing}, //"isync",  OPTYPE_ICACHE, FL_EVIL}},
 
173
        {0,   &Jit64::mcrf}, //"mcrf",   OPTYPE_SYSTEM, FL_EVIL}},
 
174
                                                                                                   
 
175
        {50,  &Jit64::rfi}, //"rfi",    OPTYPE_SYSTEM, FL_ENDBLOCK | FL_CHECKEXCEPTIONS, 1}},
 
176
        {18,  &Jit64::Default}, //"rfid",   OPTYPE_SYSTEM, FL_ENDBLOCK | FL_CHECKEXCEPTIONS}}
 
177
};
 
178
 
 
179
 
 
180
static GekkoOPTemplate table31[] = 
 
181
{
 
182
        {28,  &Jit64::boolX}, //"andx",   OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
 
183
        {60,  &Jit64::boolX}, //"andcx",  OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
 
184
        {444, &Jit64::boolX}, //"orx",    OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
 
185
        {124, &Jit64::boolX}, //"norx",   OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
 
186
        {316, &Jit64::boolX}, //"xorx",   OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
 
187
        {412, &Jit64::boolX}, //"orcx",   OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
 
188
        {476, &Jit64::boolX}, //"nandx",  OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
 
189
        {284, &Jit64::boolX}, //"eqvx",   OPTYPE_INTEGER, FL_OUT_A | FL_IN_SB | FL_RC_BIT}},
 
190
        {0,   &Jit64::cmpXX}, //"cmp",    OPTYPE_INTEGER, FL_IN_AB | FL_SET_CRn}},
 
191
        {32,  &Jit64::cmpXX}, //"cmpl",   OPTYPE_INTEGER, FL_IN_AB | FL_SET_CRn}},
 
192
        {26,  &Jit64::cntlzwx}, //"cntlzwx",OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_RC_BIT}},
 
193
        {922, &Jit64::extshx}, //"extshx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_RC_BIT}},
 
194
        {954, &Jit64::extsbx}, //"extsbx", OPTYPE_INTEGER, FL_OUT_A | FL_IN_S | FL_RC_BIT}},
 
195
        {536, &Jit64::srwx}, //"srwx",   OPTYPE_INTEGER, FL_OUT_A | FL_IN_B | FL_IN_S | FL_RC_BIT}},
 
196
        {792, &Jit64::srawx}, //"srawx",  OPTYPE_INTEGER, FL_OUT_A | FL_IN_B | FL_IN_S | FL_RC_BIT}},
 
197
        {824, &Jit64::srawix}, //"srawix", OPTYPE_INTEGER, FL_OUT_A | FL_IN_B | FL_IN_S | FL_RC_BIT}},
 
198
        {24,  &Jit64::slwx}, //"slwx",   OPTYPE_INTEGER, FL_OUT_A | FL_IN_B | FL_IN_S | FL_RC_BIT}},
 
199
 
 
200
        {54,   &Jit64::dcbst}, //"dcbst",  OPTYPE_DCACHE, 0, 4}},
 
201
        {86,   &Jit64::Default}, //"dcbf",   OPTYPE_DCACHE, 0, 4}},
 
202
        {246,  &Jit64::DoNothing}, //"dcbtst", OPTYPE_DCACHE, 0, 1}},
 
203
        {278,  &Jit64::DoNothing}, //"dcbt",   OPTYPE_DCACHE, 0, 1}},
 
204
        {470,  &Jit64::Default}, //"dcbi",   OPTYPE_DCACHE, 0, 4}},
 
205
        {758,  &Jit64::DoNothing}, //"dcba",   OPTYPE_DCACHE, 0, 4}},
 
206
        {1014, &Jit64::dcbz}, //"dcbz",   OPTYPE_DCACHE, 0, 4}},
 
207
 
 
208
        //load word
 
209
        {23,  &Jit64::lXXx}, //"lwzx",  OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
 
210
        {55,  &Jit64::lXXx}, //"lwzux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
 
211
 
 
212
        //load halfword
 
213
        {279, &Jit64::lXXx}, //"lhzx",  OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
 
214
        {311, &Jit64::lXXx}, //"lhzux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
 
215
 
 
216
        //load halfword signextend
 
217
        {343, &Jit64::lXXx}, //"lhax",  OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
 
218
        {375, &Jit64::lXXx}, //"lhaux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
 
219
 
 
220
        //load byte
 
221
        {87,  &Jit64::lXXx}, //"lbzx",  OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
 
222
        {119, &Jit64::lXXx}, //"lbzux", OPTYPE_LOAD, FL_OUT_D | FL_OUT_A | FL_IN_A | FL_IN_B}},
 
223
 
 
224
        //load byte reverse
 
225
        {534, &Jit64::Default}, //"lwbrx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
 
226
        {790, &Jit64::Default}, //"lhbrx", OPTYPE_LOAD, FL_OUT_D | FL_IN_A0 | FL_IN_B}},
 
227
 
 
228
        // Conditional load/store (Wii SMP)
 
229
        {150, &Jit64::Default}, //"stwcxd", OPTYPE_STORE, FL_EVIL | FL_SET_CR0}},
 
230
        {20,  &Jit64::Default}, //"lwarx",  OPTYPE_LOAD, FL_EVIL | FL_OUT_D | FL_IN_A0B | FL_SET_CR0}},
 
231
 
 
232
        //load string (interpret these)
 
233
        {533, &Jit64::Default}, //"lswx",  OPTYPE_LOAD, FL_EVIL | FL_IN_A | FL_OUT_D}},
 
234
        {597, &Jit64::Default}, //"lswi",  OPTYPE_LOAD, FL_EVIL | FL_IN_AB | FL_OUT_D}},
 
235
 
 
236
        //store word
 
237
        {151, &Jit64::stXx}, //"stwx",   OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
 
238
        {183, &Jit64::stXx}, //"stwux",  OPTYPE_STORE, FL_OUT_A | FL_IN_A | FL_IN_B}},
 
239
 
 
240
        //store halfword
 
241
        {407, &Jit64::stXx}, //"sthx",   OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
 
242
        {439, &Jit64::stXx}, //"sthux",  OPTYPE_STORE, FL_OUT_A | FL_IN_A | FL_IN_B}},
 
243
 
 
244
        //store byte
 
245
        {215, &Jit64::stXx}, //"stbx",   OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
 
246
        {247, &Jit64::stXx}, //"stbux",  OPTYPE_STORE, FL_OUT_A | FL_IN_A | FL_IN_B}},
 
247
 
 
248
        //store bytereverse
 
249
        {662, &Jit64::Default}, //"stwbrx", OPTYPE_STORE, FL_IN_A0 | FL_IN_B}},
 
250
        {918, &Jit64::Default}, //"sthbrx", OPTYPE_STORE, FL_IN_A | FL_IN_B}},
 
251
 
 
252
        {661, &Jit64::Default}, //"stswx",  OPTYPE_STORE, FL_EVIL}},
 
253
        {725, &Jit64::Default}, //"stswi",  OPTYPE_STORE, FL_EVIL}},
 
254
 
 
255
        // fp load/store        
 
256
        {535, &Jit64::lfsx}, //"lfsx",  OPTYPE_LOADFP, FL_IN_A0 | FL_IN_B}},
 
257
        {567, &Jit64::Default}, //"lfsux", OPTYPE_LOADFP, FL_IN_A | FL_IN_B}},
 
258
        {599, &Jit64::Default}, //"lfdx",  OPTYPE_LOADFP, FL_IN_A0 | FL_IN_B}},
 
259
        {631, &Jit64::Default}, //"lfdux", OPTYPE_LOADFP, FL_IN_A | FL_IN_B}},
 
260
 
 
261
        {663, &Jit64::stfsx}, //"stfsx",  OPTYPE_STOREFP, FL_IN_A0 | FL_IN_B}},
 
262
        {695, &Jit64::Default}, //"stfsux", OPTYPE_STOREFP, FL_IN_A | FL_IN_B}},
 
263
        {727, &Jit64::Default}, //"stfdx",  OPTYPE_STOREFP, FL_IN_A0 | FL_IN_B}},
 
264
        {759, &Jit64::Default}, //"stfdux", OPTYPE_STOREFP, FL_IN_A | FL_IN_B}},
 
265
        {983, &Jit64::Default}, //"stfiwx", OPTYPE_STOREFP, FL_IN_A0 | FL_IN_B}},
 
266
 
 
267
        {19,  &Jit64::mfcr}, //"mfcr",   OPTYPE_SYSTEM, FL_OUT_D}},
 
268
        {83,  &Jit64::mfmsr}, //"mfmsr",  OPTYPE_SYSTEM, FL_OUT_D}},
 
269
        {144, &Jit64::mtcrf}, //"mtcrf",  OPTYPE_SYSTEM, 0}},
 
270
        {146, &Jit64::mtmsr}, //"mtmsr",  OPTYPE_SYSTEM, FL_ENDBLOCK}},
 
271
        {210, &Jit64::Default}, //"mtsr",   OPTYPE_SYSTEM, 0}},
 
272
        {242, &Jit64::Default}, //"mtsrin", OPTYPE_SYSTEM, 0}},
 
273
        {339, &Jit64::mfspr}, //"mfspr",  OPTYPE_SPR, FL_OUT_D}},
 
274
        {467, &Jit64::mtspr}, //"mtspr",  OPTYPE_SPR, 0, 2}},
 
275
        {371, &Jit64::mftb}, //"mftb",   OPTYPE_SYSTEM, FL_OUT_D | FL_TIMER}},
 
276
        {512, &Jit64::mcrxr}, //"mcrxr",  OPTYPE_SYSTEM, 0}},
 
277
        {595, &Jit64::Default}, //"mfsr",   OPTYPE_SYSTEM, FL_OUT_D, 2}},
 
278
        {659, &Jit64::Default}, //"mfsrin", OPTYPE_SYSTEM, FL_OUT_D, 2}},
 
279
 
 
280
        {4,   &Jit64::twx}, //"tw",     OPTYPE_SYSTEM, FL_ENDBLOCK, 1}},
 
281
        {598, &Jit64::DoNothing}, //"sync",   OPTYPE_SYSTEM, 0, 2}},
 
282
        {982, &Jit64::icbi}, //"icbi",   OPTYPE_SYSTEM, FL_ENDBLOCK, 3}},
 
283
 
 
284
        // Unused instructions on GC
 
285
        {310, &Jit64::Default}, //"eciwx",   OPTYPE_INTEGER, FL_RC_BIT}},
 
286
        {438, &Jit64::Default}, //"ecowx",   OPTYPE_INTEGER, FL_RC_BIT}},
 
287
        {854, &Jit64::Default}, //"eieio",   OPTYPE_INTEGER, FL_RC_BIT}},
 
288
        {306, &Jit64::Default}, //"tlbie",   OPTYPE_SYSTEM, 0}},
 
289
        {370, &Jit64::Default}, //"tlbia",   OPTYPE_SYSTEM, 0}},
 
290
        {566, &Jit64::Default}, //"tlbsync", OPTYPE_SYSTEM, 0}},
 
291
};
 
292
 
 
293
static GekkoOPTemplate table31_2[] = 
 
294
{       
 
295
        {266,  &Jit64::addx}, //"addx",    OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT}},
 
296
        {778,  &Jit64::addx}, //"addx",    OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT}},
 
297
        {10,   &Jit64::addcx}, //"addcx",   OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_SET_CA | FL_RC_BIT}},
 
298
        {522,  &Jit64::addcx}, //"addcox",   OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_SET_CA | FL_RC_BIT}},
 
299
        {138,  &Jit64::addex}, //"addex",   OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
 
300
        {650,  &Jit64::addex}, //"addeox",   OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
 
301
        {234,  &Jit64::addmex}, //"addmex",  OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
 
302
        {202,  &Jit64::addzex}, //"addzex",  OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
 
303
        {491,  &Jit64::divwx}, //"divwx",   OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 39}},
 
304
        {1003, &Jit64::divwx}, //"divwox",   OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 39}},
 
305
        {459,  &Jit64::divwux}, //"divwux",  OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 39}},
 
306
        {971,  &Jit64::divwux}, //"divwuox",  OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 39}},
 
307
        {75,   &Jit64::Default}, //"mulhwx",  OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 4}},
 
308
        {11,   &Jit64::mulhwux}, //"mulhwux", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 4}},
 
309
        {235,  &Jit64::mullwx}, //"mullwx",  OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 4}},
 
310
        {747,  &Jit64::mullwx}, //"mullwox",  OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT, 4}},
 
311
        {104,  &Jit64::negx}, //"negx",    OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT}},
 
312
        {40,   &Jit64::subfx}, //"subfx",   OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT}},
 
313
        {552,  &Jit64::subfx}, //"subox",   OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_RC_BIT}},
 
314
        {8,    &Jit64::subfcx}, //"subfcx",  OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_SET_CA | FL_RC_BIT}},
 
315
        {520,  &Jit64::subfcx}, //"subfcox",  OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_SET_CA | FL_RC_BIT}},
 
316
        {136,  &Jit64::subfex}, //"subfex",  OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
 
317
        {232,  &Jit64::subfmex}, //"subfmex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
 
318
        {200,  &Jit64::subfzex}, //"subfzex", OPTYPE_INTEGER, FL_OUT_D | FL_IN_AB | FL_READ_CA | FL_SET_CA | FL_RC_BIT}},
 
319
};
 
320
 
 
321
static GekkoOPTemplate table59[] = 
 
322
{
 
323
        {18, &Jit64::Default},       //{"fdivsx",   OPTYPE_FPU, FL_RC_BIT_F, 16}}, 
 
324
        {20, &Jit64::fp_arith_s}, //"fsubsx",   OPTYPE_FPU, FL_RC_BIT_F}}, 
 
325
        {21, &Jit64::fp_arith_s}, //"faddsx",   OPTYPE_FPU, FL_RC_BIT_F}}, 
 
326
//      {22, &Jit64::Default}, //"fsqrtsx",  OPTYPE_FPU, FL_RC_BIT_F}}, // Not implemented on gekko
 
327
        {24, &Jit64::Default}, //"fresx",    OPTYPE_FPU, FL_RC_BIT_F}}, 
 
328
        {25, &Jit64::fp_arith_s}, //"fmulsx",   OPTYPE_FPU, FL_RC_BIT_F}}, 
 
329
        {28, &Jit64::fmaddXX}, //"fmsubsx",  OPTYPE_FPU, FL_RC_BIT_F}}, 
 
330
        {29, &Jit64::fmaddXX}, //"fmaddsx",  OPTYPE_FPU, FL_RC_BIT_F}}, 
 
331
        {30, &Jit64::fmaddXX}, //"fnmsubsx", OPTYPE_FPU, FL_RC_BIT_F}}, 
 
332
        {31, &Jit64::fmaddXX}, //"fnmaddsx", OPTYPE_FPU, FL_RC_BIT_F}}, 
 
333
};                                                          
 
334
 
 
335
static GekkoOPTemplate table63[] = 
 
336
{
 
337
        {264, &Jit64::fsign},   //"fabsx",   OPTYPE_FPU, FL_RC_BIT_F}},
 
338
        {32,  &Jit64::fcmpx},   //"fcmpo",   OPTYPE_FPU, FL_RC_BIT_F}},
 
339
        {0,   &Jit64::fcmpx},   //"fcmpu",   OPTYPE_FPU, FL_RC_BIT_F}},
 
340
        {14,  &Jit64::Default}, //"fctiwx",  OPTYPE_FPU, FL_RC_BIT_F}},
 
341
        {15,  &Jit64::Default}, //"fctiwzx", OPTYPE_FPU, FL_RC_BIT_F}},
 
342
        {72,  &Jit64::fmrx},    //"fmrx",    OPTYPE_FPU, FL_RC_BIT_F}},
 
343
        {136, &Jit64::fsign},   //"fnabsx",  OPTYPE_FPU, FL_RC_BIT_F}},
 
344
        {40,  &Jit64::fsign},   //"fnegx",   OPTYPE_FPU, FL_RC_BIT_F}},
 
345
        {12,  &Jit64::Default}, //"frspx",   OPTYPE_FPU, FL_RC_BIT_F}},
 
346
 
 
347
        {64,  &Jit64::Default}, //"mcrfs",   OPTYPE_SYSTEMFP, 0}},
 
348
        {583, &Jit64::Default}, //"mffsx",   OPTYPE_SYSTEMFP, 0}},
 
349
        {70,  &Jit64::Default}, //"mtfsb0x", OPTYPE_SYSTEMFP, 0, 2}},
 
350
        {38,  &Jit64::Default}, //"mtfsb1x", OPTYPE_SYSTEMFP, 0, 2}},
 
351
        {134, &Jit64::Default}, //"mtfsfix", OPTYPE_SYSTEMFP, 0, 2}},
 
352
        {711, &Jit64::Default}, //"mtfsfx",  OPTYPE_SYSTEMFP, 0, 2}},
 
353
};
 
354
 
 
355
static GekkoOPTemplate table63_2[] = 
 
356
{
 
357
        {18, &Jit64::Default}, //"fdivx",    OPTYPE_FPU, FL_RC_BIT_F, 30}},
 
358
        {20, &Jit64::Default}, //"fsubx",    OPTYPE_FPU, FL_RC_BIT_F}},
 
359
        {21, &Jit64::Default}, //"faddx",    OPTYPE_FPU, FL_RC_BIT_F}},
 
360
        {22, &Jit64::Default}, //"fsqrtx",   OPTYPE_FPU, FL_RC_BIT_F}},
 
361
        {23, &Jit64::Default}, //"fselx",    OPTYPE_FPU, FL_RC_BIT_F}},
 
362
        {25, &Jit64::fp_arith_s}, //"fmulx",    OPTYPE_FPU, FL_RC_BIT_F}},
 
363
        {26, &Jit64::fp_arith_s}, //"frsqrtex", OPTYPE_FPU, FL_RC_BIT_F}},
 
364
        {28, &Jit64::fmaddXX}, //"fmsubx",   OPTYPE_FPU, FL_RC_BIT_F}},
 
365
        {29, &Jit64::fmaddXX}, //"fmaddx",   OPTYPE_FPU, FL_RC_BIT_F}},
 
366
        {30, &Jit64::fmaddXX}, //"fnmsubx",  OPTYPE_FPU, FL_RC_BIT_F}},
 
367
        {31, &Jit64::fmaddXX}, //"fnmaddx",  OPTYPE_FPU, FL_RC_BIT_F}},
 
368
};
 
369
 
 
370
namespace Jit64Tables
 
371
{
 
372
 
 
373
void CompileInstruction(PPCAnalyst::CodeOp & op)
 
374
{
 
375
        Jit64 *jit64 = (Jit64 *)jit;
 
376
        (jit64->*dynaOpTable[op.inst.OPCD])(op.inst);
 
377
        GekkoOPInfo *info = op.opinfo;
 
378
        if (info) {
 
379
#ifdef OPLOG
 
380
                if (!strcmp(info->opname, OP_TO_LOG)){  ///"mcrfs"
 
381
                        rsplocations.push_back(jit.js.compilerPC);
 
382
                }
 
383
#endif
 
384
                info->compileCount++;
 
385
                info->lastUse = jit->js.compilerPC;
 
386
        }
 
387
}
 
388
 
 
389
void InitTables()
 
390
{
 
391
        // once initialized, tables are read-only
 
392
        static bool initialized = false;
 
393
        if (initialized)
 
394
                return;
 
395
 
 
396
        //clear
 
397
        for (int i = 0; i < 32; i++) 
 
398
        {
 
399
                dynaOpTable59[i] = &Jit64::unknown_instruction;
 
400
        }
 
401
 
 
402
        for (int i = 0; i < 1024; i++)
 
403
        {
 
404
                dynaOpTable4 [i] = &Jit64::unknown_instruction;
 
405
                dynaOpTable19[i] = &Jit64::unknown_instruction;
 
406
                dynaOpTable31[i] = &Jit64::unknown_instruction;
 
407
                dynaOpTable63[i] = &Jit64::unknown_instruction; 
 
408
        }
 
409
 
 
410
        for (int i = 0; i < (int)(sizeof(primarytable) / sizeof(GekkoOPTemplate)); i++)
 
411
        {
 
412
                dynaOpTable[primarytable[i].opcode] = primarytable[i].Inst;
 
413
        }
 
414
 
 
415
        for (int i = 0; i < 32; i++)
 
416
        {
 
417
                int fill = i << 5;
 
418
                for (int j = 0; j < (int)(sizeof(table4_2) / sizeof(GekkoOPTemplate)); j++)
 
419
                {
 
420
                        int op = fill+table4_2[j].opcode;
 
421
                        dynaOpTable4[op] = table4_2[j].Inst;
 
422
                }
 
423
        }
 
424
 
 
425
        for (int i = 0; i < 16; i++)
 
426
        {
 
427
                int fill = i << 6;
 
428
                for (int j = 0; j < (int)(sizeof(table4_3) / sizeof(GekkoOPTemplate)); j++)
 
429
                {
 
430
                        int op = fill+table4_3[j].opcode;
 
431
                        dynaOpTable4[op] = table4_3[j].Inst;
 
432
                }
 
433
        }
 
434
 
 
435
        for (int i = 0; i < (int)(sizeof(table4) / sizeof(GekkoOPTemplate)); i++)
 
436
        {
 
437
                int op = table4[i].opcode;
 
438
                dynaOpTable4[op] = table4[i].Inst;
 
439
        }
 
440
 
 
441
        for (int i = 0; i < (int)(sizeof(table31) / sizeof(GekkoOPTemplate)); i++)
 
442
        {
 
443
                int op = table31[i].opcode;
 
444
                dynaOpTable31[op] = table31[i].Inst;
 
445
        }
 
446
 
 
447
        for (int i = 0; i < 1; i++)
 
448
        {
 
449
                int fill = i << 9;
 
450
                for (int j = 0; j < (int)(sizeof(table31_2) / sizeof(GekkoOPTemplate)); j++)
 
451
                {
 
452
                        int op = fill + table31_2[j].opcode;
 
453
                        dynaOpTable31[op] = table31_2[j].Inst;
 
454
                }
 
455
        }
 
456
 
 
457
        for (int i = 0; i < (int)(sizeof(table19) / sizeof(GekkoOPTemplate)); i++)
 
458
        {
 
459
                int op = table19[i].opcode;
 
460
                dynaOpTable19[op] = table19[i].Inst;
 
461
        }
 
462
 
 
463
        for (int i = 0; i < (int)(sizeof(table59) / sizeof(GekkoOPTemplate)); i++)
 
464
        {
 
465
                int op = table59[i].opcode;
 
466
                dynaOpTable59[op] = table59[i].Inst;
 
467
        }
 
468
 
 
469
        for (int i = 0; i < (int)(sizeof(table63) / sizeof(GekkoOPTemplate)); i++)
 
470
        {
 
471
                int op = table63[i].opcode;
 
472
                dynaOpTable63[op] = table63[i].Inst;
 
473
        }
 
474
 
 
475
        for (int i = 0; i < 32; i++)
 
476
        {
 
477
                int fill = i << 5;
 
478
                for (int j = 0; j < (int)(sizeof(table63_2) / sizeof(GekkoOPTemplate)); j++)
 
479
                {
 
480
                        int op = fill + table63_2[j].opcode;
 
481
                        dynaOpTable63[op] = table63_2[j].Inst;
 
482
                }
 
483
        }
 
484
 
 
485
        initialized = true;
 
486
}
 
487
 
 
488
}  // namespace