dyld/src/glue.c

   1 /* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
   2  *
   3  * Copyright (c) 2004-2010 Apple Inc. All rights reserved.
   4  *
   5  * @APPLE_LICENSE_HEADER_START@
   6  *
   7  * This file contains Original Code and/or Modifications of Original Code
   8  * as defined in and that are subject to the Apple Public Source License
   9  * Version 2.0 (the 'License'). You may not use this file except in
  10  * compliance with the License. Please obtain a copy of the License at
  11  * http://www.opensource.apple.com/apsl/ and read it before using this
  12  * file.
  13  *
  14  * The Original Code and all software distributed under the License are
  15  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  16  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  17  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  19  * Please see the License for the specific language governing rights and
  20  * limitations under the License.
  21  *
  22  * @APPLE_LICENSE_HEADER_END@
  23  */
  24
  25 #include <stddef.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <stdint.h>
  29 #include <time.h>
  30 #include <unistd.h>
  31 #include <stdarg.h>
  32 #include <stdio.h>
  33 #include <mach/mach_error.h>
  34
  35 // from _simple.h in libc
  36 typedef struct _SIMPLE* _SIMPLE_STRING;
  37 extern void                             _simple_vdprintf(int __fd, const char *__fmt, va_list __ap);
  38 extern void                             _simple_dprintf(int __fd, const char *__fmt, ...);
  39 extern _SIMPLE_STRING   _simple_salloc(void);
  40 extern int                              _simple_vsprintf(_SIMPLE_STRING __b, const char *__fmt, va_list __ap);
  41 extern void                             _simple_sfree(_SIMPLE_STRING __b);
  42 extern char *                   _simple_string(_SIMPLE_STRING __b);
  43
  44 // dyld::log(const char* format, ...)
  45 extern void _ZN4dyld3logEPKcz(const char*, ...);
  46
  47 // dyld::halt(const char* msg);
  48 extern void _ZN4dyld4haltEPKc(const char* msg) __attribute__((noreturn));
  49
  50
  51 // abort called by C++ unwinding code
  52 void abort()
  53 {
  54         _ZN4dyld4haltEPKc("dyld calling abort()\n");
  55 }
  56
  57 // std::terminate called by C++ unwinding code
  58 void _ZSt9terminatev()
  59 {
  60         _ZN4dyld4haltEPKc("dyld std::terminate()\n");
  61 }
  62
  63 // std::unexpected called by C++ unwinding code
  64 void _ZSt10unexpectedv()
  65 {
  66         _ZN4dyld4haltEPKc("dyld std::unexpected()\n");
  67 }
  68
  69 // __cxxabiv1::__terminate(void (*)()) called to terminate process
  70 void _ZN10__cxxabiv111__terminateEPFvvE()
  71 {
  72         _ZN4dyld4haltEPKc("dyld std::__terminate()\n");
  73 }
  74
  75 // __cxxabiv1::__unexpected(void (*)()) called to terminate process
  76 void _ZN10__cxxabiv112__unexpectedEPFvvE()
  77 {
  78         _ZN4dyld4haltEPKc("dyld std::__unexpected()\n");
  79 }
  80
  81 // __cxxabiv1::__terminate_handler
  82 void* _ZN10__cxxabiv119__terminate_handlerE  = &_ZSt9terminatev;
  83
  84 // __cxxabiv1::__unexpected_handler
  85 void* _ZN10__cxxabiv120__unexpected_handlerE = &_ZSt10unexpectedv;
  86
  87 // libc uses assert()
  88 void __assert_rtn(const char* func, const char* file, int line, const char* failedexpr)
  89 {
  90         if (func == NULL)
  91                 _ZN4dyld3logEPKcz("Assertion failed: (%s), file %s, line %d.\n", failedexpr, file, line);
  92         else
  93                 _ZN4dyld3logEPKcz("Assertion failed: (%s), function %s, file %s, line %d.\n", failedexpr, func, file, line);
  94         abort();
  95 }
  96
  97
  98 // called by libuwind code before aborting
  99 size_t fwrite(const void* ptr, size_t size, size_t nitme, FILE* stream)
 100 {
 101         return fprintf(stream, "%s", (char*)ptr);
 102 }
 103
 104 // called by libuwind code before aborting
 105 int     fprintf(FILE* file, const char* format, ...)
 106 {
 107         va_list list;
 108         va_start(list, format);
 109         _simple_vdprintf(STDERR_FILENO, format, list);
 110         va_end(list);
 111         return 0;
 112 }
 113
 114 // called by LIBC_ABORT
 115 void abort_report_np(const char* format, ...)
 116 {
 117         va_list list;
 118         const char *str;
 119         _SIMPLE_STRING s = _simple_salloc();
 120         if ( s != NULL ) {
 121                 va_start(list, format);
 122                 _simple_vsprintf(s, format, list);
 123                 va_end(list);
 124                 str = _simple_string(s);
 125         }
 126         else {
 127                 // _simple_salloc failed, but at least format may have useful info by itself
 128                 str = format;
 129         }
 130         _ZN4dyld4haltEPKc(str);
 131         // _ZN4dyld4haltEPKc doesn't return, so we can't call _simple_sfree
 132 }
 133
 134
 135 // real cthread_set_errno_self() has error handling that pulls in
 136 // pthread_exit() which pulls in fprintf()
 137 extern int* __error(void);
 138 void cthread_set_errno_self(int err)
 139 {
 140         int* ep = __error();
 141      *ep = err;
 142 }
 143
 144 /*
 145  * We have our own localtime() to avoid needing the notify API which is used
 146  * by the code in libc.a for localtime() which is used by arc4random().
 147  */
 148 struct tm* localtime(const time_t* t)
 149 {
 150         return (struct tm*)NULL;
 151 }
 152
 153 // malloc calls exit(-1) in case of errors...
 154 void exit(int x)
 155 {
 156         _ZN4dyld4haltEPKc("exit()");
 157 }
 158
 159 // static initializers make calls to __cxa_atexit
 160 void __cxa_atexit()
 161 {
 162         // do nothing, dyld never terminates
 163 }
 164
 165 //
 166 // The stack protector routines in lib.c bring in too much stuff, so
 167 // make our own custom ones.
 168 //
 169 long __stack_chk_guard = 0;
 170 static __attribute__((constructor))
 171 void __guard_setup(int argc, const char* argv[], const char* envp[], const char* apple[])
 172 {
 173         for (const char** p = apple; *p != NULL; ++p) {
 174                 if ( strncmp(*p, "stack_guard=", 12) == 0 ) {
 175                         // kernel has provide a random value for us
 176                         for (const char* s = *p + 12; *s != '\0'; ++s) {
 177                                 char c = *s;
 178                                 long value = 0;
 179                                 if ( (c >= 'a') && (c <= 'f') )
 180                                         value = c - 'a' + 10;
 181                                 else if ( (c >= 'A') && (c <= 'F') )
 182                                         value = c - 'A' + 10;
 183                                 else if ( (c >= '0') && (c <= '9') )
 184                                         value = c - '0';
 185                                 __stack_chk_guard <<= 4;
 186                                 __stack_chk_guard |= value;
 187                         }
 188                         if ( __stack_chk_guard != 0 )
 189                                 return;
 190                 }
 191         }
 192
 193 #if __LP64__
 194         __stack_chk_guard = ((long)arc4random() << 32) | arc4random();
 195 #else
 196         __stack_chk_guard = arc4random();
 197 #endif
 198 }
 199 extern void _ZN4dyld4haltEPKc(const char*);
 200 void __stack_chk_fail()
 201 {
 202         _ZN4dyld4haltEPKc("stack buffer overrun");
 203 }
 204
 205
 206 // std::_throw_bad_alloc()
 207 void _ZSt17__throw_bad_allocv()
 208 {
 209         _ZN4dyld4haltEPKc("__throw_bad_alloc()");
 210 }
 211
 212 // std::_throw_length_error(const char* x)
 213 void _ZSt20__throw_length_errorPKc()
 214 {
 215         _ZN4dyld4haltEPKc("_throw_length_error()");
 216 }
 217
 218 // the libc.a version of this drags in ASL
 219 void __chk_fail()
 220 {
 221         _ZN4dyld4haltEPKc("__chk_fail()");
 222 }
 223
 224
 225 // referenced by libc.a(pthread.o) but unneeded in dyld
 226 void _init_cpu_capabilities() { }
 227 void _cpu_capabilities() {}
 228 void set_malloc_singlethreaded() {}
 229 int PR_5243343_flag = 0;
 230
 231
 232 // used by some pthread routines
 233 char* mach_error_string(mach_error_t err)
 234 {
 235         return (char *)"unknown error code";
 236 }
 237 char* mach_error_type(mach_error_t err)
 238 {
 239         return (char *)"(unknown/unknown)";
 240 }
 241
 242 // _pthread_reap_thread calls fprintf(stderr).
 243 // We map fprint to _simple_vdprintf and ignore FILE* stream, so ok for it to be NULL
 244 FILE* __stderrp = NULL;
 245 FILE* __stdoutp = NULL;
 246
 247 // work with c++abi.a
 248 void (*__cxa_terminate_handler)() = _ZSt9terminatev;
 249 void (*__cxa_unexpected_handler)() = _ZSt10unexpectedv;
 250
 251 void abort_message(const char* format, ...)
 252 {
 253         va_list list;
 254         va_start(list, format);
 255         _simple_vdprintf(STDERR_FILENO, format, list);
 256         va_end(list);
 257 }
 258
 259 void __cxa_bad_typeid()
 260 {
 261         _ZN4dyld4haltEPKc("__cxa_bad_typeid()");
 262 }
 263
 264 // to work with libc++
 265 void _ZNKSt3__120__vector_base_commonILb1EE20__throw_length_errorEv()
 266 {
 267         _ZN4dyld4haltEPKc("std::vector<>::_throw_length_error()");
 268 }
 269
 270 // libc.a sometimes missing memset
 271 #undef memset
 272 void* memset(void* b, int c, size_t len)
 273 {
 274         uint8_t* p = (uint8_t*)b;
 275         for(size_t i=len; i > 0; --i)
 276                 *p++ = c;
 277         return b;
 278 }
 279