URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [arm/] [nwfpe/] [fpa11_cpdt.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
    NetWinder Floating Point Emulator
    (c) Rebel.com, 1998-1999
    (c) Philip Blundell, 1998, 2001
 
    Direct questions, comments to Scott Bambrough <scottb@netwinder.org>
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
 
#include "fpa11.h"
#include "softfloat.h"
#include "fpopcode.h"
#include "fpmodule.h"
#include "fpmodule.inl"
 
#include <asm/uaccess.h>
 
static inline void loadSingle(const unsigned int Fn, const unsigned int *pMem)
{
        FPA11 *fpa11 = GET_FPA11();
        fpa11->fType[Fn] = typeSingle;
        get_user(fpa11->fpreg[Fn].fSingle, pMem);
}
 
static inline void loadDouble(const unsigned int Fn, const unsigned int *pMem)
{
        FPA11 *fpa11 = GET_FPA11();
        unsigned int *p;
        p = (unsigned int *) &fpa11->fpreg[Fn].fDouble;
        fpa11->fType[Fn] = typeDouble;
        get_user(p[0], &pMem[1]);
        get_user(p[1], &pMem[0]);        /* sign & exponent */
}
 
#ifdef CONFIG_FPE_NWFPE_XP
static inline void loadExtended(const unsigned int Fn, const unsigned int *pMem)
{
        FPA11 *fpa11 = GET_FPA11();
        unsigned int *p;
        p = (unsigned int *) &fpa11->fpreg[Fn].fExtended;
        fpa11->fType[Fn] = typeExtended;
        get_user(p[0], &pMem[0]); /* sign & exponent */
        get_user(p[1], &pMem[2]);       /* ls bits */
        get_user(p[2], &pMem[1]);       /* ms bits */
}
#endif
 
static inline void loadMultiple(const unsigned int Fn, const unsigned int *pMem)
{
        FPA11 *fpa11 = GET_FPA11();
        register unsigned int *p;
        unsigned long x;
 
        p = (unsigned int *) &(fpa11->fpreg[Fn]);
        get_user(x, &pMem[0]);
        fpa11->fType[Fn] = (x >> 14) & 0x00000003;
 
        switch (fpa11->fType[Fn]) {
        case typeSingle:
        case typeDouble:
                {
                        get_user(p[0], &pMem[2]);        /* Single */
                        get_user(p[1], &pMem[1]);       /* double msw */
                        p[2] = 0;                        /* empty */
                }
                break;
 
#ifdef CONFIG_FPE_NWFPE_XP
        case typeExtended:
                {
                        get_user(p[1], &pMem[2]);
                        get_user(p[2], &pMem[1]);       /* msw */
                        p[0] = (x & 0x80003fff);
                }
                break;
#endif
        }
}
 
static inline void storeSingle(const unsigned int Fn, unsigned int *pMem)
{
        FPA11 *fpa11 = GET_FPA11();
        float32 val;
        register unsigned int *p = (unsigned int *) &val;
 
        switch (fpa11->fType[Fn]) {
        case typeDouble:
                val = float64_to_float32(fpa11->fpreg[Fn].fDouble);
                break;
 
#ifdef CONFIG_FPE_NWFPE_XP
        case typeExtended:
                val = floatx80_to_float32(fpa11->fpreg[Fn].fExtended);
                break;
#endif
 
        default:
                val = fpa11->fpreg[Fn].fSingle;
        }
 
        put_user(p[0], pMem);
}
 
static inline void storeDouble(const unsigned int Fn, unsigned int *pMem)
{
        FPA11 *fpa11 = GET_FPA11();
        float64 val;
        register unsigned int *p = (unsigned int *) &val;
 
        switch (fpa11->fType[Fn]) {
        case typeSingle:
                val = float32_to_float64(fpa11->fpreg[Fn].fSingle);
                break;
 
#ifdef CONFIG_FPE_NWFPE_XP
        case typeExtended:
                val = floatx80_to_float64(fpa11->fpreg[Fn].fExtended);
                break;
#endif
 
        default:
                val = fpa11->fpreg[Fn].fDouble;
        }
        put_user(p[1], &pMem[0]);        /* msw */
        put_user(p[0], &pMem[1]);        /* lsw */
}
 
#ifdef CONFIG_FPE_NWFPE_XP
static inline void storeExtended(const unsigned int Fn, unsigned int *pMem)
{
        FPA11 *fpa11 = GET_FPA11();
        floatx80 val;
        register unsigned int *p = (unsigned int *) &val;
 
        switch (fpa11->fType[Fn]) {
        case typeSingle:
                val = float32_to_floatx80(fpa11->fpreg[Fn].fSingle);
                break;
 
        case typeDouble:
                val = float64_to_floatx80(fpa11->fpreg[Fn].fDouble);
                break;
 
        default:
                val = fpa11->fpreg[Fn].fExtended;
        }
 
        put_user(p[0], &pMem[0]); /* sign & exp */
        put_user(p[1], &pMem[2]);
        put_user(p[2], &pMem[1]);       /* msw */
}
#endif
 
static inline void storeMultiple(const unsigned int Fn, unsigned int *pMem)
{
        FPA11 *fpa11 = GET_FPA11();
        register unsigned int nType, *p;
 
        p = (unsigned int *) &(fpa11->fpreg[Fn]);
        nType = fpa11->fType[Fn];
 
        switch (nType) {
        case typeSingle:
        case typeDouble:
                {
                        put_user(p[0], &pMem[2]);        /* single */
                        put_user(p[1], &pMem[1]);       /* double msw */
                        put_user(nType << 14, &pMem[0]);
                }
                break;
 
#ifdef CONFIG_FPE_NWFPE_XP
        case typeExtended:
                {
                        put_user(p[2], &pMem[1]);       /* msw */
                        put_user(p[1], &pMem[2]);
                        put_user((p[0] & 0x80003fff) | (nType << 14), &pMem[0]);
                }
                break;
#endif
        }
}
 
unsigned int PerformLDF(const unsigned int opcode)
{
        unsigned int *pBase, *pAddress, *pFinal, nRc = 1,
            write_back = WRITE_BACK(opcode);
 
        pBase = (unsigned int *) readRegister(getRn(opcode));
        if (REG_PC == getRn(opcode)) {
                pBase += 2;
                write_back = 0;
        }
 
        pFinal = pBase;
        if (BIT_UP_SET(opcode))
                pFinal += getOffset(opcode);
        else
                pFinal -= getOffset(opcode);
 
        if (PREINDEXED(opcode))
                pAddress = pFinal;
        else
                pAddress = pBase;
 
        switch (opcode & MASK_TRANSFER_LENGTH) {
        case TRANSFER_SINGLE:
                loadSingle(getFd(opcode), pAddress);
                break;
        case TRANSFER_DOUBLE:
                loadDouble(getFd(opcode), pAddress);
                break;
#ifdef CONFIG_FPE_NWFPE_XP
        case TRANSFER_EXTENDED:
                loadExtended(getFd(opcode), pAddress);
                break;
#endif
        default:
                nRc = 0;
        }
 
        if (write_back)
                writeRegister(getRn(opcode), (unsigned int) pFinal);
        return nRc;
}
 
unsigned int PerformSTF(const unsigned int opcode)
{
        unsigned int *pBase, *pAddress, *pFinal, nRc = 1,
            write_back = WRITE_BACK(opcode);
 
        SetRoundingMode(ROUND_TO_NEAREST);
 
        pBase = (unsigned int *) readRegister(getRn(opcode));
        if (REG_PC == getRn(opcode)) {
                pBase += 2;
                write_back = 0;
        }
 
        pFinal = pBase;
        if (BIT_UP_SET(opcode))
                pFinal += getOffset(opcode);
        else
                pFinal -= getOffset(opcode);
 
        if (PREINDEXED(opcode))
                pAddress = pFinal;
        else
                pAddress = pBase;
 
        switch (opcode & MASK_TRANSFER_LENGTH) {
        case TRANSFER_SINGLE:
                storeSingle(getFd(opcode), pAddress);
                break;
        case TRANSFER_DOUBLE:
                storeDouble(getFd(opcode), pAddress);
                break;
#ifdef CONFIG_FPE_NWFPE_XP
        case TRANSFER_EXTENDED:
                storeExtended(getFd(opcode), pAddress);
                break;
#endif
        default:
                nRc = 0;
        }
 
        if (write_back)
                writeRegister(getRn(opcode), (unsigned int) pFinal);
        return nRc;
}
 
unsigned int PerformLFM(const unsigned int opcode)
{
        unsigned int i, Fd, *pBase, *pAddress, *pFinal,
            write_back = WRITE_BACK(opcode);
 
        pBase = (unsigned int *) readRegister(getRn(opcode));
        if (REG_PC == getRn(opcode)) {
                pBase += 2;
                write_back = 0;
        }
 
        pFinal = pBase;
        if (BIT_UP_SET(opcode))
                pFinal += getOffset(opcode);
        else
                pFinal -= getOffset(opcode);
 
        if (PREINDEXED(opcode))
                pAddress = pFinal;
        else
                pAddress = pBase;
 
        Fd = getFd(opcode);
        for (i = getRegisterCount(opcode); i > 0; i--) {
                loadMultiple(Fd, pAddress);
                pAddress += 3;
                Fd++;
                if (Fd == 8)
                        Fd = 0;
        }
 
        if (write_back)
                writeRegister(getRn(opcode), (unsigned int) pFinal);
        return 1;
}
 
unsigned int PerformSFM(const unsigned int opcode)
{
        unsigned int i, Fd, *pBase, *pAddress, *pFinal,
            write_back = WRITE_BACK(opcode);
 
        pBase = (unsigned int *) readRegister(getRn(opcode));
        if (REG_PC == getRn(opcode)) {
                pBase += 2;
                write_back = 0;
        }
 
        pFinal = pBase;
        if (BIT_UP_SET(opcode))
                pFinal += getOffset(opcode);
        else
                pFinal -= getOffset(opcode);
 
        if (PREINDEXED(opcode))
                pAddress = pFinal;
        else
                pAddress = pBase;
 
        Fd = getFd(opcode);
        for (i = getRegisterCount(opcode); i > 0; i--) {
                storeMultiple(Fd, pAddress);
                pAddress += 3;
                Fd++;
                if (Fd == 8)
                        Fd = 0;
        }
 
        if (write_back)
                writeRegister(getRn(opcode), (unsigned int) pFinal);
        return 1;
}
 
unsigned int EmulateCPDT(const unsigned int opcode)
{
        unsigned int nRc = 0;
 
        if (LDF_OP(opcode)) {
                nRc = PerformLDF(opcode);
        } else if (LFM_OP(opcode)) {
                nRc = PerformLFM(opcode);
        } else if (STF_OP(opcode)) {
                nRc = PerformSTF(opcode);
        } else if (SFM_OP(opcode)) {
                nRc = PerformSFM(opcode);
        } else {
                nRc = 0;
        }
 
        return nRc;
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [arch/] [arm/] [nwfpe/] [fpa11_cpdt.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`NetWinder Floating Point Emulator`
3			`(c) Rebel.com, 1998-1999`
4			`(c) Philip Blundell, 1998, 2001`
5
6			`Direct questions, comments to Scott Bambrough <scottb@netwinder.org>`
7
8			`This program is free software; you can redistribute it and/or modify`
9			`it under the terms of the GNU General Public License as published by`
10			`the Free Software Foundation; either version 2 of the License, or`
11			`(at your option) any later version.`
12
13			`This program is distributed in the hope that it will be useful,`
14			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
15			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
16			`GNU General Public License for more details.`
17
18			`You should have received a copy of the GNU General Public License`
19			`along with this program; if not, write to the Free Software`
20			`Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.`
21			`*/`
22
23			`#include "fpa11.h"`
24			`#include "softfloat.h"`
25			`#include "fpopcode.h"`
26			`#include "fpmodule.h"`
27			`#include "fpmodule.inl"`
28
29			`#include <asm/uaccess.h>`
30
31			`static inline void loadSingle(const unsigned int Fn, const unsigned int *pMem)`
32			`{`
33			`FPA11 *fpa11 = GET_FPA11();`
34			`fpa11->fType[Fn] = typeSingle;`
35			`get_user(fpa11->fpreg[Fn].fSingle, pMem);`
36			`}`
37
38			`static inline void loadDouble(const unsigned int Fn, const unsigned int *pMem)`
39			`{`
40			`FPA11 *fpa11 = GET_FPA11();`
41			`unsigned int *p;`
42			`p = (unsigned int *) &fpa11->fpreg[Fn].fDouble;`
43			`fpa11->fType[Fn] = typeDouble;`
44			`get_user(p[0], &pMem[1]);`
45			`get_user(p[1], &pMem[0]); /* sign & exponent */`
46			`}`
47
48			`#ifdef CONFIG_FPE_NWFPE_XP`
49			`static inline void loadExtended(const unsigned int Fn, const unsigned int *pMem)`
50			`{`
51			`FPA11 *fpa11 = GET_FPA11();`
52			`unsigned int *p;`
53			`p = (unsigned int *) &fpa11->fpreg[Fn].fExtended;`
54			`fpa11->fType[Fn] = typeExtended;`
55			`get_user(p[0], &pMem[0]); /* sign & exponent */`
56			`get_user(p[1], &pMem[2]); /* ls bits */`
57			`get_user(p[2], &pMem[1]); /* ms bits */`
58			`}`
59			`#endif`
60
61			`static inline void loadMultiple(const unsigned int Fn, const unsigned int *pMem)`
62			`{`
63			`FPA11 *fpa11 = GET_FPA11();`
64			`register unsigned int *p;`
65			`unsigned long x;`
66
67			`p = (unsigned int *) &(fpa11->fpreg[Fn]);`
68			`get_user(x, &pMem[0]);`
69			`fpa11->fType[Fn] = (x >> 14) & 0x00000003;`
70
71			`switch (fpa11->fType[Fn]) {`
72			`case typeSingle:`
73			`case typeDouble:`
74			`{`
75			`get_user(p[0], &pMem[2]); /* Single */`
76			`get_user(p[1], &pMem[1]); /* double msw */`
77			`p[2] = 0; /* empty */`
78			`}`
79			`break;`
80
81			`#ifdef CONFIG_FPE_NWFPE_XP`
82			`case typeExtended:`
83			`{`
84			`get_user(p[1], &pMem[2]);`
85			`get_user(p[2], &pMem[1]); /* msw */`
86			`p[0] = (x & 0x80003fff);`
87			`}`
88			`break;`
89			`#endif`
90			`}`
91			`}`
92
93			`static inline void storeSingle(const unsigned int Fn, unsigned int *pMem)`
94			`{`
95			`FPA11 *fpa11 = GET_FPA11();`
96			`float32 val;`
97			`register unsigned int p = (unsigned int ) &val;`
98
99			`switch (fpa11->fType[Fn]) {`
100			`case typeDouble:`
101			`val = float64_to_float32(fpa11->fpreg[Fn].fDouble);`
102			`break;`
103
104			`#ifdef CONFIG_FPE_NWFPE_XP`
105			`case typeExtended:`
106			`val = floatx80_to_float32(fpa11->fpreg[Fn].fExtended);`
107			`break;`
108			`#endif`
109
110			`default:`
111			`val = fpa11->fpreg[Fn].fSingle;`
112			`}`
113
114			`put_user(p[0], pMem);`
115			`}`
116
117			`static inline void storeDouble(const unsigned int Fn, unsigned int *pMem)`
118			`{`
119			`FPA11 *fpa11 = GET_FPA11();`
120			`float64 val;`
121			`register unsigned int p = (unsigned int ) &val;`
122
123			`switch (fpa11->fType[Fn]) {`
124			`case typeSingle:`
125			`val = float32_to_float64(fpa11->fpreg[Fn].fSingle);`
126			`break;`
127
128			`#ifdef CONFIG_FPE_NWFPE_XP`
129			`case typeExtended:`
130			`val = floatx80_to_float64(fpa11->fpreg[Fn].fExtended);`
131			`break;`
132			`#endif`
133
134			`default:`
135			`val = fpa11->fpreg[Fn].fDouble;`
136			`}`
137			`put_user(p[1], &pMem[0]); /* msw */`
138			`put_user(p[0], &pMem[1]); /* lsw */`
139			`}`
140
141			`#ifdef CONFIG_FPE_NWFPE_XP`
142			`static inline void storeExtended(const unsigned int Fn, unsigned int *pMem)`
143			`{`
144			`FPA11 *fpa11 = GET_FPA11();`
145			`floatx80 val;`
146			`register unsigned int p = (unsigned int ) &val;`
147
148			`switch (fpa11->fType[Fn]) {`
149			`case typeSingle:`
150			`val = float32_to_floatx80(fpa11->fpreg[Fn].fSingle);`
151			`break;`
152
153			`case typeDouble:`
154			`val = float64_to_floatx80(fpa11->fpreg[Fn].fDouble);`
155			`break;`
156
157			`default:`
158			`val = fpa11->fpreg[Fn].fExtended;`
159			`}`
160
161			`put_user(p[0], &pMem[0]); /* sign & exp */`
162			`put_user(p[1], &pMem[2]);`
163			`put_user(p[2], &pMem[1]); /* msw */`
164			`}`
165			`#endif`
166
167			`static inline void storeMultiple(const unsigned int Fn, unsigned int *pMem)`
168			`{`
169			`FPA11 *fpa11 = GET_FPA11();`
170			`register unsigned int nType, *p;`
171
172			`p = (unsigned int *) &(fpa11->fpreg[Fn]);`
173			`nType = fpa11->fType[Fn];`
174
175			`switch (nType) {`
176			`case typeSingle:`
177			`case typeDouble:`
178			`{`
179			`put_user(p[0], &pMem[2]); /* single */`
180			`put_user(p[1], &pMem[1]); /* double msw */`
181			`put_user(nType << 14, &pMem[0]);`
182			`}`
183			`break;`
184
185			`#ifdef CONFIG_FPE_NWFPE_XP`
186			`case typeExtended:`
187			`{`
188			`put_user(p[2], &pMem[1]); /* msw */`
189			`put_user(p[1], &pMem[2]);`
190			`put_user((p[0] & 0x80003fff) \| (nType << 14), &pMem[0]);`
191			`}`
192			`break;`
193			`#endif`
194			`}`
195			`}`
196
197			`unsigned int PerformLDF(const unsigned int opcode)`
198			`{`
199			`unsigned int pBase, pAddress, *pFinal, nRc = 1,`
200			`write_back = WRITE_BACK(opcode);`
201
202			`pBase = (unsigned int *) readRegister(getRn(opcode));`
203			`if (REG_PC == getRn(opcode)) {`
204			`pBase += 2;`
205			`write_back = 0;`
206			`}`
207
208			`pFinal = pBase;`
209			`if (BIT_UP_SET(opcode))`
210			`pFinal += getOffset(opcode);`
211			`else`
212			`pFinal -= getOffset(opcode);`
213
214			`if (PREINDEXED(opcode))`
215			`pAddress = pFinal;`
216			`else`
217			`pAddress = pBase;`
218
219			`switch (opcode & MASK_TRANSFER_LENGTH) {`
220			`case TRANSFER_SINGLE:`
221			`loadSingle(getFd(opcode), pAddress);`
222			`break;`
223			`case TRANSFER_DOUBLE:`
224			`loadDouble(getFd(opcode), pAddress);`
225			`break;`
226			`#ifdef CONFIG_FPE_NWFPE_XP`
227			`case TRANSFER_EXTENDED:`
228			`loadExtended(getFd(opcode), pAddress);`
229			`break;`
230			`#endif`
231			`default:`
232			`nRc = 0;`
233			`}`
234
235			`if (write_back)`
236			`writeRegister(getRn(opcode), (unsigned int) pFinal);`
237			`return nRc;`
238			`}`
239
240			`unsigned int PerformSTF(const unsigned int opcode)`
241			`{`
242			`unsigned int pBase, pAddress, *pFinal, nRc = 1,`
243			`write_back = WRITE_BACK(opcode);`
244
245			`SetRoundingMode(ROUND_TO_NEAREST);`
246
247			`pBase = (unsigned int *) readRegister(getRn(opcode));`
248			`if (REG_PC == getRn(opcode)) {`
249			`pBase += 2;`
250			`write_back = 0;`
251			`}`
252
253			`pFinal = pBase;`
254			`if (BIT_UP_SET(opcode))`
255			`pFinal += getOffset(opcode);`
256			`else`
257			`pFinal -= getOffset(opcode);`
258
259			`if (PREINDEXED(opcode))`
260			`pAddress = pFinal;`
261			`else`
262			`pAddress = pBase;`
263
264			`switch (opcode & MASK_TRANSFER_LENGTH) {`
265			`case TRANSFER_SINGLE:`
266			`storeSingle(getFd(opcode), pAddress);`
267			`break;`
268			`case TRANSFER_DOUBLE:`
269			`storeDouble(getFd(opcode), pAddress);`
270			`break;`
271			`#ifdef CONFIG_FPE_NWFPE_XP`
272			`case TRANSFER_EXTENDED:`
273			`storeExtended(getFd(opcode), pAddress);`
274			`break;`
275			`#endif`
276			`default:`
277			`nRc = 0;`
278			`}`
279
280			`if (write_back)`
281			`writeRegister(getRn(opcode), (unsigned int) pFinal);`
282			`return nRc;`
283			`}`
284
285			`unsigned int PerformLFM(const unsigned int opcode)`
286			`{`
287			`unsigned int i, Fd, pBase, pAddress, *pFinal,`
288			`write_back = WRITE_BACK(opcode);`
289
290			`pBase = (unsigned int *) readRegister(getRn(opcode));`
291			`if (REG_PC == getRn(opcode)) {`
292			`pBase += 2;`
293			`write_back = 0;`
294			`}`
295
296			`pFinal = pBase;`
297			`if (BIT_UP_SET(opcode))`
298			`pFinal += getOffset(opcode);`
299			`else`
300			`pFinal -= getOffset(opcode);`
301
302			`if (PREINDEXED(opcode))`
303			`pAddress = pFinal;`
304			`else`
305			`pAddress = pBase;`
306
307			`Fd = getFd(opcode);`
308			`for (i = getRegisterCount(opcode); i > 0; i--) {`
309			`loadMultiple(Fd, pAddress);`
310			`pAddress += 3;`
311			`Fd++;`
312			`if (Fd == 8)`
313			`Fd = 0;`
314			`}`
315
316			`if (write_back)`
317			`writeRegister(getRn(opcode), (unsigned int) pFinal);`
318			`return 1;`
319			`}`
320
321			`unsigned int PerformSFM(const unsigned int opcode)`
322			`{`
323			`unsigned int i, Fd, pBase, pAddress, *pFinal,`
324			`write_back = WRITE_BACK(opcode);`
325
326			`pBase = (unsigned int *) readRegister(getRn(opcode));`
327			`if (REG_PC == getRn(opcode)) {`
328			`pBase += 2;`
329			`write_back = 0;`
330			`}`
331
332			`pFinal = pBase;`
333			`if (BIT_UP_SET(opcode))`
334			`pFinal += getOffset(opcode);`
335			`else`
336			`pFinal -= getOffset(opcode);`
337
338			`if (PREINDEXED(opcode))`
339			`pAddress = pFinal;`
340			`else`
341			`pAddress = pBase;`
342
343			`Fd = getFd(opcode);`
344			`for (i = getRegisterCount(opcode); i > 0; i--) {`
345			`storeMultiple(Fd, pAddress);`
346			`pAddress += 3;`
347			`Fd++;`
348			`if (Fd == 8)`
349			`Fd = 0;`
350			`}`
351
352			`if (write_back)`
353			`writeRegister(getRn(opcode), (unsigned int) pFinal);`
354			`return 1;`
355			`}`
356
357			`unsigned int EmulateCPDT(const unsigned int opcode)`
358			`{`
359			`unsigned int nRc = 0;`
360
361			`if (LDF_OP(opcode)) {`
362			`nRc = PerformLDF(opcode);`
363			`} else if (LFM_OP(opcode)) {`
364			`nRc = PerformLFM(opcode);`
365			`} else if (STF_OP(opcode)) {`
366			`nRc = PerformSTF(opcode);`
367			`} else if (SFM_OP(opcode)) {`
368			`nRc = PerformSFM(opcode);`
369			`} else {`
370			`nRc = 0;`
371			`}`
372
373			`return nRc;`
374			`}`