ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/SheepShaver/src/include/thunks.h
(Generate patch)

Comparing SheepShaver/src/include/thunks.h (file contents):
Revision 1.2 by gbeauche, 2003-12-05T12:36:11Z vs.
Revision 1.14 by gbeauche, 2006-05-03T21:45:14Z

# Line 32 | Line 32 | enum {
32    NATIVE_VIDEO_INSTALL_ACCEL,
33    NATIVE_VIDEO_VBL,
34    NATIVE_VIDEO_DO_DRIVER_IO,
35 +  NATIVE_ETHER_AO_GET_HWADDR,
36 +  NATIVE_ETHER_AO_ADD_MULTI,
37 +  NATIVE_ETHER_AO_DEL_MULTI,
38 +  NATIVE_ETHER_AO_SEND_PACKET,
39    NATIVE_ETHER_IRQ,
40    NATIVE_ETHER_INIT,
41    NATIVE_ETHER_TERM,
# Line 51 | Line 55 | enum {
55    NATIVE_GET_IND_RESOURCE,
56    NATIVE_GET_1_IND_RESOURCE,
57    NATIVE_R_GET_RESOURCE,
54  NATIVE_DISABLE_INTERRUPT,
55  NATIVE_ENABLE_INTERRUPT,
58    NATIVE_MAKE_EXECUTABLE,
59 +  NATIVE_CHECK_LOAD_INVOC,
60 +  NATIVE_SYNC_HOOK,
61 +  NATIVE_BITBLT_HOOK,
62 +  NATIVE_FILLRECT_HOOK,
63 +  NATIVE_BITBLT,
64 +  NATIVE_INVRECT,
65 +  NATIVE_FILLRECT,
66 +  NATIVE_NAMED_CHECK_LOAD_INVOC,
67 +  NATIVE_GET_NAMED_RESOURCE,
68 +  NATIVE_GET_1_NAMED_RESOURCE,
69    NATIVE_OP_MAX
70   };
71  
72   // Initialize the thunks system
73   extern bool ThunksInit(void);
74  
75 + // Exit the thunks system
76 + extern void ThunksExit(void);
77 +
78   // Return the fake PowerPC opcode to handle specified native code
79   #if EMULATED_PPC
80   extern uint32 NativeOpcode(int selector);
# Line 71 | Line 86 | extern uint32 NativeTVECT(int selector);
86   // Return the native function address
87   extern uint32 NativeFunction(int selector);
88  
89 + // Return the routine descriptor address of the native function
90 + extern uint32 NativeRoutineDescriptor(int selector);
91 +
92  
93   /*
94   *  Helpers to share 32-bit addressable data with MacOS
95 + *
96 + *  There are two distinct allocatable regions:
97 + *
98 + *  - The Data region is used to share data between MacOS and
99 + *    SheepShaver. This is stack-like allocation since it is
100 + *    meant to only hold temporary data which dies at the end
101 + *    of the current function scope.
102 + *
103 + *  - The Procedure region is used to hold permanent M68K or
104 + *    PowerPC code to assist native routine implementations.
105 + *
106 + *  - The Procedure region grows up whereas the Data region
107 + *    grows down. They may intersect into the ZeroPage, which
108 + *    is a read-only page with all bits set to zero. In practise,
109 + *    the intersection is unlikely since the Procedure region is
110 + *    static and the Data region is meant to be small (< 256 KB).
111   */
112  
113   class SheepMem {
114          static uint32 align(uint32 size);
115   protected:
116 +        static uint32  page_size;
117          static uintptr zero_page;
118          static uintptr base;
119 <        static uintptr top;
120 <        static const uint32 size = 0x40000;
119 >        static uintptr data;
120 >        static uintptr proc;
121 >        static const uint32 size = 0x80000; // 512 KB
122   public:
123          static bool Init(void);
124          static void Exit(void);
125 <        static uintptr ZeroPage();
126 <        static uintptr Reserve(uint32 size);
125 >        static uint32 PageSize();
126 >        static uint32 ZeroPage();
127 >        static uint32 Reserve(uint32 size);
128          static void Release(uint32 size);
129 +        static uint32 ReserveProc(uint32 size);
130          friend class SheepVar;
131   };
132  
# Line 98 | Line 136 | inline uint32 SheepMem::align(uint32 siz
136          return (size + 3) & -4;
137   }
138  
139 < inline uintptr SheepMem::ZeroPage()
139 > inline uint32 SheepMem::PageSize()
140 > {
141 >  return page_size;
142 > }
143 >
144 > inline uint32 SheepMem::ZeroPage()
145   {
146    return zero_page;
147   }
148  
149 < inline uintptr SheepMem::Reserve(uint32 size)
149 > inline uint32 SheepMem::Reserve(uint32 size)
150   {
151 <        top -= align(size);
152 <        assert(top >= base);
153 <        return top;
151 >        data -= align(size);
152 >        assert(data >= proc);
153 >        return data;
154   }
155  
156   inline void SheepMem::Release(uint32 size)
157   {
158 <        top += align(size);
158 >        data += align(size);
159 > }
160 >
161 > inline uint32 SheepMem::ReserveProc(uint32 size)
162 > {
163 >        uint32 mproc = proc;
164 >        proc += align(size);
165 >        assert(proc < data);
166 >        return mproc;
167 > }
168 >
169 > static inline uint32 SheepProc(const uint8 *proc, uint32 proc_size)
170 > {
171 >        uint32 mac_proc = SheepMem::ReserveProc(proc_size);
172 >        Host2Mac_memcpy(mac_proc, proc, proc_size);
173 >        return mac_proc;
174   }
175  
176 + #define BUILD_SHEEPSHAVER_PROCEDURE(PROC)                                                       \
177 +        static uint32 PROC = 0;                                                                                 \
178 +        if (PROC == 0)                                                                                                  \
179 +                PROC = SheepProc(PROC##_template, sizeof(PROC##_template))
180 +
181   class SheepVar
182   {
183 <        uintptr m_base;
184 <        uint32  m_size;
183 >        uint32 m_base;
184 >        uint32 m_size;
185   public:
186          SheepVar(uint32 requested_size);
187          ~SheepVar() { SheepMem::Release(m_size); }
188 <        uintptr addr() const { return m_base; }
126 <        void *ptr() const { return (void *)addr(); }
188 >        uint32 addr() const { return m_base; }
189   };
190  
191   inline SheepVar::SheepVar(uint32 requested_size)
# Line 134 | Line 196 | inline SheepVar::SheepVar(uint32 request
196  
197   // TODO: optimize for 32-bit platforms
198  
199 < template< int size >
199 > template< int requested_size >
200   struct SheepArray : public SheepVar
201   {
202 <        SheepArray() : SheepVar(size) { }
141 <        uint8 *ptr() const { return (uint8 *)addr(); }
202 >        SheepArray() : SheepVar(requested_size) { }
203   };
204  
205   struct SheepVar32 : public SheepVar
# Line 147 | Line 208 | struct SheepVar32 : public SheepVar
208          SheepVar32(uint32 value) : SheepVar(4) { set_value(value); }
209          uint32 value() const { return ReadMacInt32(addr()); }
210          void set_value(uint32 v) { WriteMacInt32(addr(), v); }
150        uint32 *ptr() const { return (uint32 *)addr(); }
211   };
212  
213   struct SheepString : public SheepVar
214   {
215          SheepString(const char *str) : SheepVar(strlen(str) + 1)
216 <                { if (str) strcpy((char *)addr(), str); else WriteMacInt8(addr(), 0); }
216 >                { if (str) strcpy(value(), str); else WriteMacInt8(addr(), 0); }
217          char *value() const
218 <                { return (char *)addr(); }
159 <        char *ptr() const
160 <                { return (char *)addr(); }
218 >                { return (char *)Mac2HostAddr(addr()); }
219   };
220  
221   #endif

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines