#import "common.h"

#define EXPOSE_NSException_IVARS 1

#define EXPOSE_NSThread_IVARS 1

#import "GSPrivate.h"

#import "Foundation/NSEnumerator.h"

#import "Foundation/NSException.h"

#import "Foundation/NSArray.h"

#import "Foundation/NSCoder.h"

#import "Foundation/NSData.h"

#import "Foundation/NSLock.h"

#import "Foundation/NSNull.h"

#import "Foundation/NSThread.h"

#import "Foundation/NSLock.h"

#import "Foundation/NSDictionary.h"

#import "Foundation/NSValue.h"

#import "GNUstepBase/NSString+GNUstepBase.h"

#import "GSPThread.h"

#ifdef __GNUSTEP_RUNTIME__

#include <objc/hooks.h>

#endif

#ifdef HAVE_SET_UNCAUGHT_EXCEPTION_HANDLER

#include <objc/objc-exception.h>

#endif

#ifdef HAVE_MALLOC_H

#if !defined(__OpenBSD__)

#include <malloc.h>

#endif

#endif

#ifdef HAVE_ALLOCA_H

#include <alloca.h>

#endif

#include <stdio.h>

#ifdef HAVE_BACKTRACE

#include <execinfo.h>

#endif

#if !(defined(HAVE_BFD_H) && defined(HAVE_LIBBFD) && defined(HAVE_LIBIBERTY))

# if defined(USE_BFD)

# undef USE_BFD

# endif

#endif

#if defined(_WIN32) && !defined(USE_BFD)

#include <windows.h>

#if defined(HAVE_DBGHELP_H)

#include <dbghelp.h>

#else

#define SYMOPT_UNDNAME 0x00000002

#define SYMOPT_DEFERRED_LOADS 0x00000004

typedef struct _SYMBOL_INFO {

ULONG SizeOfStruct;

ULONG TypeIndex;

uint64_t Reserved[2];

ULONG Index;

ULONG Size;

uint64_t ModBase;

ULONG Flags;

uint64_t Value;

uint64_t Address;

ULONG Register;

ULONG Scope;

ULONG Tag;

ULONG NameLen;

ULONG MaxNameLen;

TCHAR Name[1];

} SYMBOL_INFO;

#endif

#endif

static NSUncaughtExceptionHandler *_NSUncaughtExceptionHandler = 0;

#define _e_info (((id*)_reserved)[0])

#define _e_stack (((id*)_reserved)[1])

@interface NSException (GSPrivate)

- (GSStackTrace*) _callStack;

#if defined(_WIN32)

#if defined(USE_BFD)

static NSString *

GSPrivateBaseAddress(void *addr, void **base)

