SheepShaver/src/thunks.cpp

/*
 *  thunks.cpp - Thunks to share data and code with MacOS
 *
 *  SheepShaver (C) 1997-2002 Christian Bauer and Marc Hellwig
 *
 *  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sysdeps.h"
#include "thunks.h"
#include "emul_op.h"
#include "cpu_emulation.h"
#include "xlowmem.h"

// Native function declarations
#include "main.h"
#include "video.h"
#include "name_registry.h"
#include "serial.h"
#include "ether.h"
#include "macos_util.h"

// Generate PowerPC thunks for GetResource() replacements?
#define POWERPC_GET_RESOURCE_THUNKS 1


/*              NativeOp instruction format:
                +------------+-------------------------+--+-----------+------------+
                |      6     |                         |FN|    OP     |      2     |
                +------------+-------------------------+--+-----------+------------+
                 0         5 |6                      18 19 20      25 26        31
*/

#define POWERPC_NATIVE_OP(FN, OP) \
                (POWERPC_EMUL_OP | ((FN) << 12) | (((uint32)OP) << 6) | 2)

/*
 *  Return the fake PowerPC opcode to handle specified native code
 */

#if EMULATED_PPC
uint32 NativeOpcode(int selector)
{
        uint32 opcode;
        switch (selector) {
        case NATIVE_CHECK_LOAD_INVOC:
        case NATIVE_NAMED_CHECK_LOAD_INVOC:
                opcode = POWERPC_NATIVE_OP(0, selector);
                break;
        case NATIVE_PATCH_NAME_REGISTRY:
        case NATIVE_VIDEO_INSTALL_ACCEL:
        case NATIVE_VIDEO_VBL:
        case NATIVE_VIDEO_DO_DRIVER_IO:
        case NATIVE_ETHER_AO_GET_HWADDR:
        case NATIVE_ETHER_AO_ADD_MULTI:
        case NATIVE_ETHER_AO_DEL_MULTI:
        case NATIVE_ETHER_AO_SEND_PACKET:
        case NATIVE_ETHER_IRQ:
        case NATIVE_ETHER_INIT:
        case NATIVE_ETHER_TERM:
        case NATIVE_ETHER_OPEN:
        case NATIVE_ETHER_CLOSE:
        case NATIVE_ETHER_WPUT:
        case NATIVE_ETHER_RSRV:
        case NATIVE_SERIAL_NOTHING:
        case NATIVE_SERIAL_OPEN:
        case NATIVE_SERIAL_PRIME_IN:
        case NATIVE_SERIAL_PRIME_OUT:
        case NATIVE_SERIAL_CONTROL:
        case NATIVE_SERIAL_STATUS:
        case NATIVE_SERIAL_CLOSE:
        case NATIVE_GET_RESOURCE:
        case NATIVE_GET_1_RESOURCE:
        case NATIVE_GET_IND_RESOURCE:
        case NATIVE_GET_1_IND_RESOURCE:
        case NATIVE_R_GET_RESOURCE:
        case NATIVE_GET_NAMED_RESOURCE:
        case NATIVE_GET_1_NAMED_RESOURCE:
        case NATIVE_MAKE_EXECUTABLE:
        case NATIVE_NQD_SYNC_HOOK:
        case NATIVE_NQD_BITBLT_HOOK:
        case NATIVE_NQD_FILLRECT_HOOK:
        case NATIVE_NQD_UNKNOWN_HOOK:
        case NATIVE_NQD_BITBLT:
        case NATIVE_NQD_INVRECT:
        case NATIVE_NQD_FILLRECT:
                opcode = POWERPC_NATIVE_OP(1, selector);
                break;
        default:
                abort();
        }
        return opcode;
}
#endif


/*
 *  Generate PowerPC thunks for GetResource() replacements
 */

#if EMULATED_PPC
static uint32 get_resource_func;
static uint32 get_1_resource_func;
static uint32 get_ind_resource_func;
static uint32 get_1_ind_resource_func;
static uint32 r_get_resource_func;
static uint32 get_named_resource_func;
static uint32 get_1_named_resource_func;

