/[pcsx2_0.9.7]/trunk/pcsx2/Vif_Codes.cpp
ViewVC logotype

Contents of /trunk/pcsx2/Vif_Codes.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 191 - (show annotations) (download)
Mon Sep 20 05:35:51 2010 UTC (9 years, 9 months ago) by william
File size: 19634 byte(s)
Auto Commited Import of: pcsx2-0.9.7-DEBUG (upstream: v0.9.7.3795 local: v0.9.7.186-latest) in ./trunk
1 /* PCSX2 - PS2 Emulator for PCs
2 * Copyright (C) 2002-2010 PCSX2 Dev Team
3 *
4 * PCSX2 is free software: you can redistribute it and/or modify it under the terms
5 * of the GNU Lesser General Public License as published by the Free Software Found-
6 * ation, either version 3 of the License, or (at your option) any later version.
7 *
8 * PCSX2 is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
9 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
10 * PURPOSE. See the GNU General Public License for more details.
11 *
12 * You should have received a copy of the GNU General Public License along with PCSX2.
13 * If not, see <http://www.gnu.org/licenses/>.
14 */
15
16 #include "PrecompiledHeader.h"
17 #include "Common.h"
18 #include "GS.h"
19 #include "Gif.h"
20 #include "Vif_Dma.h"
21 #include "newVif.h"
22 #include "VUmicro.h"
23
24 #define vifOp(vifCodeName) _vifT int __fastcall vifCodeName(int pass, const u32 *data)
25 #define pass1 if (pass == 0)
26 #define pass2 if (pass == 1)
27 #define pass3 if (pass == 2)
28 #define vif1Only() { if (!idx) return vifCode_Null<idx>(pass, (u32*)data); }
29 vifOp(vifCode_Null);
30
31 //------------------------------------------------------------------
32 // Vif0/Vif1 Misc Functions
33 //------------------------------------------------------------------
34
35 static __fi void vifFlush(int idx) {
36 if (!idx) vif0FLUSH();
37 else vif1FLUSH();
38 }
39
40 static __fi void vuExecMicro(int idx, u32 addr) {
41 VIFregisters& vifRegs = vifXRegs;
42 int startcycles = 0;
43 //vifFlush(idx);
44
45 //if(vifX.vifstalled == true) return;
46
47 if (vifRegs.itops > (idx ? 0x3ffu : 0xffu)) {
48 Console.WriteLn("VIF%d ITOP overrun! %x", idx, vifRegs.itops);
49 vifRegs.itops &= (idx ? 0x3ffu : 0xffu);
50 }
51
52 vifRegs.itop = vifRegs.itops;
53
54 if (idx) {
55 // in case we're handling a VIF1 execMicro, set the top with the tops value
56 vifRegs.top = vifRegs.tops & 0x3ff;
57
58 // is DBF flag set in VIF_STAT?
59 if (vifRegs.stat.DBF) {
60 // it is, so set tops with base, and clear the stat DBF flag
61 vifRegs.tops = vifRegs.base;
62 vifRegs.stat.DBF = false;
63 }
64 else {
65 // it is not, so set tops with base + offset, and set stat DBF flag
66 vifRegs.tops = vifRegs.base + vifRegs.ofst;
67 vifRegs.stat.DBF = true;
68 }
69 }
70
71 if(!idx)startcycles = VU0.cycle;
72 else startcycles = VU1.cycle;
73
74 if (!idx) vu0ExecMicro(addr);
75 else vu1ExecMicro(addr);
76
77 if(!idx) { g_vu0Cycles += (VU0.cycle-startcycles) * BIAS; g_packetsizeonvu = vif0.vifpacketsize; }
78 else { g_vu1Cycles += (VU1.cycle-startcycles) * BIAS; g_packetsizeonvu = vif1.vifpacketsize; }
79 //DevCon.Warning("Ran VU%x, VU0 Cycles %x, VU1 Cycles %x", idx, g_vu0Cycles, g_vu1Cycles);
80 GetVifX.vifstalled = true;
81 }
82
83 u8 schedulepath3msk = 0;
84
85 void Vif1MskPath3() {
86
87 vif1Regs.mskpath3 = schedulepath3msk & 0x1;
88 GIF_LOG("VIF MSKPATH3 %x gif str %x path3 status %x", vif1Regs.mskpath3, gifch.chcr.STR, GSTransferStatus.PTH3);
89 gifRegs.stat.M3P = vif1Regs.mskpath3;
90
91 if (!vif1Regs.mskpath3)
92 {
93 //if(GSTransferStatus.PTH3 > TRANSFER_MODE && gif->chcr.STR) GSTransferStatus.PTH3 = TRANSFER_MODE;
94 //DevCon.Warning("Mask off");
95 //if(GSTransferStatus.PTH3 >= PENDINGSTOP_MODE) GSTransferStatus.PTH3 = IDLE_MODE;
96 if(gifRegs.stat.P3Q)
97 {
98 gsInterrupt();//gsInterrupt();
99 }
100
101 }// else if(!gif->chcr.STR && GSTransferStatus.PTH3 == IDLE_MODE) GSTransferStatus.PTH3 = STOPPED_MODE;//else DevCon.Warning("Mask on");
102
103 schedulepath3msk = 0;
104 }
105
106 //------------------------------------------------------------------
107 // Vif0/Vif1 Code Implementations
108 //------------------------------------------------------------------
109
110 vifOp(vifCode_Base) {
111 vif1Only();
112 pass1 { vif1Regs.base = vif1Regs.code & 0x3ff; vif1.cmd = 0; }
113 pass3 { VifCodeLog("Base"); }
114 return 0;
115 }
116
117 extern bool SIGNAL_IMR_Pending;
118
119 template<int idx> __fi int _vifCode_Direct(int pass, const u8* data, bool isDirectHL) {
120 pass1 {
121 vif1Only();
122 int vifImm = (u16)vif1Regs.code;
123 vif1.tag.size = vifImm ? (vifImm*4) : (65536*4);
124 vif1.vifstalled = true;
125 gifRegs.stat.P2Q = true;
126 if (gifRegs.stat.PSE) // temporarily stop
127 {
128 Console.WriteLn("Gif dma temp paused? VIF DIRECT");
129 vif1.GifWaitState = 3;
130 vif1Regs.stat.VGW = true;
131 }
132 //Should cause this to split here to try and time PATH3 right.
133 return 0;
134 }
135 pass2 {
136 vif1Only();
137
138 if (GSTransferStatus.PTH3 < IDLE_MODE || gifRegs.stat.P1Q == true)
139 {
140 if(gifRegs.stat.APATH == GIF_APATH2 || ((GSTransferStatus.PTH3 <= IMAGE_MODE && gifRegs.stat.IMT && (vif1.cmd & 0x7f) == 0x50)) && gifRegs.stat.P1Q == false)
141 {
142 //Do nothing, allow it
143 vif1Regs.stat.VGW = false;
144 //if(gifRegs.stat.APATH != GIF_APATH2)DevCon.Warning("Continue DIRECT/HL %x P3 %x APATH %x P1Q %x", vif1.cmd, GSTransferStatus.PTH3, gifRegs.stat.APATH, gifRegs.stat.P1Q);
145 }
146 else
147 {
148 //DevCon.Warning("Stall DIRECT/HL %x P3 %x APATH %x P1Q %x", vif1.cmd, GSTransferStatus.PTH3, gifRegs.stat.APATH, gifRegs.stat.P1Q);
149 vif1Regs.stat.VGW = true; // PATH3 is in image mode (DIRECTHL), or busy (BOTH no IMT)
150 vif1.GifWaitState = 0;
151 vif1.vifstalled = true;
152 return 0;
153 }
154 }
155 if(SIGNAL_IMR_Pending == true)
156 {
157 DevCon.Warning("Path 2 Paused (At start)");
158 vif1.vifstalled = true;
159 return 0;
160 }
161 if (gifRegs.stat.PSE) // temporarily stop
162 {
163 Console.WriteLn("Gif dma temp paused? VIF DIRECT");
164 vif1.GifWaitState = 3;
165 vif1.vifstalled = true;
166 vif1Regs.stat.VGW = true;
167 return 0;
168 }
169
170 // HACK ATTACK!
171 // we shouldn't be clearing the queue flag here at all. Ideally, the queue statuses
172 // should be checked, handled, and cleared from the EOP check in GIFPath only. --air
173 gifRegs.stat.clear_flags(GIF_STAT_P2Q);
174
175 uint minSize = aMin(vif1.vifpacketsize, vif1.tag.size);
176 uint ret;
177
178 if(minSize < 4)
179 {
180 // When TTE==1, the VIF might end up sending us 8-byte packets instead of the usual 16-byte
181 // variety, if DIRECT tags cross chain dma boundaries. The actual behavior of real hardware
182 // is unknown at this time, but it seems that games *only* ever try to upload zero'd data
183 // in this situation.
184 //
185 // Games that use TTE==1 and DIRECT in this fashion: ICO
186 //
187 // Because DIRECT normally has a strict QWC alignment requirement, and this funky behavior
188 // only seems to happen on TTE mode transfers with their split-64-bit packets, there shouldn't
189 // be any need to worry about queuing more than 16 bytes of data,
190 //
191
192 static __aligned16 u32 partial_write[4];
193 static uint partial_count = 0;
194
195 for( uint i=0; i<(minSize & 3); ++i)
196 partial_write[partial_count++] = ((u32*)data)[i];
197
198 pxAssume( partial_count <= 4 );
199 ret = 0;
200 if (partial_count == 4)
201 {
202 GetMTGS().PrepDataPacket(GIF_PATH_2, 1);
203 GIFPath_CopyTag(GIF_PATH_2, (u128*)partial_write, 1);
204 GetMTGS().SendDataPacket();
205 partial_count = 0;
206 ret = 4;
207 }
208 }
209 else
210 {
211 if (!minSize)
212 DevCon.Warning("VIF DIRECT (PATH2): No Data Transfer?");
213
214 // TTE=1 mode is the only time we should be getting DIRECT packet sizes that are
215 // not a multiple of QWC, and those are assured to be under 128 bits in size.
216 // So if this assert is triggered then it probably means something else is amiss.
217 pxAssertMsg((minSize & 3) == 0, "DIRECT packet size is not a multiple of QWC." );
218
219 GetMTGS().PrepDataPacket(GIF_PATH_2, minSize/4);
220 ret = GIFPath_CopyTag(GIF_PATH_2, (u128*)data, minSize/4)*4;
221 GetMTGS().SendDataPacket();
222 }
223
224 vif1.tag.size -= ret;
225
226 if(vif1.tag.size == 0)
227 {
228 vif1.cmd = 0;
229 }
230 vif1.vifstalled = true;
231 return ret;
232 }
233 return 0;
234 }
235
236 vifOp(vifCode_Direct) {
237 pass3 { VifCodeLog("Direct"); }
238 return _vifCode_Direct<idx>(pass, (u8*)data, 0);
239 }
240
241 vifOp(vifCode_DirectHL) {
242 pass3 { VifCodeLog("DirectHL"); }
243 return _vifCode_Direct<idx>(pass, (u8*)data, 1);
244 }
245
246 // ToDo: FixMe
247 vifOp(vifCode_Flush) {
248 vif1Only();
249 vifStruct& vifX = GetVifX;
250 pass1 { vifFlush(idx); vifX.cmd = 0; }
251 pass3 { VifCodeLog("Flush"); }
252 return 0;
253 }
254
255 // ToDo: FixMe
256 vifOp(vifCode_FlushA) {
257 vif1Only();
258 vifStruct& vifX = GetVifX;
259 pass1 {
260 vifFlush(idx);
261 // Gif is already transferring so wait for it.
262 if (gifRegs.stat.P1Q || GSTransferStatus.PTH3 <= PENDINGSTOP_MODE) {
263 //DevCon.Warning("VIF FlushA Wait MSK = %x", vif1Regs.mskpath3);
264 //
265
266 //DevCon.WriteLn("FlushA path3 Wait! PTH3 MD %x STR %x", GSTransferStatus.PTH3, gif->chcr.STR);
267 vif1Regs.stat.VGW = true;
268 vifX.GifWaitState = 1;
269 vifX.vifstalled = true;
270 } // else DevCon.WriteLn("FlushA path3 no Wait! PTH3 MD %x STR %x", GSTransferStatus.PTH3, gif->chcr.STR);
271
272 vifX.cmd = 0;
273 }
274 pass3 { VifCodeLog("FlushA"); }
275 return 0;
276 }
277
278 // ToDo: FixMe
279 vifOp(vifCode_FlushE) {
280 vifStruct& vifX = GetVifX;
281 pass1 { vifFlush(idx); vifX.cmd = 0; }
282 pass3 { VifCodeLog("FlushE"); }
283 return 0;
284 }
285
286 vifOp(vifCode_ITop) {
287 pass1 { vifXRegs.itops = vifXRegs.code & 0x3ff; GetVifX.cmd = 0; }
288 pass3 { VifCodeLog("ITop"); }
289 return 0;
290 }
291
292 vifOp(vifCode_Mark) {
293 vifStruct& vifX = GetVifX;
294 pass1 {
295 vifXRegs.mark = (u16)vifXRegs.code;
296 vifXRegs.stat.MRK = true;
297 vifX.cmd = 0;
298 }
299 pass3 { VifCodeLog("Mark"); }
300 return 0;
301 }
302
303 static __fi void _vifCode_MPG(int idx, u32 addr, const u32 *data, int size) {
304 VURegs& VUx = idx ? VU1 : VU0;
305 pxAssume(VUx.Micro > 0);
306
307 if (memcmp_mmx(VUx.Micro + addr, data, size*4)) {
308 // Clear VU memory before writing!
309 // (VUs expect size to be 32-bit scale, same as VIF's internal working sizes)
310 if (!idx) CpuVU0->Clear(addr, size);
311 else CpuVU1->Clear(addr, size);
312 memcpy_fast(VUx.Micro + addr, data, size*4);
313 }
314 }
315
316 vifOp(vifCode_MPG) {
317 vifStruct& vifX = GetVifX;
318 pass1 {
319 int vifNum = (u8)(vifXRegs.code >> 16);
320 vifX.tag.addr = (u16)(vifXRegs.code << 3) & (idx ? 0x3fff : 0xfff);
321 vifX.tag.size = vifNum ? (vifNum*2) : 512;
322 //vifFlush(idx);
323 return 1;
324 }
325 pass2 {
326 if (vifX.vifpacketsize < vifX.tag.size) { // Partial Transfer
327 if((vifX.tag.addr + vifX.vifpacketsize*4) > (idx ? 0x4000 : 0x1000)) {
328 DevCon.Warning("Vif%d MPG Split Overflow", idx);
329 }
330 _vifCode_MPG(idx, vifX.tag.addr, data, vifX.vifpacketsize);
331 vifX.tag.addr += vifX.vifpacketsize * 4;
332 vifX.tag.size -= vifX.vifpacketsize;
333 return vifX.vifpacketsize;
334 }
335 else { // Full Transfer
336 if((vifX.tag.addr + vifX.tag.size*4) > (idx ? 0x4000 : 0x1000)) {
337 DevCon.Warning("Vif%d MPG Split Overflow", idx);
338 }
339 _vifCode_MPG(idx, vifX.tag.addr, data, vifX.tag.size);
340 int ret = vifX.tag.size;
341 vifX.tag.size = 0;
342 vifX.cmd = 0;
343 return ret;
344 }
345 }
346 pass3 { VifCodeLog("MPG"); }
347 return 0;
348 }
349
350 vifOp(vifCode_MSCAL) {
351 vifStruct& vifX = GetVifX;
352 pass1 { vifFlush(idx); vuExecMicro(idx, (u16)(vifXRegs.code) << 3); vifX.cmd = 0;}
353 pass3 { VifCodeLog("MSCAL"); }
354 return 0;
355 }
356
357 vifOp(vifCode_MSCALF) {
358 vifStruct& vifX = GetVifX;
359 pass1 { vifFlush(idx); vuExecMicro(idx, (u16)(vifXRegs.code) << 3); vifX.cmd = 0; }
360 pass3 { VifCodeLog("MSCALF"); }
361 return 0;
362 }
363
364 vifOp(vifCode_MSCNT) {
365 vifStruct& vifX = GetVifX;
366 pass1 { vifFlush(idx); vuExecMicro(idx, -1); vifX.cmd = 0; }
367 pass3 { VifCodeLog("MSCNT"); }
368 return 0;
369 }
370
371 // ToDo: FixMe
372 vifOp(vifCode_MskPath3) {
373 vif1Only();
374 pass1 {
375 if (vif1ch.chcr.STR && vif1.lastcmd != 0x13) {
376 schedulepath3msk = 0x10 | ((vif1Regs.code >> 15) & 0x1);
377 vif1.vifstalled = true;
378 }
379 else {
380 schedulepath3msk = (vif1Regs.code >> 15) & 0x1;
381 Vif1MskPath3();
382 }
383 vif1.cmd = 0;
384 }
385 pass3 { VifCodeLog("MskPath3"); }
386 return 0;
387 }
388
389 vifOp(vifCode_Nop) {
390 pass1 { GetVifX.cmd = 0; }
391 pass3 { VifCodeLog("Nop"); }
392 return 0;
393 }
394
395 // ToDo: Review Flags
396 vifOp(vifCode_Null) {
397 vifStruct& vifX = GetVifX;
398 pass1 {
399 // if ME1, then force the vif to interrupt
400 if (!(vifXRegs.err.ME1)) { // Ignore vifcode and tag mismatch error
401 Console.WriteLn("Vif%d: Unknown VifCmd! [%x]", idx, vifX.cmd);
402 vifXRegs.stat.ER1 = true;
403 vifX.vifstalled = true;
404 //vifX.irq++;
405 }
406 vifX.cmd = 0;
407 }
408 pass2 { Console.Error("Vif%d bad vifcode! [CMD = %x]", idx, vifX.cmd); }
409 pass3 { VifCodeLog("Null"); }
410 return 0;
411 }
412
413 vifOp(vifCode_Offset) {
414 vif1Only();
415 pass1 {
416 vif1Regs.stat.DBF = false;
417 vif1Regs.ofst = vif1Regs.code & 0x3ff;
418 vif1Regs.tops = vif1Regs.base;
419 vif1.cmd = 0;
420 }
421 pass3 { VifCodeLog("Offset"); }
422 return 0;
423 }
424
425 template<int idx> static __fi int _vifCode_STColRow(const u32* data, u32* pmem2) {
426 vifStruct& vifX = GetVifX;
427
428 int ret = min(4 - vifX.tag.addr, vifX.vifpacketsize);
429 pxAssume(vifX.tag.addr < 4);
430 pxAssume(ret > 0);
431
432 switch (ret) {
433 case 4:
434 pmem2[3] = data[3];
435 case 3:
436 pmem2[2] = data[2];
437 case 2:
438 pmem2[1] = data[1];
439 case 1:
440 pmem2[0] = data[0];
441 break;
442 jNO_DEFAULT
443 }
444
445 vifX.tag.addr += ret;
446 vifX.tag.size -= ret;
447 if (!vifX.tag.size) vifX.cmd = 0;
448
449 return ret;
450 }
451
452 vifOp(vifCode_STCol) {
453 vifStruct& vifX = GetVifX;
454 pass1 {
455 vifX.tag.addr = 0;
456 vifX.tag.size = 4;
457 return 1;
458 }
459 pass2 {
460 return _vifCode_STColRow<idx>(data, &vifX.MaskCol._u32[vifX.tag.addr]);
461 }
462 pass3 { VifCodeLog("STCol"); }
463 return 0;
464 }
465
466 vifOp(vifCode_STRow) {
467 vifStruct& vifX = GetVifX;
468
469 pass1 {
470 vifX.tag.addr = 0;
471 vifX.tag.size = 4;
472 return 1;
473 }
474 pass2 {
475 return _vifCode_STColRow<idx>(data, &vifX.MaskRow._u32[vifX.tag.addr]);
476 }
477 pass3 { VifCodeLog("STRow"); }
478 return 0;
479 }
480
481 vifOp(vifCode_STCycl) {
482 vifStruct& vifX = GetVifX;
483 pass1 {
484 vifXRegs.cycle.cl = (u8)(vifXRegs.code);
485 vifXRegs.cycle.wl = (u8)(vifXRegs.code >> 8);
486 vifX.cmd = 0;
487 }
488 pass3 { VifCodeLog("STCycl"); }
489 return 0;
490 }
491
492 vifOp(vifCode_STMask) {
493 vifStruct& vifX = GetVifX;
494 pass1 { vifX.tag.size = 1; }
495 pass2 { vifXRegs.mask = data[0]; vifX.tag.size = 0; vifX.cmd = 0; }
496 pass3 { VifCodeLog("STMask"); }
497 return 1;
498 }
499
500 vifOp(vifCode_STMod) {
501 pass1 { vifXRegs.mode = vifXRegs.code & 0x3; GetVifX.cmd = 0; }
502 pass3 { VifCodeLog("STMod"); }
503 return 0;
504 }
505
506 vifOp(vifCode_Unpack) {
507 pass1 {
508 vifUnpackSetup<idx>(data);
509 return 1;
510 }
511 pass2 { return nVifUnpack<idx>((u8*)data); }
512 pass3 { VifCodeLog("Unpack"); }
513 return 0;
514 }
515
516 //------------------------------------------------------------------
517 // Vif0/Vif1 Code Tables
518 //------------------------------------------------------------------
519
520 __aligned16 FnType_VifCmdHandler* const vifCmdHandler[2][128] =
521 {
522 {
523 vifCode_Nop<0> , vifCode_STCycl<0> , vifCode_Offset<0> , vifCode_Base<0> , vifCode_ITop<0> , vifCode_STMod<0> , vifCode_MskPath3<0>, vifCode_Mark<0>, /*0x00*/
524 vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x08*/
525 vifCode_FlushE<0> , vifCode_Flush<0> , vifCode_Null<0> , vifCode_FlushA<0> , vifCode_MSCAL<0> , vifCode_MSCALF<0> , vifCode_Null<0> , vifCode_MSCNT<0>, /*0x10*/
526 vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x18*/
527 vifCode_STMask<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x20*/
528 vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x28*/
529 vifCode_STRow<0> , vifCode_STCol<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x30*/
530 vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x38*/
531 vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x40*/
532 vifCode_Null<0> , vifCode_Null<0> , vifCode_MPG<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x48*/
533 vifCode_Direct<0> , vifCode_DirectHL<0>, vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x50*/
534 vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0> , vifCode_Null<0>, /*0x58*/
535 vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Null<0>, /*0x60*/
536 vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0>, /*0x68*/
537 vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Null<0>, /*0x70*/
538 vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Null<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> , vifCode_Unpack<0> /*0x78*/
539 },
540 {
541 vifCode_Nop<1> , vifCode_STCycl<1> , vifCode_Offset<1> , vifCode_Base<1> , vifCode_ITop<1> , vifCode_STMod<1> , vifCode_MskPath3<1>, vifCode_Mark<1>, /*0x00*/
542 vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x08*/
543 vifCode_FlushE<1> , vifCode_Flush<1> , vifCode_Null<1> , vifCode_FlushA<1> , vifCode_MSCAL<1> , vifCode_MSCALF<1> , vifCode_Null<1> , vifCode_MSCNT<1>, /*0x10*/
544 vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x18*/
545 vifCode_STMask<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x20*/
546 vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x28*/
547 vifCode_STRow<1> , vifCode_STCol<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x30*/
548 vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x38*/
549 vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x40*/
550 vifCode_Null<1> , vifCode_Null<1> , vifCode_MPG<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x48*/
551 vifCode_Direct<1> , vifCode_DirectHL<1>, vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x50*/
552 vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1> , vifCode_Null<1>, /*0x58*/
553 vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Null<1>, /*0x60*/
554 vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1>, /*0x68*/
555 vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Null<1>, /*0x70*/
556 vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Null<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> , vifCode_Unpack<1> /*0x78*/
557 }
558 };

  ViewVC Help
Powered by ViewVC 1.1.22