#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <time.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdarg.h>
#include <stdio.h>
#include <mach/mach.h>
#include <mach/mach_time.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <TargetConditionals.h>
#include <libkern/OSAtomic.h>
#include <errno.h>
#include <pthread.h>
#if TARGET_IPHONE_SIMULATOR
#include "dyldSyscallInterface.h"
#endif
typedef struct _SIMPLE* _SIMPLE_STRING;
extern void _simple_vdprintf(int __fd, const char *__fmt, va_list __ap);
extern void _simple_dprintf(int __fd, const char *__fmt, ...);
extern _SIMPLE_STRING _simple_salloc(void);
extern int _simple_vsprintf(_SIMPLE_STRING __b, const char *__fmt, va_list __ap);
extern void _simple_sfree(_SIMPLE_STRING __b);
extern char * _simple_string(_SIMPLE_STRING __b);
extern void _ZN4dyld3logEPKcz(const char*, ...);
extern void _ZN4dyld4haltEPKc(const char* msg) __attribute__((noreturn));
void abort()
{
_ZN4dyld4haltEPKc("dyld calling abort()\n");
}
void _ZSt9terminatev()
{
_ZN4dyld4haltEPKc("dyld std::terminate()\n");
}
void _ZSt10unexpectedv()
{
_ZN4dyld4haltEPKc("dyld std::unexpected()\n");
}
void _ZN10__cxxabiv111__terminateEPFvvE()
{
_ZN4dyld4haltEPKc("dyld std::__terminate()\n");
}
void _ZN10__cxxabiv112__unexpectedEPFvvE()
{
_ZN4dyld4haltEPKc("dyld std::__unexpected()\n");
}
void* _ZN10__cxxabiv119__terminate_handlerE = &_ZSt9terminatev;
void* _ZN10__cxxabiv120__unexpected_handlerE = &_ZSt10unexpectedv;
void __assert_rtn(const char* func, const char* file, int line, const char* failedexpr)
{
if (func == NULL)
_ZN4dyld3logEPKcz("Assertion failed: (%s), file %s, line %d.\n", failedexpr, file, line);
else
_ZN4dyld3logEPKcz("Assertion failed: (%s), function %s, file %s, line %d.\n", failedexpr, func, file, line);
abort();
}
size_t fwrite(const void* ptr, size_t size, size_t nitme, FILE* stream)
{
return fprintf(stream, "%s", (char*)ptr);
}
int fprintf(FILE* file, const char* format, ...)
{
va_list list;
va_start(list, format);
_simple_vdprintf(STDERR_FILENO, format, list);
va_end(list);
return 0;
}
void abort_report_np(const char* format, ...)
{
va_list list;
const char *str;
_SIMPLE_STRING s = _simple_salloc();
if ( s != NULL ) {
va_start(list, format);
_simple_vsprintf(s, format, list);
va_end(list);
str = _simple_string(s);
}
else {
str = format;
}
_ZN4dyld4haltEPKc(str);
}
extern int* __error(void);
void cthread_set_errno_self(int err)
{
int* ep = __error();
*ep = err;
}
struct tm* localtime(const time_t* t)
{
return (struct tm*)NULL;
}
void exit(int x)
{
_ZN4dyld4haltEPKc("exit()");
}
void __cxa_atexit()
{
}
long __stack_chk_guard = 0;
void __guard_setup(const char* apple[])
{
for (const char** p = apple; *p != NULL; ++p) {
if ( strncmp(*p, "stack_guard=", 12) == 0 ) {
for (const char* s = *p + 12; *s != '\0'; ++s) {
char c = *s;
long value = 0;
if ( (c >= 'a') && (c <= 'f') )
value = c - 'a' + 10;
else if ( (c >= 'A') && (c <= 'F') )
value = c - 'A' + 10;
else if ( (c >= '0') && (c <= '9') )
value = c - '0';
__stack_chk_guard <<= 4;
__stack_chk_guard |= value;
}
if ( __stack_chk_guard != 0 )
return;
}
}
#if !TARGET_IPHONE_SIMULATOR
#if __LP64__
__stack_chk_guard = ((long)arc4random() << 32) | arc4random();
#else
__stack_chk_guard = arc4random();
#endif
#endif
}
extern void _ZN4dyld4haltEPKc(const char*);
void __stack_chk_fail()
{
_ZN4dyld4haltEPKc("stack buffer overrun");
}
void _ZSt17__throw_bad_allocv()
{
_ZN4dyld4haltEPKc("__throw_bad_alloc()");
}
void _ZSt20__throw_length_errorPKc()
{
_ZN4dyld4haltEPKc("_throw_length_error()");
}
void __chk_fail()
{
_ZN4dyld4haltEPKc("__chk_fail()");
}
void _init_cpu_capabilities() { }
void _cpu_capabilities() {}
void set_malloc_singlethreaded() {}
int PR_5243343_flag = 0;
char* mach_error_string(mach_error_t err)
{
return (char *)"unknown error code";
}
char* mach_error_type(mach_error_t err)
{
return (char *)"(unknown/unknown)";
}
FILE* __stderrp = NULL;
FILE* __stdoutp = NULL;
void (*__cxa_terminate_handler)() = _ZSt9terminatev;
void (*__cxa_unexpected_handler)() = _ZSt10unexpectedv;
void abort_message(const char* format, ...)
{
va_list list;
va_start(list, format);
_simple_vdprintf(STDERR_FILENO, format, list);
va_end(list);
}
void __cxa_bad_typeid()
{
_ZN4dyld4haltEPKc("__cxa_bad_typeid()");
}
void _ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv()
{
_ZN4dyld4haltEPKc("std::vector<>::_throw_length_error()");
}
#undef memset
void* memset(void* b, int c, size_t len)
{
uint8_t* p = (uint8_t*)b;
for(size_t i=len; i > 0; --i)
*p++ = c;
return b;
}
int _ZN4dyld7my_statEPKcP4stat(const char* path, struct stat* buf)
{
int result;
do {
result = stat(path, buf);
} while ((result == -1) && (errno == EAGAIN));
return result;
}
int _ZN4dyld7my_openEPKcii(const char* path, int flag, int other)
{
int result;
do {
result = open(path, flag, other);
} while ((result == -1) && (errno == EAGAIN));
return result;
}
#if TARGET_IPHONE_SIMULATOR
int myopen(const char* path, int oflag, int extra) __asm("_open");
int myopen(const char* path, int oflag, int extra) {
return gSyscallHelpers->open(path, oflag, extra);
}
int close(int fd) {
return gSyscallHelpers->close(fd);
}
ssize_t pread(int fd, void* buf, size_t nbytes, off_t offset) {
return gSyscallHelpers->pread(fd, buf , nbytes, offset);
}
ssize_t write(int fd, const void *buf, size_t nbytes) {
return gSyscallHelpers->write(fd, buf , nbytes);
}
void* mmap(void* addr, size_t len, int prot, int flags, int fd, off_t offset) {
return gSyscallHelpers->mmap(addr, len, prot, flags, fd, offset);
}
int munmap(void* addr, size_t len) {
return gSyscallHelpers->munmap(addr, len);
}
int madvise(void* addr, size_t len, int advice) {
return gSyscallHelpers->madvise(addr, len, advice);
}
int stat(const char* path, struct stat* buf) {
return gSyscallHelpers->stat(path, buf);
}
int myfcntl(int fd, int cmd, void* result) __asm("_fcntl");
int myfcntl(int fd, int cmd, void* result) {
return gSyscallHelpers->fcntl(fd, cmd, result);
}
int myioctl(int fd, unsigned long request, void* result) __asm("_ioctl");
int myioctl(int fd, unsigned long request, void* result) {
return gSyscallHelpers->ioctl(fd, request, result);
}
int issetugid() {
return gSyscallHelpers->issetugid();
}
char* getcwd(char* buf, size_t size) {
return gSyscallHelpers->getcwd(buf, size);
}
char* realpath(const char* file_name, char* resolved_name) {
return gSyscallHelpers->realpath(file_name, resolved_name);
}
kern_return_t vm_allocate(vm_map_t target_task, vm_address_t *address,
vm_size_t size, int flags) {
return gSyscallHelpers->vm_allocate(target_task, address, size, flags);
}
kern_return_t vm_deallocate(vm_map_t target_task, vm_address_t address,
vm_size_t size) {
return gSyscallHelpers->vm_deallocate(target_task, address, size);
}
kern_return_t vm_protect(vm_map_t target_task, vm_address_t address,
vm_size_t size, boolean_t max, vm_prot_t prot) {
return gSyscallHelpers->vm_protect(target_task, address, size, max, prot);
}
void _ZN4dyld3logEPKcz(const char* format, ...) {
va_list list;
va_start(list, format);
gSyscallHelpers->vlog(format, list);
va_end(list);
}
void _ZN4dyld4warnEPKcz(const char* format, ...) {
va_list list;
va_start(list, format);
gSyscallHelpers->vwarn(format, list);
va_end(list);
}
int pthread_mutex_lock(pthread_mutex_t* m) {
return gSyscallHelpers->pthread_mutex_lock(m);
}
int pthread_mutex_unlock(pthread_mutex_t* m) {
return gSyscallHelpers->pthread_mutex_unlock(m);
}
mach_port_t mach_thread_self() {
return gSyscallHelpers->mach_thread_self();
}
kern_return_t mach_port_deallocate(ipc_space_t task, mach_port_name_t name) {
return gSyscallHelpers->mach_port_deallocate(task, name);
}
mach_port_name_t task_self_trap() {
return gSyscallHelpers->task_self_trap();
}
kern_return_t mach_timebase_info(mach_timebase_info_t info) {
return gSyscallHelpers->mach_timebase_info(info);
}
bool OSAtomicCompareAndSwapPtrBarrier(void* old, void* new, void * volatile *value) {
return gSyscallHelpers->OSAtomicCompareAndSwapPtrBarrier(old, new, value);
}
void OSMemoryBarrier() {
return gSyscallHelpers->OSMemoryBarrier();
}
uint64_t mach_absolute_time(void) {
return gSyscallHelpers->mach_absolute_time();
}
int* __error(void) {
return gSyscallHelpers->errnoAddress();
}
void mach_init() {
mach_task_self_ = task_self_trap();
}
mach_port_t mach_task_self_ = MACH_PORT_NULL;
extern int myerrno_fallback __asm("_errno");
int myerrno_fallback = 0;
#endif // TARGET_IPHONE_SIMULATOR