1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
|
/*
File: MachineExceptions.h
Contains: Processor Exception Handling Interfaces.
Version: QuickTime 7.3
Copyright: (c) 2007 (c) 1993-2001 by Apple Computer, Inc., all rights reserved.
Bugs?: For bug reports, consult the following page on
the World Wide Web:
http://developer.apple.com/bugreporter/
*/
#ifndef __MACHINEEXCEPTIONS__
#define __MACHINEEXCEPTIONS__
#ifndef __MACTYPES__
#include <MacTypes.h>
#endif
#ifndef __MIXEDMODE__
#include <MixedMode.h>
#endif
#if PRAGMA_ONCE
#pragma once
#endif
#ifdef __cplusplus
extern "C" {
#endif
#if PRAGMA_IMPORT
#pragma import on
#endif
#if PRAGMA_STRUCT_ALIGN
#pragma options align=power
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(push, 2)
#elif PRAGMA_STRUCT_PACK
#pragma pack(2)
#endif
/* Some basic declarations used throughout the kernel */
typedef struct OpaqueAreaID* AreaID;
#if TARGET_OS_MAC
/* Machine Dependent types for PowerPC: */
struct MachineInformationPowerPC {
UnsignedWide CTR;
UnsignedWide LR;
UnsignedWide PC;
unsigned long CR;
unsigned long XER;
unsigned long MSR;
unsigned long MQ;
unsigned long ExceptKind;
unsigned long DSISR;
UnsignedWide DAR;
UnsignedWide Reserved;
};
typedef struct MachineInformationPowerPC MachineInformationPowerPC;
struct RegisterInformationPowerPC {
UnsignedWide R0;
UnsignedWide R1;
UnsignedWide R2;
UnsignedWide R3;
UnsignedWide R4;
UnsignedWide R5;
UnsignedWide R6;
UnsignedWide R7;
UnsignedWide R8;
UnsignedWide R9;
UnsignedWide R10;
UnsignedWide R11;
UnsignedWide R12;
UnsignedWide R13;
UnsignedWide R14;
UnsignedWide R15;
UnsignedWide R16;
UnsignedWide R17;
UnsignedWide R18;
UnsignedWide R19;
UnsignedWide R20;
UnsignedWide R21;
UnsignedWide R22;
UnsignedWide R23;
UnsignedWide R24;
UnsignedWide R25;
UnsignedWide R26;
UnsignedWide R27;
UnsignedWide R28;
UnsignedWide R29;
UnsignedWide R30;
UnsignedWide R31;
};
typedef struct RegisterInformationPowerPC RegisterInformationPowerPC;
struct FPUInformationPowerPC {
UnsignedWide Registers[32];
unsigned long FPSCR;
unsigned long Reserved;
};
typedef struct FPUInformationPowerPC FPUInformationPowerPC;
union Vector128 {
#ifdef __VEC__
vector unsigned int v;
#endif
unsigned long l[4];
unsigned short s[8];
unsigned char c[16];
};
typedef union Vector128 Vector128;
struct VectorInformationPowerPC {
Vector128 Registers[32];
Vector128 VSCR;
UInt32 VRsave;
};
typedef struct VectorInformationPowerPC VectorInformationPowerPC;
/* Exception related declarations */
enum {
kWriteReference = 0,
kReadReference = 1,
kFetchReference = 2,
writeReference = kWriteReference, /* Obsolete name*/
readReference = kReadReference, /* Obsolete name*/
fetchReference = kFetchReference /* Obsolete name*/
};
typedef unsigned long MemoryReferenceKind;
struct MemoryExceptionInformation {
AreaID theArea; /* The area related to the execption, same as MPAreaID.*/
LogicalAddress theAddress; /* The 32-bit address of the exception.*/
OSStatus theError; /* See enum below.*/
MemoryReferenceKind theReference; /* read, write, instruction fetch.*/
};
typedef struct MemoryExceptionInformation MemoryExceptionInformation;
enum {
kUnknownException = 0,
kIllegalInstructionException = 1,
kTrapException = 2,
kAccessException = 3,
kUnmappedMemoryException = 4,
kExcludedMemoryException = 5,
kReadOnlyMemoryException = 6,
kUnresolvablePageFaultException = 7,
kPrivilegeViolationException = 8,
kTraceException = 9,
kInstructionBreakpointException = 10, /* Optional*/
kDataBreakpointException = 11, /* Optional*/
kIntegerException = 12,
kFloatingPointException = 13,
kStackOverflowException = 14, /* Optional, may be implemented as kAccessException on some systems.*/
kTaskTerminationException = 15, /* Obsolete*/
kTaskCreationException = 16, /* Obsolete*/
kDataAlignmentException = 17 /* May occur when a task is in little endian mode or created with kMPTaskTakesAllExceptions.*/
};
#if OLDROUTINENAMES
enum {
unknownException = kUnknownException, /* Obsolete name*/
illegalInstructionException = kIllegalInstructionException, /* Obsolete name*/
trapException = kTrapException, /* Obsolete name*/
accessException = kAccessException, /* Obsolete name*/
unmappedMemoryException = kUnmappedMemoryException, /* Obsolete name*/
excludedMemoryException = kExcludedMemoryException, /* Obsolete name*/
readOnlyMemoryException = kReadOnlyMemoryException, /* Obsolete name*/
unresolvablePageFaultException = kUnresolvablePageFaultException, /* Obsolete name*/
privilegeViolationException = kPrivilegeViolationException, /* Obsolete name*/
traceException = kTraceException, /* Obsolete name*/
instructionBreakpointException = kInstructionBreakpointException, /* Obsolete name*/
dataBreakpointException = kDataBreakpointException, /* Obsolete name*/
integerException = kIntegerException, /* Obsolete name*/
floatingPointException = kFloatingPointException, /* Obsolete name*/
stackOverflowException = kStackOverflowException, /* Obsolete name*/
terminationException = kTaskTerminationException, /* Obsolete name*/
kTerminationException = kTaskTerminationException /* Obsolete name*/
};
#endif /* OLDROUTINENAMES */
typedef unsigned long ExceptionKind;
union ExceptionInfo {
MemoryExceptionInformation * memoryInfo;
};
typedef union ExceptionInfo ExceptionInfo;
struct ExceptionInformationPowerPC {
ExceptionKind theKind;
MachineInformationPowerPC * machineState;
RegisterInformationPowerPC * registerImage;
FPUInformationPowerPC * FPUImage;
ExceptionInfo info;
VectorInformationPowerPC * vectorImage;
};
typedef struct ExceptionInformationPowerPC ExceptionInformationPowerPC;
#if TARGET_CPU_PPC || TARGET_CPU_68K
typedef ExceptionInformationPowerPC ExceptionInformation;
typedef MachineInformationPowerPC MachineInformation;
typedef RegisterInformationPowerPC RegisterInformation;
typedef FPUInformationPowerPC FPUInformation;
typedef VectorInformationPowerPC VectorInformation;
#endif /* TARGET_CPU_PPC || TARGET_CPU_68K */
/*
Note: An ExceptionHandler is NOT a UniversalProcPtr, except in Carbon.
It must be a PowerPC function pointer with NO routine descriptor,
except on Carbon, where it must be a UniversalProcPtr (TPP actually)
to allow the interface to work from both CFM and Mach-O.
*/
typedef CALLBACK_API_C( OSStatus , ExceptionHandlerProcPtr )(ExceptionInformation * theException);
typedef TVECTOR_UPP_TYPE(ExceptionHandlerProcPtr) ExceptionHandlerUPP;
/*
* NewExceptionHandlerUPP()
*
* Availability:
* Non-Carbon CFM: available as macro/inline
* CarbonLib: in CarbonLib 1.1 and later
* Mac OS X: in version 10.0 and later
*/
EXTERN_API_C( ExceptionHandlerUPP )
NewExceptionHandlerUPP(ExceptionHandlerProcPtr userRoutine);
#if !OPAQUE_UPP_TYPES
enum { uppExceptionHandlerProcInfo = 0x000000F1 }; /* 4_bytes Func(4_bytes) */
#ifdef __cplusplus
inline DEFINE_API_C(ExceptionHandlerUPP) NewExceptionHandlerUPP(ExceptionHandlerProcPtr userRoutine) { return userRoutine; }
#else
#define NewExceptionHandlerUPP(userRoutine) (userRoutine)
#endif
#endif
/*
* DisposeExceptionHandlerUPP()
*
* Availability:
* Non-Carbon CFM: available as macro/inline
* CarbonLib: in CarbonLib 1.1 and later
* Mac OS X: in version 10.0 and later
*/
EXTERN_API_C( void )
DisposeExceptionHandlerUPP(ExceptionHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
inline DEFINE_API_C(void) DisposeExceptionHandlerUPP(ExceptionHandlerUPP) {}
#else
#define DisposeExceptionHandlerUPP(userUPP)
#endif
#endif
/*
* InvokeExceptionHandlerUPP()
*
* Availability:
* Non-Carbon CFM: available as macro/inline
* CarbonLib: in CarbonLib 1.1 and later
* Mac OS X: in version 10.0 and later
*/
EXTERN_API_C( OSStatus )
InvokeExceptionHandlerUPP(
ExceptionInformation * theException,
ExceptionHandlerUPP userUPP);
#if !OPAQUE_UPP_TYPES
#ifdef __cplusplus
inline DEFINE_API_C(OSStatus) InvokeExceptionHandlerUPP(ExceptionInformation * theException, ExceptionHandlerUPP userUPP) { return (*userUPP)(theException); }
#else
#define InvokeExceptionHandlerUPP(theException, userUPP) (*userUPP)(theException)
#endif
#endif
/*
ExceptionHandler function pointers (TPP):
on classic PowerPC, use raw function pointers
on classic PowerPC with OPAQUE_UPP_TYPES=1, use UPP's
on Carbon, use UPP's
*/
#if TARGET_OS_MAC && !OPAQUE_UPP_TYPES
/* use raw function pointers*/
typedef ExceptionHandlerProcPtr ExceptionHandlerTPP;
#else
/* use UPP's*/
typedef ExceptionHandlerUPP ExceptionHandlerTPP;
#endif /* TARGET_OS_MAC && !OPAQUE_UPP_TYPES */
typedef ExceptionHandlerTPP ExceptionHandler;
/* Routine for installing per-process exception handlers */
/*
* InstallExceptionHandler()
*
* Availability:
* Non-Carbon CFM: in InterfaceLib 7.1 and later
* CarbonLib: in CarbonLib 1.1 and later
* Mac OS X: in version 10.0 and later
*/
EXTERN_API( ExceptionHandlerTPP ) InstallExceptionHandler(ExceptionHandlerTPP theHandler);
#endif /* TARGET_OS_MAC */
#if PRAGMA_STRUCT_ALIGN
#pragma options align=reset
#elif PRAGMA_STRUCT_PACKPUSH
#pragma pack(pop)
#elif PRAGMA_STRUCT_PACK
#pragma pack()
#endif
#ifdef PRAGMA_IMPORT_OFF
#pragma import off
#elif PRAGMA_IMPORT
#pragma import reset
#endif
#ifdef __cplusplus
}
#endif
#endif /* __MACHINEEXCEPTIONS__ */
|