static void generate_powerpc_thunks(void)
{
        // check_load_invoc() thunk
        uint32 check_load_invoc_opcode = NativeOpcode(NATIVE_CHECK_LOAD_INVOC);
        uint32 base;

        static uint32 get_resource_template[] = {
                PL(0x7c0802a6),         // mflr    r0
                PL(0x90010008),         // stw     r0,8(r1)
                PL(0x9421ffbc),         // stwu    r1,-68(r1)
                PL(0x90610038),         // stw     r3,56(r1)
                PL(0x9081003c),         // stw     r4,60(r1)
                PL(0x00000000),         // lwz     r0,XLM_GET_RESOURCE(r0)
                PL(0x80402834),         // lwz     r2,XLM_RES_LIB_TOC(r0)
                PL(0x7c0903a6),         // mtctr   r0
                PL(0x4e800421),         // bctrl
                PL(0x90610040),         // stw     r3,64(r1)
                PL(0x80610038),         // lwz     r3,56(r1)
                PL(0xa881003e),         // lha     r4,62(r1)
                PL(0x80a10040),         // lwz     r5,64(r1)
                PL(0x00000001),         // <check_load_invoc>
                PL(0x80610040),         // lwz     r3,64(r1)
                PL(0x8001004c),         // lwz     r0,76(r1)
                PL(0x7c0803a6),         // mtlr    r0
                PL(0x38210044),         // addi    r1,r1,68
                PL(0x4e800020)          // blr
        };
        const uint32 get_resource_template_size = sizeof(get_resource_template);

        int xlm_index = -1, check_load_invoc_index = -1;
        for (int i = 0; i < get_resource_template_size/4; i++) {
                uint32 opcode = ntohl(get_resource_template[i]);
                switch (opcode) {
                case 0x00000000:
                        xlm_index = i;
                        break;
                case 0x00000001:
                        check_load_invoc_index = i;
                        break;
                }
        }
        assert(xlm_index != -1 && check_load_invoc_index != -1);

        // GetResource()
        get_resource_func = base = SheepMem::Reserve(get_resource_template_size);
        Host2Mac_memcpy(base, get_resource_template, get_resource_template_size);
        WriteMacInt32(base + xlm_index * 4, 0x80000000 | XLM_GET_RESOURCE);
        WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);

        // Get1Resource()
        get_1_resource_func = base = SheepMem::Reserve(get_resource_template_size);
        Host2Mac_memcpy(base, get_resource_template, get_resource_template_size);
        WriteMacInt32(base + xlm_index * 4, 0x80000000 | XLM_GET_1_RESOURCE);
        WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);

        // GetIndResource()
        get_ind_resource_func = base = SheepMem::Reserve(get_resource_template_size);
        Host2Mac_memcpy(base, get_resource_template, get_resource_template_size);
        WriteMacInt32(base + xlm_index * 4, 0x80000000 | XLM_GET_IND_RESOURCE);
        WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);

        // Get1IndResource()
        get_1_ind_resource_func = base = SheepMem::Reserve(get_resource_template_size);
        Host2Mac_memcpy(base, get_resource_template, get_resource_template_size);
        WriteMacInt32(base + xlm_index * 4, 0x80000000 | XLM_GET_1_IND_RESOURCE);
        WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);

        // RGetResource()
        r_get_resource_func = base = SheepMem::Reserve(get_resource_template_size);
        Host2Mac_memcpy(base, get_resource_template, get_resource_template_size);
        WriteMacInt32(base + xlm_index * 4, 0x80000000 | XLM_R_GET_RESOURCE);
        WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);

        // named_check_load_invoc() thunk
        check_load_invoc_opcode = NativeOpcode(NATIVE_NAMED_CHECK_LOAD_INVOC);

        static uint32 get_named_resource_template[] = {
                PL(0x7c0802a6),         // mflr    r0
                PL(0x90010008),         // stw     r0,8(r1)
                PL(0x9421ffbc),         // stwu    r1,-68(r1)
                PL(0x90610038),         // stw     r3,56(r1)
                PL(0x9081003c),         // stw     r4,60(r1)
                PL(0x00000000),         // lwz     r0,XLM_GET_NAMED_RESOURCE(r0)
                PL(0x80402834),         // lwz     r2,XLM_RES_LIB_TOC(r0)
                PL(0x7c0903a6),         // mtctr   r0
                PL(0x4e800421),         // bctrl
                PL(0x90610040),         // stw     r3,64(r1)
                PL(0x80610038),         // lwz     r3,56(r1)
                PL(0x8081003c),         // lwz     r4,60(r1)
                PL(0x80a10040),         // lwz     r5,64(r1)
                PL(0x00000001),         // <named_check_load_invoc>
                PL(0x80610040),         // lwz     r3,64(r1)
                PL(0x8001004c),         // lwz     r0,76(r1)
                PL(0x7c0803a6),         // mtlr    r0
                PL(0x38210044),         // addi    r1,r1,68
                PL(0x4e800020)          // blr
        };
        const uint32 get_named_resource_template_size = sizeof(get_named_resource_template);

        xlm_index = -1, check_load_invoc_index = -1;
        for (int i = 0; i < get_resource_template_size/4; i++) {
                uint32 opcode = ntohl(get_resource_template[i]);
                switch (opcode) {
                case 0x00000000:
                        xlm_index = i;
                        break;
                case 0x00000001:
                        check_load_invoc_index = i;
                        break;
                }
        }
        assert(xlm_index != -1 && check_load_invoc_index != -1);

        // GetNamedResource()
        get_named_resource_func = base = SheepMem::Reserve(get_named_resource_template_size);
        Host2Mac_memcpy(base, get_named_resource_template, get_named_resource_template_size);
        WriteMacInt32(base + xlm_index * 4, 0x80000000 | XLM_GET_NAMED_RESOURCE);
        WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);

        // Get1NamedResource()
        get_1_named_resource_func = base = SheepMem::Reserve(get_named_resource_template_size);
        Host2Mac_memcpy(base, get_named_resource_template, get_named_resource_template_size);
        WriteMacInt32(base + xlm_index * 4, 0x80000000 | XLM_GET_1_NAMED_RESOURCE);
        WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);
}
#endif


/*
 *  Initialize the thunks system
 */

struct native_op_t {
        uint32 tvect;
        uint32 func;
        SheepRoutineDescriptor *desc;
};
static native_op_t native_op[NATIVE_OP_MAX];

bool ThunksInit(void)
{
#if EMULATED_PPC
        for (int i = 0; i < NATIVE_OP_MAX; i++) {
                uintptr base = SheepMem::Reserve(12);
                WriteMacInt32(base + 0, base + 8);
                WriteMacInt32(base + 4, 0); // Fake TVECT
                WriteMacInt32(base + 8, NativeOpcode(i));
                native_op[i].tvect = base;
                native_op[i].func  = base + 8;
        }
#if POWERPC_GET_RESOURCE_THUNKS
        generate_powerpc_thunks();
        native_op[NATIVE_GET_RESOURCE].func = get_resource_func;
        native_op[NATIVE_GET_1_RESOURCE].func = get_1_resource_func;
        native_op[NATIVE_GET_IND_RESOURCE].func = get_ind_resource_func;
        native_op[NATIVE_GET_1_IND_RESOURCE].func = get_1_ind_resource_func;
        native_op[NATIVE_R_GET_RESOURCE].func = r_get_resource_func;
        native_op[NATIVE_GET_NAMED_RESOURCE].func = get_named_resource_func;
        native_op[NATIVE_GET_1_NAMED_RESOURCE].func = get_1_named_resource_func;
#endif
#else
#if defined(__linux__) || defined(__NetBSD__) || (defined(__APPLE__) && defined(__MACH__))
#define DEFINE_NATIVE_OP(ID, FUNC) do {                         \
                uintptr base = SheepMem::Reserve(8);            \
                WriteMacInt32(base + 0, (uint32)FUNC);          \
                WriteMacInt32(base + 4, (uint32)TOC);           \
                native_op[ID].tvect = base;                                     \
                native_op[ID].func  = (uint32)FUNC;                     \
        } while (0)
#elif defined(__BEOS__)
#define DEFINE_NATIVE_OP(ID, FUNC) do {                         \
                native_op[ID].tvect = FUNC;                                     \
                native_op[ID].func  = ((uint32 *)FUNC)[0];      \
        } while (0)
#else
#error "FIXME: define NativeOp for your platform"
#endif
        // FIXME: add GetResource() and friends for completeness
        DEFINE_NATIVE_OP(NATIVE_PATCH_NAME_REGISTRY, DoPatchNameRegistry);
        DEFINE_NATIVE_OP(NATIVE_VIDEO_INSTALL_ACCEL, VideoInstallAccel);
        DEFINE_NATIVE_OP(NATIVE_VIDEO_VBL, VideoVBL);
        DEFINE_NATIVE_OP(NATIVE_VIDEO_DO_DRIVER_IO, VideoDoDriverIO);
        DEFINE_NATIVE_OP(NATIVE_ETHER_AO_GET_HWADDR, AO_get_ethernet_address);
        DEFINE_NATIVE_OP(NATIVE_ETHER_AO_ADD_MULTI, AO_enable_multicast);
        DEFINE_NATIVE_OP(NATIVE_ETHER_AO_DEL_MULTI, AO_disable_multicast);
        DEFINE_NATIVE_OP(NATIVE_ETHER_AO_SEND_PACKET, AO_transmit_packet);
        DEFINE_NATIVE_OP(NATIVE_ETHER_IRQ, EtherIRQ);
        DEFINE_NATIVE_OP(NATIVE_ETHER_INIT, InitStreamModule);
        DEFINE_NATIVE_OP(NATIVE_ETHER_TERM, TerminateStreamModule);
        DEFINE_NATIVE_OP(NATIVE_ETHER_OPEN, ether_open);
        DEFINE_NATIVE_OP(NATIVE_ETHER_CLOSE, ether_close);
        DEFINE_NATIVE_OP(NATIVE_ETHER_WPUT, ether_wput);
        DEFINE_NATIVE_OP(NATIVE_ETHER_RSRV, ether_rsrv);
        DEFINE_NATIVE_OP(NATIVE_SERIAL_NOTHING, SerialNothing);
        DEFINE_NATIVE_OP(NATIVE_SERIAL_OPEN, SerialOpen);
        DEFINE_NATIVE_OP(NATIVE_SERIAL_PRIME_IN, SerialPrimeIn);
        DEFINE_NATIVE_OP(NATIVE_SERIAL_PRIME_OUT, SerialPrimeOut);
        DEFINE_NATIVE_OP(NATIVE_SERIAL_CONTROL, SerialControl);
        DEFINE_NATIVE_OP(NATIVE_SERIAL_STATUS, SerialStatus);
        DEFINE_NATIVE_OP(NATIVE_SERIAL_CLOSE, SerialClose);
        DEFINE_NATIVE_OP(NATIVE_MAKE_EXECUTABLE, MakeExecutable);
        DEFINE_NATIVE_OP(NATIVE_NQD_SYNC_HOOK, NQD_sync_hook);
        DEFINE_NATIVE_OP(NATIVE_NQD_BITBLT_HOOK, NQD_bitblt_hook);
        DEFINE_NATIVE_OP(NATIVE_NQD_FILLRECT_HOOK, NQD_fillrect_hook);
        DEFINE_NATIVE_OP(NATIVE_NQD_UNKNOWN_HOOK, NQD_unknown_hook);
        DEFINE_NATIVE_OP(NATIVE_NQD_BITBLT, NQD_bitblt);
        DEFINE_NATIVE_OP(NATIVE_NQD_INVRECT, NQD_invrect);
        DEFINE_NATIVE_OP(NATIVE_NQD_FILLRECT, NQD_fillrect);
#undef DEFINE_NATIVE_OP
#endif

        // Initialize routine descriptors (if TVECT exists)
        for (int i = 0; i < NATIVE_OP_MAX; i++) {
                uint32 tvect = native_op[i].tvect;
                if (tvect)
                        native_op[i].desc = new SheepRoutineDescriptor(0, tvect);
        }

        return true;
}


/*
 *  Delete generated thunks
 */

void ThunksExit(void)
{
        for (int i = 0; i < NATIVE_OP_MAX; i++) {
                SheepRoutineDescriptor *desc = native_op[i].desc;
                if (desc)
                        delete desc;
        }
}


/*
 *  Return the native function descriptor (TVECT)
 */

uint32 NativeTVECT(int selector)
{
        assert(selector < NATIVE_OP_MAX);
        const uint32 tvect = native_op[selector].tvect;
        assert(tvect != 0);
        return tvect;
}


/*
 *  Return the native function address
 */

uint32 NativeFunction(int selector)
{
        assert(selector < NATIVE_OP_MAX);
        const uint32 func = native_op[selector].func;
        assert(func != 0);
        return func;
}


/*
 *  Return the routine descriptor address of the native function
 */

uint32 NativeRoutineDescriptor(int selector)
{
        assert(selector < NATIVE_OP_MAX);
        SheepRoutineDescriptor * const desc = native_op[selector].desc;
        assert(desc != 0);
        return desc->addr();
}


/*
 *  Execute native code from EMUL_OP routine (real mode switch)
 */