{

MEMORY_BASIC_INFORMATION info;

/* Found a note saying that according to Matt Pietrek's "Under the Hood"

if (VirtualQuery (addr, &info, sizeof(info)) != 0)

{

HMODULE handle = (HMODULE) info.AllocationBase;

unichar path[MAX_PATH+1];

if (GetModuleFileNameW(handle, path, sizeof(path)-1) != 0)

{

path[sizeof(path)-1] = '\0';

*base = info.BaseAddress;

return [NSString stringWithCharacters: path length: wcslen(path)];

}

}

return nil;

}

#endif /* USE_BFD */

#else /* _WIN32 */

#include <dlfcn.h>

#if defined(USE_BFD)

static NSString *

GSPrivateBaseAddress(void *addr, void **base)

{

#ifdef HAVE_DLADDR

Dl_info info;

if (!dladdr(addr, &info))

return nil;

*base = info.dli_fbase;

return [NSString stringWithUTF8String: info.dli_fname];

#else

return nil;

#endif

}

#endif /* USE_BFD */

#endif /* _WIN32 */

#if defined(USE_BFD)

#include <bfd.h>

@class GSBinaryFileInfo;

@interface GSFunctionInfo : NSObject

{

void *_address;

NSString *_fileName;

NSString *_functionName;

int _lineNo;

GSBinaryFileInfo *_module;

}

- (void*) address;

- (NSString *) fileName;

- (NSString *) function;

- (id) initWithModule: (GSBinaryFileInfo*)module

address: (void*)address

file: (NSString*)file

function: (NSString*)function

line: (int)lineNo;

- (int) lineNumber;

- (GSBinaryFileInfo*) module;

@interface GSBinaryFileInfo : NSObject

{

NSString *_fileName;

bfd *_abfd;

asymbol **_symbols;

long _symbolCount;

}

- (NSString *) fileName;

- (GSFunctionInfo *) functionForAddress: (void*) address;

- (id) initWithBinaryFile: (NSString *)fileName;

- (id) init; // return info for the current executing process



@implementation GSFunctionInfo

- (void*) address

{

return _address;

}

- (oneway void) dealloc

{

DESTROY(_module);

DESTROY(_fileName);

DESTROY(_functionName);

[super dealloc];

}

- (NSString *) description

{

return [NSString stringWithFormat: @"(%@: %p) %@ %@: %d",

[_module fileName], _address, _functionName, _fileName, _lineNo];

}

- (NSString *) fileName

{

return _fileName;

}

- (NSString *) function

{

return _functionName;

}

- (id) init

{

DESTROY(self);

return nil;

}

- (id) initWithModule: (GSBinaryFileInfo*)module

address: (void*)address

file: (NSString*)file

function: (NSString*)function

line: (int)lineNo

{

_module = RETAIN(module);

_address = address;

_fileName = [file copy];

_functionName = [function copy];

_lineNo = lineNo;

return self;

}

- (int) lineNumber

{

return _lineNo;

}

- (GSBinaryFileInfo *) module

{

return _module;

}



@implementation GSBinaryFileInfo

+ (GSBinaryFileInfo*) infoWithBinaryFile: (NSString *)fileName

{

return [[[self alloc] initWithBinaryFile: fileName] autorelease];

}

+ (void) initialize

{

static BOOL first = YES;

if (first == NO)

{

return;

}

first = NO;

bfd_init ();

}

- (oneway void) dealloc

{

DESTROY(_fileName);

if (_abfd)

{

bfd_close (_abfd);

_abfd = NULL;

}

if (_symbols)

{

free(_symbols);

_symbols = NULL;

}

[super dealloc];

}

- (NSString *) fileName

{

return _fileName;

}

- (id) init

{

NSString *processName;

processName = [[[NSProcessInfo processInfo] arguments] objectAtIndex: 0];

return [self initWithBinaryFile: processName];

}

- (id) initWithBinaryFile: (NSString *)fileName

{

int neededSpace;

// 1st initialize the bfd

if ([fileName length] == 0)

{

//NSLog (@"GSBinaryFileInfo: No File");

DESTROY(self);

return nil;

}

_fileName = [fileName copy];

_abfd = bfd_openr ([fileName cString], NULL);

if (!_abfd)

{

//NSLog (@"GSBinaryFileInfo: No Binary Info");

DESTROY(self);

return nil;

}

if (!bfd_check_format_matches (_abfd, bfd_object, NULL))

{

//NSLog (@"GSBinaryFileInfo: BFD format object error");

DESTROY(self);

return nil;

}

// second read the symbols from it

if (!(bfd_get_file_flags (_abfd) & HAS_SYMS))

{

//NSLog (@"GSBinaryFileInfo: BFD does not contain any symbols");

DESTROY(self);

return nil;

}

neededSpace = bfd_get_symtab_upper_bound (_abfd);

if (neededSpace < 0)

{

//NSLog (@"GSBinaryFileInfo: BFD error while deducing needed space");

DESTROY(self);

return nil;

}

if (neededSpace == 0)

{

//NSLog (@"GSBinaryFileInfo: BFD no space for symbols needed");

DESTROY(self);

return nil;

}

_symbols = malloc (neededSpace);

if (!_symbols)

{

//NSLog (@"GSBinaryFileInfo: Can't allocate buffer");

DESTROY(self);

return nil;

}

_symbolCount = bfd_canonicalize_symtab (_abfd, _symbols);

if (_symbolCount < 0)

{

//NSLog (@"GSBinaryFileInfo: BFD error while reading symbols");

DESTROY(self);

return nil;

}

return self;

}

struct SearchAddressStruct

{

void *theAddress;

GSBinaryFileInfo *module;

asymbol **symbols;

GSFunctionInfo *theInfo;

};

static void find_address (bfd *abfd, asection *section,

struct SearchAddressStruct *info)

{

bfd_vma address;

bfd_vma vma;

unsigned size;

const char *fileName = 0;

const char *functionName = 0;

unsigned line = 0;

if (info->theInfo)

{

return;

}

address = (bfd_vma) (uintptr_t)info->theAddress;

/* bfd_get_section_vma() was changed to bfd_section_vma() together with

#if defined(HAVE_BFD_SECTION_VMA)

if (!(bfd_section_flags(section) & SEC_ALLOC))

{

return; // Only debug in this section

}

if (bfd_section_flags(section) & SEC_DATA)

{

return; // Only data in this section

}

vma = bfd_section_vma(section);

size = bfd_section_size(section);

#else

if (!(bfd_get_section_flags(abfd, section) & SEC_ALLOC))

{

return; // Only debug in this section

}

if (bfd_get_section_flags(abfd, section) & SEC_DATA)

{

return; // Only data in this section

}

vma = bfd_get_section_vma(abfd, section);

size = bfd_section_size(abfd, section);

#endif

if (address < vma || address >= vma + size)

{

return;

}

if (bfd_find_nearest_line (abfd, section, info->symbols,

address - vma, &fileName, &functionName, &line))

{

GSFunctionInfo *fi;

NSString *file = nil;

NSString *func = nil;

if (fileName != 0)

{

file = [NSString stringWithCString: fileName

encoding: [NSString defaultCStringEncoding]];

}

if (functionName != 0)

{

func = [NSString stringWithCString: functionName

encoding: [NSString defaultCStringEncoding]];

}

fi = [GSFunctionInfo alloc];

fi = [fi initWithModule: info->module

address: info->theAddress

file: file

function: func

line: line];

[fi autorelease];

info->theInfo = fi;

}

}

- (GSFunctionInfo *) functionForAddress: (void*) address

{

struct SearchAddressStruct searchInfo =

{ address, self, _symbols, nil };

bfd_map_over_sections (_abfd,

(void (*) (bfd *, asection *, void *)) find_address, &searchInfo);

return searchInfo.theInfo;

}

static pthread_mutex_t modLock;

static NSMutableDictionary *stackModules = nil;

static id

GSLoadModule(NSString *fileName)

{

GSBinaryFileInfo *module = nil;

(void)pthread_mutex_lock(&modLock);

if (stackModules == nil)

{

NSEnumerator *enumerator;

NSBundle *bundle;

stackModules = [NSMutableDictionary new];

/*

[NSBundle mainBundle];

[NSBundle bundleForClass: [NSObject class]];

[NSBundle bundleForClass: NSClassFromString(@"NSView")];

/*

enumerator = [[NSBundle allBundles] objectEnumerator];

while ((bundle = [enumerator nextObject]) != nil)

{

if ([bundle load] == YES)

{

GSLoadModule([bundle executablePath]);

}

}

}

if ([fileName length] > 0)

{

module = [stackModules objectForKey: fileName];

if (module == nil)

{

module = [GSBinaryFileInfo infoWithBinaryFile: fileName];

if (module == nil)

{

module = (id)[NSNull null];

}

if ([stackModules objectForKey: fileName] == nil)

{

[stackModules setObject: module forKey: fileName];

}

else

{

module = [stackModules objectForKey: fileName];

}

}

}

(void)pthread_mutex_unlock(&modLock);

if (module == (id)[NSNull null])

{

module = nil;

}

return module;

}

static NSArray*

GSListModules()

{

NSArray *result;

GSLoadModule(nil); // initialise

(void)pthread_mutex_lock(&modLock);

result = [stackModules allValues];

(void)pthread_mutex_unlock(&modLock);

return result;

}

#endif /* USE_BFD */

#if defined(WITH_UNWIND) && !defined(HAVE_BACKTRACE)

#include <unwind.h>

#if !defined(_WIN32)

#include <dlfcn.h>

#endif

struct GSBacktraceState

{

void **current;

void **end;

};

static _Unwind_Reason_Code

GSUnwindCallback(struct _Unwind_Context* context, void* arg)

{

struct GSBacktraceState *state = (struct GSBacktraceState*)arg;

uintptr_t pc = _Unwind_GetIP(context);

if (pc) {

if (state->current == state->end) {

return _URC_END_OF_STACK;

} else {

*state->current++ = (void*)pc;

}

}

return 0; //_URC_OK/_URC_NO_REASON

}

#endif /* WITH_UNWIND && !HAVE_BACKTRACE */

#if defined(_WIN32) && !defined(USE_BFD)

typedef USHORT (WINAPI *CaptureStackBackTraceType)(ULONG,ULONG,PVOID*,PULONG);

typedef BOOL (WINAPI *SymInitializeType)(HANDLE,char*,BOOL);

typedef DWORD (WINAPI *SymSetOptionsType)(DWORD);

typedef BOOL (WINAPI *SymFromAddrType)(HANDLE,DWORD64,PDWORD64,SYMBOL_INFO*);

static CaptureStackBackTraceType capture = 0;

static SymInitializeType initSym = 0;

static SymSetOptionsType optSym = 0;

static SymFromAddrType fromSym = 0;

static HANDLE hProcess = 0;

static pthread_mutex_t traceLock;

#define MAXFRAMES 62 /* Limitation of windows-xp */

#else

#define MAXFRAMES 128 /* 1KB buffer on 64bit machine */

#endif

#if !defined(HAVE_BUILTIN_EXTRACT_RETURN_ADDRESS)

# define __builtin_extract_return_address(X) X

#endif

#define _NS_FRAME_HACK(a) \

case a: env->addr = __builtin_frame_address(a + 1); break;

#define _NS_RETURN_HACK(a) \

case a: env->addr = (__builtin_frame_address(a + 1) ? \

__builtin_extract_return_address(__builtin_return_address(a + 1)) : 0); break;

#if defined(HAVE_SYS_SIGNAL_H)

# include <sys/signal.h>

#elif defined(HAVE_SIGNAL_H)

# include <signal.h>

#endif

#if defined(_WIN32)

#ifndef SIGBUS

#define SIGBUS SIGILL

#endif

#endif

#if !defined(HAVE_SIGSETJMP) && !defined(sigsetjmp)

#define siglongjmp(A,B) longjmp(A,B)

#define sigsetjmp(A,B) setjmp(A)

#define sigjmp_buf jmp_buf

#endif

typedef struct {

sigjmp_buf buf;

void *addr;

void (*bus)(int);

void (*segv)(int);

} jbuf_type;

static jbuf_type *

jbuf()

{

NSMutableData *d;

NSMutableDictionary *dict;

dict = [[NSThread currentThread] threadDictionary];

d = [dict objectForKey: @"GSjbuf"];

if (d == nil)

{

d = [[NSMutableData alloc] initWithLength: sizeof(jbuf_type)];

[dict setObject: d forKey: @"GSjbuf"];

RELEASE(d);

}

return (jbuf_type*)[d mutableBytes];

}

static void

recover(int sig)

{

siglongjmp(jbuf()->buf, 1);

}

#ifdef __clang__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wframe-address"

#else

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wframe-address"

#endif

void *

NSFrameAddress(NSUInteger offset)

{

jbuf_type *env;

env = jbuf();

if (sigsetjmp(env->buf, 1) == 0)

{

env->segv = signal(SIGSEGV, recover);

env->bus = signal(SIGBUS, recover);

switch (offset)

{

_NS_FRAME_HACK(0); _NS_FRAME_HACK(1); _NS_FRAME_HACK(2);

_NS_FRAME_HACK(3); _NS_FRAME_HACK(4); _NS_FRAME_HACK(5);

_NS_FRAME_HACK(6); _NS_FRAME_HACK(7); _NS_FRAME_HACK(8);

_NS_FRAME_HACK(9); _NS_FRAME_HACK(10); _NS_FRAME_HACK(11);

_NS_FRAME_HACK(12); _NS_FRAME_HACK(13); _NS_FRAME_HACK(14);

_NS_FRAME_HACK(15); _NS_FRAME_HACK(16); _NS_FRAME_HACK(17);

_NS_FRAME_HACK(18); _NS_FRAME_HACK(19); _NS_FRAME_HACK(20);

_NS_FRAME_HACK(21); _NS_FRAME_HACK(22); _NS_FRAME_HACK(23);

_NS_FRAME_HACK(24); _NS_FRAME_HACK(25); _NS_FRAME_HACK(26);

_NS_FRAME_HACK(27); _NS_FRAME_HACK(28); _NS_FRAME_HACK(29);

_NS_FRAME_HACK(30); _NS_FRAME_HACK(31); _NS_FRAME_HACK(32);

_NS_FRAME_HACK(33); _NS_FRAME_HACK(34); _NS_FRAME_HACK(35);

_NS_FRAME_HACK(36); _NS_FRAME_HACK(37); _NS_FRAME_HACK(38);

_NS_FRAME_HACK(39); _NS_FRAME_HACK(40); _NS_FRAME_HACK(41);

_NS_FRAME_HACK(42); _NS_FRAME_HACK(43); _NS_FRAME_HACK(44);

_NS_FRAME_HACK(45); _NS_FRAME_HACK(46); _NS_FRAME_HACK(47);

_NS_FRAME_HACK(48); _NS_FRAME_HACK(49); _NS_FRAME_HACK(50);

_NS_FRAME_HACK(51); _NS_FRAME_HACK(52); _NS_FRAME_HACK(53);

_NS_FRAME_HACK(54); _NS_FRAME_HACK(55); _NS_FRAME_HACK(56);

_NS_FRAME_HACK(57); _NS_FRAME_HACK(58); _NS_FRAME_HACK(59);

_NS_FRAME_HACK(60); _NS_FRAME_HACK(61); _NS_FRAME_HACK(62);

_NS_FRAME_HACK(63); _NS_FRAME_HACK(64); _NS_FRAME_HACK(65);

_NS_FRAME_HACK(66); _NS_FRAME_HACK(67); _NS_FRAME_HACK(68);

_NS_FRAME_HACK(69); _NS_FRAME_HACK(70); _NS_FRAME_HACK(71);

_NS_FRAME_HACK(72); _NS_FRAME_HACK(73); _NS_FRAME_HACK(74);

_NS_FRAME_HACK(75); _NS_FRAME_HACK(76); _NS_FRAME_HACK(77);

_NS_FRAME_HACK(78); _NS_FRAME_HACK(79); _NS_FRAME_HACK(80);

_NS_FRAME_HACK(81); _NS_FRAME_HACK(82); _NS_FRAME_HACK(83);

_NS_FRAME_HACK(84); _NS_FRAME_HACK(85); _NS_FRAME_HACK(86);

_NS_FRAME_HACK(87); _NS_FRAME_HACK(88); _NS_FRAME_HACK(89);

_NS_FRAME_HACK(90); _NS_FRAME_HACK(91); _NS_FRAME_HACK(92);

_NS_FRAME_HACK(93); _NS_FRAME_HACK(94); _NS_FRAME_HACK(95);

_NS_FRAME_HACK(96); _NS_FRAME_HACK(97); _NS_FRAME_HACK(98);

_NS_FRAME_HACK(99);

default: env->addr = NULL; break;

}

signal(SIGSEGV, env->segv);

signal(SIGBUS, env->bus);

}

else

{

env = jbuf();

signal(SIGSEGV, env->segv);

signal(SIGBUS, env->bus);

env->addr = NULL;

}

return env->addr;

}

NSUInteger NSCountFrames(void)

{

jbuf_type *env;

env = jbuf();

if (sigsetjmp(env->buf, 1) == 0)

{

env->segv = signal(SIGSEGV, recover);

env->bus = signal(SIGBUS, recover);

env->addr = 0;

#define _NS_COUNT_HACK(X) if (__builtin_frame_address(X + 1) == 0) \

goto done; else env->addr = (void*)(X + 1);

_NS_COUNT_HACK(0); _NS_COUNT_HACK(1); _NS_COUNT_HACK(2);

_NS_COUNT_HACK(3); _NS_COUNT_HACK(4); _NS_COUNT_HACK(5);

_NS_COUNT_HACK(6); _NS_COUNT_HACK(7); _NS_COUNT_HACK(8);

_NS_COUNT_HACK(9); _NS_COUNT_HACK(10); _NS_COUNT_HACK(11);

_NS_COUNT_HACK(12); _NS_COUNT_HACK(13); _NS_COUNT_HACK(14);

_NS_COUNT_HACK(15); _NS_COUNT_HACK(16); _NS_COUNT_HACK(17);

_NS_COUNT_HACK(18); _NS_COUNT_HACK(19); _NS_COUNT_HACK(20);

_NS_COUNT_HACK(21); _NS_COUNT_HACK(22); _NS_COUNT_HACK(23);

_NS_COUNT_HACK(24); _NS_COUNT_HACK(25); _NS_COUNT_HACK(26);

_NS_COUNT_HACK(27); _NS_COUNT_HACK(28); _NS_COUNT_HACK(29);

_NS_COUNT_HACK(30); _NS_COUNT_HACK(31); _NS_COUNT_HACK(32);

_NS_COUNT_HACK(33); _NS_COUNT_HACK(34); _NS_COUNT_HACK(35);

_NS_COUNT_HACK(36); _NS_COUNT_HACK(37); _NS_COUNT_HACK(38);

_NS_COUNT_HACK(39); _NS_COUNT_HACK(40); _NS_COUNT_HACK(41);

_NS_COUNT_HACK(42); _NS_COUNT_HACK(43); _NS_COUNT_HACK(44);

_NS_COUNT_HACK(45); _NS_COUNT_HACK(46); _NS_COUNT_HACK(47);

_NS_COUNT_HACK(48); _NS_COUNT_HACK(49); _NS_COUNT_HACK(50);

_NS_COUNT_HACK(51); _NS_COUNT_HACK(52); _NS_COUNT_HACK(53);

_NS_COUNT_HACK(54); _NS_COUNT_HACK(55); _NS_COUNT_HACK(56);

_NS_COUNT_HACK(57); _NS_COUNT_HACK(58); _NS_COUNT_HACK(59);

_NS_COUNT_HACK(60); _NS_COUNT_HACK(61); _NS_COUNT_HACK(62);

_NS_COUNT_HACK(63); _NS_COUNT_HACK(64); _NS_COUNT_HACK(65);

_NS_COUNT_HACK(66); _NS_COUNT_HACK(67); _NS_COUNT_HACK(68);

_NS_COUNT_HACK(69); _NS_COUNT_HACK(70); _NS_COUNT_HACK(71);

_NS_COUNT_HACK(72); _NS_COUNT_HACK(73); _NS_COUNT_HACK(74);

_NS_COUNT_HACK(75); _NS_COUNT_HACK(76); _NS_COUNT_HACK(77);

_NS_COUNT_HACK(78); _NS_COUNT_HACK(79); _NS_COUNT_HACK(80);

_NS_COUNT_HACK(81); _NS_COUNT_HACK(82); _NS_COUNT_HACK(83);

_NS_COUNT_HACK(84); _NS_COUNT_HACK(85); _NS_COUNT_HACK(86);

_NS_COUNT_HACK(87); _NS_COUNT_HACK(88); _NS_COUNT_HACK(89);

_NS_COUNT_HACK(90); _NS_COUNT_HACK(91); _NS_COUNT_HACK(92);

_NS_COUNT_HACK(93); _NS_COUNT_HACK(94); _NS_COUNT_HACK(95);

_NS_COUNT_HACK(96); _NS_COUNT_HACK(97); _NS_COUNT_HACK(98);

_NS_COUNT_HACK(99);

done:

signal(SIGSEGV, env->segv);

signal(SIGBUS, env->bus);

}

else

{

env = jbuf();

signal(SIGSEGV, env->segv);

signal(SIGBUS, env->bus);

}

return (uintptr_t)env->addr;

}

void *

NSReturnAddress(NSUInteger offset)

{

jbuf_type *env;

env = jbuf();

if (sigsetjmp(env->buf, 1) == 0)

{

env->segv = signal(SIGSEGV, recover);

env->bus = signal(SIGBUS, recover);

switch (offset)

{

_NS_RETURN_HACK(0); _NS_RETURN_HACK(1); _NS_RETURN_HACK(2);

_NS_RETURN_HACK(3); _NS_RETURN_HACK(4); _NS_RETURN_HACK(5);

_NS_RETURN_HACK(6); _NS_RETURN_HACK(7); _NS_RETURN_HACK(8);

_NS_RETURN_HACK(9); _NS_RETURN_HACK(10); _NS_RETURN_HACK(11);

_NS_RETURN_HACK(12); _NS_RETURN_HACK(13); _NS_RETURN_HACK(14);

_NS_RETURN_HACK(15); _NS_RETURN_HACK(16); _NS_RETURN_HACK(17);

_NS_RETURN_HACK(18); _NS_RETURN_HACK(19); _NS_RETURN_HACK(20);

_NS_RETURN_HACK(21); _NS_RETURN_HACK(22); _NS_RETURN_HACK(23);

_NS_RETURN_HACK(24); _NS_RETURN_HACK(25); _NS_RETURN_HACK(26);

_NS_RETURN_HACK(27); _NS_RETURN_HACK(28); _NS_RETURN_HACK(29);

_NS_RETURN_HACK(30); _NS_RETURN_HACK(31); _NS_RETURN_HACK(32);

_NS_RETURN_HACK(33); _NS_RETURN_HACK(34); _NS_RETURN_HACK(35);

_NS_RETURN_HACK(36); _NS_RETURN_HACK(37); _NS_RETURN_HACK(38);

_NS_RETURN_HACK(39); _NS_RETURN_HACK(40); _NS_RETURN_HACK(41);

_NS_RETURN_HACK(42); _NS_RETURN_HACK(43); _NS_RETURN_HACK(44);

_NS_RETURN_HACK(45); _NS_RETURN_HACK(46); _NS_RETURN_HACK(47);

_NS_RETURN_HACK(48); _NS_RETURN_HACK(49); _NS_RETURN_HACK(50);

_NS_RETURN_HACK(51); _NS_RETURN_HACK(52); _NS_RETURN_HACK(53);

_NS_RETURN_HACK(54); _NS_RETURN_HACK(55); _NS_RETURN_HACK(56);

_NS_RETURN_HACK(57); _NS_RETURN_HACK(58); _NS_RETURN_HACK(59);

_NS_RETURN_HACK(60); _NS_RETURN_HACK(61); _NS_RETURN_HACK(62);

_NS_RETURN_HACK(63); _NS_RETURN_HACK(64); _NS_RETURN_HACK(65);

_NS_RETURN_HACK(66); _NS_RETURN_HACK(67); _NS_RETURN_HACK(68);

_NS_RETURN_HACK(69); _NS_RETURN_HACK(70); _NS_RETURN_HACK(71);

_NS_RETURN_HACK(72); _NS_RETURN_HACK(73); _NS_RETURN_HACK(74);

_NS_RETURN_HACK(75); _NS_RETURN_HACK(76); _NS_RETURN_HACK(77);

_NS_RETURN_HACK(78); _NS_RETURN_HACK(79); _NS_RETURN_HACK(80);

_NS_RETURN_HACK(81); _NS_RETURN_HACK(82); _NS_RETURN_HACK(83);

_NS_RETURN_HACK(84); _NS_RETURN_HACK(85); _NS_RETURN_HACK(86);

_NS_RETURN_HACK(87); _NS_RETURN_HACK(88); _NS_RETURN_HACK(89);

_NS_RETURN_HACK(90); _NS_RETURN_HACK(91); _NS_RETURN_HACK(92);

_NS_RETURN_HACK(93); _NS_RETURN_HACK(94); _NS_RETURN_HACK(95);

_NS_RETURN_HACK(96); _NS_RETURN_HACK(97); _NS_RETURN_HACK(98);

_NS_RETURN_HACK(99);

default: env->addr = NULL; break;

}

signal(SIGSEGV, env->segv);

signal(SIGBUS, env->bus);

}

else

{

env = jbuf();

signal(SIGSEGV, env->segv);

signal(SIGBUS, env->bus);

env->addr = NULL;

}

return env->addr;

}

#ifdef __clang__

#pragma clang diagnostic pop

#else

#pragma GCC diagnostic pop

#endif

GSPrivateReturnAddresses(NSUInteger **returns)

{

unsigned numReturns;

#if defined(_WIN32) && !defined(USE_BFD)

NSUInteger addr[MAXFRAMES];

(void)pthread_mutex_lock(&traceLock);

if (0 == hProcess)

{

hProcess = GetCurrentProcess();

if (0 == capture)

{

HANDLE hModule;

hModule = LoadLibrary("kernel32.dll");

if (0 == hModule)

{

fprintf(stderr, "Failed to load kernel32.dll with error: %d\n",

(int)GetLastError());

(void)pthread_mutex_unlock(&traceLock);

return 0;

}

capture = (CaptureStackBackTraceType)GetProcAddress(

hModule, "RtlCaptureStackBackTrace");

if (0 == capture)

{

fprintf(stderr, "Failed to find RtlCaptureStackBackTrace: %d\n",

(int)GetLastError());

(void)pthread_mutex_unlock(&traceLock);

return 0;

}

hModule = LoadLibrary("dbghelp.dll");

if (0 == hModule)

{

fprintf(stderr, "Failed to load dbghelp.dll with error: %d\n",

(int)GetLastError());

(void)pthread_mutex_unlock(&traceLock);

return 0;

}

optSym = (SymSetOptionsType)GetProcAddress(

hModule, "SymSetOptions");

if (0 == optSym)

{

fprintf(stderr, "Failed to find SymSetOptions: %d\n",

(int)GetLastError());

(void)pthread_mutex_unlock(&traceLock);

return 0;

}

initSym = (SymInitializeType)GetProcAddress(

hModule, "SymInitialize");

if (0 == initSym)

{

fprintf(stderr, "Failed to find SymInitialize: %d\n",

(int)GetLastError());

(void)pthread_mutex_unlock(&traceLock);

return 0;

}

fromSym = (SymFromAddrType)GetProcAddress(

hModule, "SymFromAddr");

if (0 == fromSym)

{

fprintf(stderr, "Failed to find SymFromAddr: %d\n",

(int)GetLastError());

(void)pthread_mutex_unlock(&traceLock);

return 0;

}

}

(optSym)(SYMOPT_UNDNAME | SYMOPT_DEFERRED_LOADS);

if (!(initSym)(hProcess, NULL, TRUE))

{

fprintf(stderr, "SymInitialize failed with error: %d\n",

(int)GetLastError());

fromSym = 0;

(void)pthread_mutex_unlock(&traceLock);

return 0;

}

}

if (0 == capture)

{

(void)pthread_mutex_unlock(&traceLock);

return 0;

}

numReturns = (capture)(0, MAXFRAMES, (void**)addr, NULL);

if (numReturns > 0)

{

*returns = malloc(numReturns * sizeof(void*));

memcpy(*returns, addr, numReturns * sizeof(void*));

}

(void)pthread_mutex_unlock(&traceLock);

#elif defined(HAVE_BACKTRACE)

void *addr[MAXFRAMES*sizeof(void*)];

numReturns = backtrace(addr, MAXFRAMES);

if (numReturns > 0)

{

*returns = malloc(numReturns * sizeof(void*));