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
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// Undo the damage that exception_defines.h does.
#undef try
#undef catch
#ifndef nsObjCExceptions_h_
#define nsObjCExceptions_h_
#import <Foundation/Foundation.h>
#ifdef DEBUG
#import <ExceptionHandling/NSExceptionHandler.h>
#endif
#include <unistd.h>
#include <signal.h>
#include "nsError.h"
// Undo the damage that exception_defines.h does.
#undef try
#undef catch
/* NOTE: Macros that claim to abort no longer abort, see bug 486574.
* If you actually want to log and abort, call "nsObjCExceptionLogAbort"
* from an exception handler. At some point we will fix this by replacing
* all macros in the tree with appropriately-named macros.
*/
// See Mozilla bug 163260.
// This file can only be included in an Objective-C context.
__attribute__((unused))
static void
nsObjCExceptionLog(NSException* aException)
{
NSLog(@"Mozilla has caught an Obj-C exception [%@: %@]",
[aException name], [aException reason]);
#ifdef DEBUG
@try {
// Try to get stack information out of the exception. 10.5 returns the stack
// info with the callStackReturnAddresses selector.
NSArray* stackTrace = nil;
if ([aException respondsToSelector:@selector(callStackReturnAddresses)]) {
NSArray* addresses = (NSArray*)
[aException performSelector:@selector(callStackReturnAddresses)];
if ([addresses count]) {
stackTrace = addresses;
}
}
// 10.4 doesn't respond to callStackReturnAddresses so we'll try to pull the
// stack info out of the userInfo. It might not be there, sadly :(
if (!stackTrace) {
stackTrace = [[aException userInfo] objectForKey:NSStackTraceKey];
}
if (stackTrace) {
// The command line should look like this:
// /usr/bin/atos -p <pid> -printHeader <stack frame addresses>
NSMutableArray* args =
[NSMutableArray arrayWithCapacity:[stackTrace count] + 3];
[args addObject:@"-p"];
int pid = [[NSProcessInfo processInfo] processIdentifier];
[args addObject:[NSString stringWithFormat:@"%d", pid]];
[args addObject:@"-printHeader"];
unsigned int stackCount = [stackTrace count];
unsigned int stackIndex = 0;
for (; stackIndex < stackCount; stackIndex++) {
unsigned long address =
[[stackTrace objectAtIndex:stackIndex] unsignedLongValue];
[args addObject:[NSString stringWithFormat:@"0x%lx", address]];
}
NSPipe* outPipe = [NSPipe pipe];
NSTask* task = [[NSTask alloc] init];
[task setLaunchPath:@"/usr/bin/atos"];
[task setArguments:args];
[task setStandardOutput:outPipe];
[task setStandardError:outPipe];
NSLog(@"Generating stack trace for Obj-C exception...");
// This will throw an exception if the atos tool cannot be found, and in
// that case we'll just hit our @catch block below.
[task launch];
[task waitUntilExit];
[task release];
NSData* outData =
[[outPipe fileHandleForReading] readDataToEndOfFile];
NSString* outString =
[[NSString alloc] initWithData:outData encoding:NSUTF8StringEncoding];
NSLog(@"Stack trace:\n%@", outString);
[outString release];
} else {
NSLog(@"<No stack information available for Obj-C exception>");
}
}
@catch (NSException* exn) {
NSLog(@"Failed to generate stack trace for Obj-C exception [%@: %@]",
[exn name], [exn reason]);
}
#endif
}
__attribute__((unused))
static void
nsObjCExceptionAbort()
{
// We need to raise a mach-o signal here, the Mozilla crash reporter on
// Mac OS X does not respond to POSIX signals. Raising mach-o signals directly
// is tricky so we do it by just derefing a null pointer.
int* foo = nullptr;
*foo = 1;
}
__attribute__((unused))
static void
nsObjCExceptionLogAbort(NSException* aException)
{
nsObjCExceptionLog(aException);
nsObjCExceptionAbort();
}
#define NS_OBJC_TRY(_e, _fail) \
@try { _e; } \
@catch(NSException *_exn) { \
nsObjCExceptionLog(_exn); \
_fail; \
}
#define NS_OBJC_TRY_EXPR(_e, _fail) \
({ \
typeof(_e) _tmp; \
@try { _tmp = (_e); } \
@catch(NSException *_exn) { \
nsObjCExceptionLog(_exn); \
_fail; \
} \
_tmp; \
})
#define NS_OBJC_TRY_EXPR_NULL(_e) \
NS_OBJC_TRY_EXPR(_e, 0)
#define NS_OBJC_TRY_IGNORE(_e) \
NS_OBJC_TRY(_e, )
// To reduce code size the abort versions do not reuse above macros. This allows
// catch blocks to only contain one call.
#define NS_OBJC_TRY_ABORT(_e) \
@try { _e; } \
@catch(NSException *_exn) { \
nsObjCExceptionLog(_exn); \
}
#define NS_OBJC_TRY_EXPR_ABORT(_e) \
({ \
typeof(_e) _tmp; \
@try { _tmp = (_e); } \
@catch(NSException *_exn) { \
nsObjCExceptionLog(_exn); \
} \
_tmp; \
})
// For wrapping blocks of Obj-C calls. Does not actually terminate.
#define NS_OBJC_BEGIN_TRY_ABORT_BLOCK @try {
#define NS_OBJC_END_TRY_ABORT_BLOCK } @catch(NSException *_exn) { \
nsObjCExceptionLog(_exn); \
}
// Same as above ABORT_BLOCK but returns a value after the try/catch block to
// suppress compiler warnings. This allows us to avoid having to refactor code
// to get scoping right when wrapping an entire method.
#define NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NIL @try {
#define NS_OBJC_END_TRY_ABORT_BLOCK_NIL } @catch(NSException *_exn) { \
nsObjCExceptionLog(_exn); \
} \
return nil;
#define NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSNULL @try {
#define NS_OBJC_END_TRY_ABORT_BLOCK_NSNULL } @catch(NSException *_exn) { \
nsObjCExceptionLog(_exn); \
} \
return nullptr;
#define NS_OBJC_BEGIN_TRY_ABORT_BLOCK_NSRESULT @try {
#define NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT } @catch(NSException *_exn) { \
nsObjCExceptionLog(_exn); \
} \
return NS_ERROR_FAILURE;
#define NS_OBJC_BEGIN_TRY_ABORT_BLOCK_RETURN @try {
#define NS_OBJC_END_TRY_ABORT_BLOCK_RETURN(_rv) } @catch(NSException *_exn) { \
nsObjCExceptionLog(_exn);\
} \
return _rv;
#endif // nsObjCExceptions_h_
|