void ExecuteNative(int selector)
{
        M68kRegisters r;
        Execute68k(NativeRoutineDescriptor(selector), &r);
}
Revision:	1.17
Committed:	2006-05-13T17:12:18Z (18 years, 6 months ago) by gbeauche
Branch:	MAIN
Changes since 1.16:	+14 -12 lines
Log Message:	NQD dirty boxes, generic code + while we are at it, also rename a few NQD related NativeOps.
#	Content
1	/*
2	* thunks.cpp - Thunks to share data and code with MacOS
3	*
4	* SheepShaver (C) 1997-2002 Christian Bauer and Marc Hellwig
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/
20
21	#include "sysdeps.h"
22	#include "thunks.h"
23	#include "emul_op.h"
24	#include "cpu_emulation.h"
25	#include "xlowmem.h"
26
27	// Native function declarations
28	#include "main.h"
29	#include "video.h"
30	#include "name_registry.h"
31	#include "serial.h"
32	#include "ether.h"
33	#include "macos_util.h"
34
35	// Generate PowerPC thunks for GetResource() replacements?
36	#define POWERPC_GET_RESOURCE_THUNKS 1
37
38
39	/* NativeOp instruction format:
40	+------------+-------------------------+--+-----------+------------+
41	\| 6 \| \|FN\| OP \| 2 \|
42	+------------+-------------------------+--+-----------+------------+
43	0 5 \|6 18 19 20 25 26 31
44	*/
45
46	#define POWERPC_NATIVE_OP(FN, OP) \
47	(POWERPC_EMUL_OP \| ((FN) << 12) \| (((uint32)OP) << 6) \| 2)
48
49	/*
50	* Return the fake PowerPC opcode to handle specified native code
51	*/
52
53	#if EMULATED_PPC
54	uint32 NativeOpcode(int selector)
55	{
56	uint32 opcode;
57	switch (selector) {
58	case NATIVE_CHECK_LOAD_INVOC:
59	case NATIVE_NAMED_CHECK_LOAD_INVOC:
60	opcode = POWERPC_NATIVE_OP(0, selector);
61	break;
62	case NATIVE_PATCH_NAME_REGISTRY:
63	case NATIVE_VIDEO_INSTALL_ACCEL:
64	case NATIVE_VIDEO_VBL:
65	case NATIVE_VIDEO_DO_DRIVER_IO:
66	case NATIVE_ETHER_AO_GET_HWADDR:
67	case NATIVE_ETHER_AO_ADD_MULTI:
68	case NATIVE_ETHER_AO_DEL_MULTI:
69	case NATIVE_ETHER_AO_SEND_PACKET:
70	case NATIVE_ETHER_IRQ:
71	case NATIVE_ETHER_INIT:
72	case NATIVE_ETHER_TERM:
73	case NATIVE_ETHER_OPEN:
74	case NATIVE_ETHER_CLOSE:
75	case NATIVE_ETHER_WPUT:
76	case NATIVE_ETHER_RSRV:
77	case NATIVE_SERIAL_NOTHING:
78	case NATIVE_SERIAL_OPEN:
79	case NATIVE_SERIAL_PRIME_IN:
80	case NATIVE_SERIAL_PRIME_OUT:
81	case NATIVE_SERIAL_CONTROL:
82	case NATIVE_SERIAL_STATUS:
83	case NATIVE_SERIAL_CLOSE:
84	case NATIVE_GET_RESOURCE:
85	case NATIVE_GET_1_RESOURCE:
86	case NATIVE_GET_IND_RESOURCE:
87	case NATIVE_GET_1_IND_RESOURCE:
88	case NATIVE_R_GET_RESOURCE:
89	case NATIVE_GET_NAMED_RESOURCE:
90	case NATIVE_GET_1_NAMED_RESOURCE:
91	case NATIVE_MAKE_EXECUTABLE:
92	case NATIVE_NQD_SYNC_HOOK:
93	case NATIVE_NQD_BITBLT_HOOK:
94	case NATIVE_NQD_FILLRECT_HOOK:
95	case NATIVE_NQD_UNKNOWN_HOOK:
96	case NATIVE_NQD_BITBLT:
97	case NATIVE_NQD_INVRECT:
98	case NATIVE_NQD_FILLRECT:
99	opcode = POWERPC_NATIVE_OP(1, selector);
100	break;
101	default:
102	abort();
103	}
104	return opcode;
105	}
106	#endif
107
108
109	/*
110	* Generate PowerPC thunks for GetResource() replacements
111	*/
112
113	#if EMULATED_PPC
114	static uint32 get_resource_func;
115	static uint32 get_1_resource_func;
116	static uint32 get_ind_resource_func;
117	static uint32 get_1_ind_resource_func;
118	static uint32 r_get_resource_func;
119	static uint32 get_named_resource_func;
120	static uint32 get_1_named_resource_func;
121
122	static void generate_powerpc_thunks(void)
123	{
124	// check_load_invoc() thunk
125	uint32 check_load_invoc_opcode = NativeOpcode(NATIVE_CHECK_LOAD_INVOC);
126	uint32 base;
127
128	static uint32 get_resource_template[] = {
129	PL(0x7c0802a6), // mflr r0
130	PL(0x90010008), // stw r0,8(r1)
131	PL(0x9421ffbc), // stwu r1,-68(r1)
132	PL(0x90610038), // stw r3,56(r1)
133	PL(0x9081003c), // stw r4,60(r1)
134	PL(0x00000000), // lwz r0,XLM_GET_RESOURCE(r0)
135	PL(0x80402834), // lwz r2,XLM_RES_LIB_TOC(r0)
136	PL(0x7c0903a6), // mtctr r0
137	PL(0x4e800421), // bctrl
138	PL(0x90610040), // stw r3,64(r1)
139	PL(0x80610038), // lwz r3,56(r1)
140	PL(0xa881003e), // lha r4,62(r1)
141	PL(0x80a10040), // lwz r5,64(r1)
142	PL(0x00000001), // <check_load_invoc>
143	PL(0x80610040), // lwz r3,64(r1)
144	PL(0x8001004c), // lwz r0,76(r1)
145	PL(0x7c0803a6), // mtlr r0
146	PL(0x38210044), // addi r1,r1,68
147	PL(0x4e800020) // blr
148	};
149	const uint32 get_resource_template_size = sizeof(get_resource_template);
150
151	int xlm_index = -1, check_load_invoc_index = -1;
152	for (int i = 0; i < get_resource_template_size/4; i++) {
153	uint32 opcode = ntohl(get_resource_template[i]);
154	switch (opcode) {
155	case 0x00000000:
156	xlm_index = i;
157	break;
158	case 0x00000001:
159	check_load_invoc_index = i;
160	break;
161	}
162	}
163	assert(xlm_index != -1 && check_load_invoc_index != -1);
164
165	// GetResource()
166	get_resource_func = base = SheepMem::Reserve(get_resource_template_size);
167	Host2Mac_memcpy(base, get_resource_template, get_resource_template_size);
168	WriteMacInt32(base + xlm_index * 4, 0x80000000 \| XLM_GET_RESOURCE);
169	WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);
170
171	// Get1Resource()
172	get_1_resource_func = base = SheepMem::Reserve(get_resource_template_size);
173	Host2Mac_memcpy(base, get_resource_template, get_resource_template_size);
174	WriteMacInt32(base + xlm_index * 4, 0x80000000 \| XLM_GET_1_RESOURCE);
175	WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);
176
177	// GetIndResource()
178	get_ind_resource_func = base = SheepMem::Reserve(get_resource_template_size);
179	Host2Mac_memcpy(base, get_resource_template, get_resource_template_size);
180	WriteMacInt32(base + xlm_index * 4, 0x80000000 \| XLM_GET_IND_RESOURCE);
181	WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);
182
183	// Get1IndResource()
184	get_1_ind_resource_func = base = SheepMem::Reserve(get_resource_template_size);
185	Host2Mac_memcpy(base, get_resource_template, get_resource_template_size);
186	WriteMacInt32(base + xlm_index * 4, 0x80000000 \| XLM_GET_1_IND_RESOURCE);
187	WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);
188
189	// RGetResource()
190	r_get_resource_func = base = SheepMem::Reserve(get_resource_template_size);
191	Host2Mac_memcpy(base, get_resource_template, get_resource_template_size);
192	WriteMacInt32(base + xlm_index * 4, 0x80000000 \| XLM_R_GET_RESOURCE);
193	WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);
194
195	// named_check_load_invoc() thunk
196	check_load_invoc_opcode = NativeOpcode(NATIVE_NAMED_CHECK_LOAD_INVOC);
197
198	static uint32 get_named_resource_template[] = {
199	PL(0x7c0802a6), // mflr r0
200	PL(0x90010008), // stw r0,8(r1)
201	PL(0x9421ffbc), // stwu r1,-68(r1)
202	PL(0x90610038), // stw r3,56(r1)
203	PL(0x9081003c), // stw r4,60(r1)
204	PL(0x00000000), // lwz r0,XLM_GET_NAMED_RESOURCE(r0)
205	PL(0x80402834), // lwz r2,XLM_RES_LIB_TOC(r0)
206	PL(0x7c0903a6), // mtctr r0
207	PL(0x4e800421), // bctrl
208	PL(0x90610040), // stw r3,64(r1)
209	PL(0x80610038), // lwz r3,56(r1)
210	PL(0x8081003c), // lwz r4,60(r1)
211	PL(0x80a10040), // lwz r5,64(r1)
212	PL(0x00000001), // <named_check_load_invoc>
213	PL(0x80610040), // lwz r3,64(r1)
214	PL(0x8001004c), // lwz r0,76(r1)
215	PL(0x7c0803a6), // mtlr r0
216	PL(0x38210044), // addi r1,r1,68
217	PL(0x4e800020) // blr
218	};
219	const uint32 get_named_resource_template_size = sizeof(get_named_resource_template);
220
221	xlm_index = -1, check_load_invoc_index = -1;
222	for (int i = 0; i < get_resource_template_size/4; i++) {
223	uint32 opcode = ntohl(get_resource_template[i]);
224	switch (opcode) {
225	case 0x00000000:
226	xlm_index = i;
227	break;
228	case 0x00000001:
229	check_load_invoc_index = i;
230	break;
231	}
232	}
233	assert(xlm_index != -1 && check_load_invoc_index != -1);
234
235	// GetNamedResource()
236	get_named_resource_func = base = SheepMem::Reserve(get_named_resource_template_size);
237	Host2Mac_memcpy(base, get_named_resource_template, get_named_resource_template_size);
238	WriteMacInt32(base + xlm_index * 4, 0x80000000 \| XLM_GET_NAMED_RESOURCE);
239	WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);
240
241	// Get1NamedResource()
242	get_1_named_resource_func = base = SheepMem::Reserve(get_named_resource_template_size);
243	Host2Mac_memcpy(base, get_named_resource_template, get_named_resource_template_size);
244	WriteMacInt32(base + xlm_index * 4, 0x80000000 \| XLM_GET_1_NAMED_RESOURCE);
245	WriteMacInt32(base + check_load_invoc_index * 4, check_load_invoc_opcode);
246	}
247	#endif
248
249
250	/*
251	* Initialize the thunks system
252	*/
253
254	struct native_op_t {
255	uint32 tvect;
256	uint32 func;
257	SheepRoutineDescriptor *desc;
258	};
259	static native_op_t native_op[NATIVE_OP_MAX];
260
261	bool ThunksInit(void)
262	{
263	#if EMULATED_PPC
264	for (int i = 0; i < NATIVE_OP_MAX; i++) {
265	uintptr base = SheepMem::Reserve(12);
266	WriteMacInt32(base + 0, base + 8);
267	WriteMacInt32(base + 4, 0); // Fake TVECT
268	WriteMacInt32(base + 8, NativeOpcode(i));
269	native_op[i].tvect = base;
270	native_op[i].func = base + 8;
271	}
272	#if POWERPC_GET_RESOURCE_THUNKS
273	generate_powerpc_thunks();
274	native_op[NATIVE_GET_RESOURCE].func = get_resource_func;
275	native_op[NATIVE_GET_1_RESOURCE].func = get_1_resource_func;
276	native_op[NATIVE_GET_IND_RESOURCE].func = get_ind_resource_func;
277	native_op[NATIVE_GET_1_IND_RESOURCE].func = get_1_ind_resource_func;
278	native_op[NATIVE_R_GET_RESOURCE].func = r_get_resource_func;
279	native_op[NATIVE_GET_NAMED_RESOURCE].func = get_named_resource_func;
280	native_op[NATIVE_GET_1_NAMED_RESOURCE].func = get_1_named_resource_func;
281	#endif
282	#else
283	#if defined(__linux__) \|\| defined(__NetBSD__) \|\| (defined(__APPLE__) && defined(__MACH__))
284	#define DEFINE_NATIVE_OP(ID, FUNC) do { \
285	uintptr base = SheepMem::Reserve(8); \
286	WriteMacInt32(base + 0, (uint32)FUNC); \
287	WriteMacInt32(base + 4, (uint32)TOC); \
288	native_op[ID].tvect = base; \
289	native_op[ID].func = (uint32)FUNC; \
290	} while (0)
291	#elif defined(__BEOS__)
292	#define DEFINE_NATIVE_OP(ID, FUNC) do { \
293	native_op[ID].tvect = FUNC; \
294	native_op[ID].func = ((uint32 *)FUNC)[0]; \
295	} while (0)
296	#else
297	#error "FIXME: define NativeOp for your platform"
298	#endif
299	// FIXME: add GetResource() and friends for completeness
300	DEFINE_NATIVE_OP(NATIVE_PATCH_NAME_REGISTRY, DoPatchNameRegistry);
301	DEFINE_NATIVE_OP(NATIVE_VIDEO_INSTALL_ACCEL, VideoInstallAccel);
302	DEFINE_NATIVE_OP(NATIVE_VIDEO_VBL, VideoVBL);
303	DEFINE_NATIVE_OP(NATIVE_VIDEO_DO_DRIVER_IO, VideoDoDriverIO);
304	DEFINE_NATIVE_OP(NATIVE_ETHER_AO_GET_HWADDR, AO_get_ethernet_address);
305	DEFINE_NATIVE_OP(NATIVE_ETHER_AO_ADD_MULTI, AO_enable_multicast);
306	DEFINE_NATIVE_OP(NATIVE_ETHER_AO_DEL_MULTI, AO_disable_multicast);
307	DEFINE_NATIVE_OP(NATIVE_ETHER_AO_SEND_PACKET, AO_transmit_packet);
308	DEFINE_NATIVE_OP(NATIVE_ETHER_IRQ, EtherIRQ);
309	DEFINE_NATIVE_OP(NATIVE_ETHER_INIT, InitStreamModule);
310	DEFINE_NATIVE_OP(NATIVE_ETHER_TERM, TerminateStreamModule);
311	DEFINE_NATIVE_OP(NATIVE_ETHER_OPEN, ether_open);
312	DEFINE_NATIVE_OP(NATIVE_ETHER_CLOSE, ether_close);
313	DEFINE_NATIVE_OP(NATIVE_ETHER_WPUT, ether_wput);
314	DEFINE_NATIVE_OP(NATIVE_ETHER_RSRV, ether_rsrv);
315	DEFINE_NATIVE_OP(NATIVE_SERIAL_NOTHING, SerialNothing);
316	DEFINE_NATIVE_OP(NATIVE_SERIAL_OPEN, SerialOpen);
317	DEFINE_NATIVE_OP(NATIVE_SERIAL_PRIME_IN, SerialPrimeIn);
318	DEFINE_NATIVE_OP(NATIVE_SERIAL_PRIME_OUT, SerialPrimeOut);
319	DEFINE_NATIVE_OP(NATIVE_SERIAL_CONTROL, SerialControl);
320	DEFINE_NATIVE_OP(NATIVE_SERIAL_STATUS, SerialStatus);
321	DEFINE_NATIVE_OP(NATIVE_SERIAL_CLOSE, SerialClose);
322	DEFINE_NATIVE_OP(NATIVE_MAKE_EXECUTABLE, MakeExecutable);
323	DEFINE_NATIVE_OP(NATIVE_NQD_SYNC_HOOK, NQD_sync_hook);
324	DEFINE_NATIVE_OP(NATIVE_NQD_BITBLT_HOOK, NQD_bitblt_hook);
325	DEFINE_NATIVE_OP(NATIVE_NQD_FILLRECT_HOOK, NQD_fillrect_hook);
326	DEFINE_NATIVE_OP(NATIVE_NQD_UNKNOWN_HOOK, NQD_unknown_hook);
327	DEFINE_NATIVE_OP(NATIVE_NQD_BITBLT, NQD_bitblt);
328	DEFINE_NATIVE_OP(NATIVE_NQD_INVRECT, NQD_invrect);
329	DEFINE_NATIVE_OP(NATIVE_NQD_FILLRECT, NQD_fillrect);
330	#undef DEFINE_NATIVE_OP
331	#endif
332
333	// Initialize routine descriptors (if TVECT exists)
334	for (int i = 0; i < NATIVE_OP_MAX; i++) {
335	uint32 tvect = native_op[i].tvect;
336	if (tvect)
337	native_op[i].desc = new SheepRoutineDescriptor(0, tvect);
338	}
339
340	return true;
341	}
342
343
344	/*
345	* Delete generated thunks
346	*/
347
348	void ThunksExit(void)
349	{
350	for (int i = 0; i < NATIVE_OP_MAX; i++) {
351	SheepRoutineDescriptor *desc = native_op[i].desc;
352	if (desc)
353	delete desc;
354	}
355	}
356
357
358	/*
359	* Return the native function descriptor (TVECT)
360	*/
361
362	uint32 NativeTVECT(int selector)
363	{
364	assert(selector < NATIVE_OP_MAX);
365	const uint32 tvect = native_op[selector].tvect;
366	assert(tvect != 0);
367	return tvect;
368	}
369
370
371	/*
372	* Return the native function address
373	*/
374
375	uint32 NativeFunction(int selector)
376	{
377	assert(selector < NATIVE_OP_MAX);
378	const uint32 func = native_op[selector].func;
379	assert(func != 0);
380	return func;
381	}
382
383
384	/*
385	* Return the routine descriptor address of the native function
386	*/
387
388	uint32 NativeRoutineDescriptor(int selector)
389	{
390	assert(selector < NATIVE_OP_MAX);
391	SheepRoutineDescriptor * const desc = native_op[selector].desc;
392	assert(desc != 0);
393	return desc->addr();
394	}
395
396
397	/*
398	* Execute native code from EMUL_OP routine (real mode switch)
399	*/
400
401	void ExecuteNative(int selector)
402	{
403	M68kRegisters r;
404	Execute68k(NativeRoutineDescriptor(selector), &r);
405	}