[apple/dyld.git] / src / dyldExceptions.c

/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
 *
 * Copyright (c) 2004-2008 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */

#include <stdlib.h>
#include <string.h>
#include <mach-o/loader.h>
#include <unistd.h>
#include <stdio.h>
#include <stdbool.h>
#include <stdarg.h>
#include <pthread.h>

#include "mach-o/dyld_priv.h"
#include "dyldLibSystemInterface.h"

extern void _ZN4dyld3logEPKcz(const char*, ...);
extern struct LibSystemHelpers* _ZN4dyld17gLibSystemHelpersE;


#if __LP64__
        #define LC_SEGMENT_COMMAND              LC_SEGMENT_64
        #define macho_header                    mach_header_64
        #define macho_segment_command   segment_command_64
        #define macho_section                   section_64
        #define getsectdatafromheader   getsectdatafromheader_64
#else
        #define LC_SEGMENT_COMMAND              LC_SEGMENT
        #define macho_header                    mach_header
        #define macho_segment_command   segment_command
        #define macho_section                   section
#endif


#if __i386__ || __x86_64 || __ppc__

static struct dyld_unwind_sections      sDyldInfo;
static void*                                            sDyldTextEnd;
static pthread_key_t                            sCxaKey = 0;
static char                                                     sPreMainCxaGlobals[2*sizeof(long)];

// called by dyldStartup.s very early
void dyld_exceptions_init(struct mach_header* mh, intptr_t slide)
{
        // record location of unwind sections in dyld itself
    sDyldInfo.mh = mh;    
        const struct load_command* cmd;
        unsigned long i;
        cmd = (struct load_command*) ((char *)mh + sizeof(struct macho_header));
        for(i = 0; i < mh->ncmds; i++) {
            if ( cmd->cmd == LC_SEGMENT_COMMAND ) {
                        const struct macho_segment_command* seg = (struct macho_segment_command*)cmd;
                        if ( strcmp(seg->segname, "__TEXT") == 0 ) {
                                const struct macho_section* sect = (struct macho_section*)( (char*)seg + sizeof(struct macho_segment_command) );
                                unsigned long j;
                                for (j = 0; j < seg->nsects; j++) {
                                        if ( strcmp(sect[j].sectname, "__eh_frame") == 0 ) {
                                                sDyldInfo.dwarf_section = (void*)(sect[j].addr + slide);
                                                sDyldInfo.dwarf_section_length = sect[j].size;
                                        }
                                        else if ( strcmp(sect[j].sectname, "__unwind_info") == 0 ) {
                                                sDyldInfo.compact_unwind_section = (void*)(sect[j].addr + slide);
                                                sDyldInfo.compact_unwind_section_length = sect[j].size;
                                        }
                                }
                                sDyldTextEnd = (void*)(seg->vmaddr + seg->vmsize + slide);
                    }
                }
            cmd = (struct load_command*)( (char*)cmd + cmd->cmdsize );
        }
}

// called by libuwind code to find unwind information in dyld
bool _dyld_find_unwind_sections(void* addr, struct dyld_unwind_sections* info)
{
        if ( ((void*)sDyldInfo.mh < addr) && (addr < sDyldTextEnd) ) { 
                *info = sDyldInfo;
                return true;
        }
        else {
                return false;
        }
}



// called by libstdc++.a 
char* __cxa_get_globals() 
{       
        // if libSystem.dylib not yet initialized, or is old libSystem, use shared global
        if ( (_ZN4dyld17gLibSystemHelpersE == NULL) || (_ZN4dyld17gLibSystemHelpersE->version < 5) )
                return sPreMainCxaGlobals;

        if ( sCxaKey == 0 ) {
                // create key
                // we don't need a lock because only one thread can be in dyld at a time
                _ZN4dyld17gLibSystemHelpersE->pthread_key_create(&sCxaKey, &free);
        }
        char* data = (char*)pthread_getspecific(sCxaKey);
        if ( data == NULL ) {
                data = calloc(2,sizeof(void*));
                _ZN4dyld17gLibSystemHelpersE->pthread_setspecific(sCxaKey, data);
        }
        return data; 
}

// called by libstdc++.a 
char* __cxa_get_globals_fast() 
{ 
        // if libSystem.dylib not yet initialized, or is old libSystem, use shared global
        if ( (_ZN4dyld17gLibSystemHelpersE == NULL) || (_ZN4dyld17gLibSystemHelpersE->version < 5) )
                return sPreMainCxaGlobals;

        return pthread_getspecific(sCxaKey); 
}

#if __ppc__
        // the ppc version of _Znwm in libstdc++.a uses keymgr
        // need to override that
        void* _Znwm(size_t size) { return malloc(size); }
#endif





#else /*  __i386__ || __x86_64 || __ppc__ */






//
// BEGIN copy of code from libgcc.a source file unwind-dw2-fde-darwin.c
//
#define KEYMGR_API_MAJOR_GCC3           3       
/* ... with these keys.  */
#define KEYMGR_GCC3_LIVE_IMAGE_LIST     301     /* loaded images  */
#define KEYMGR_GCC3_DW2_OBJ_LIST        302     /* Dwarf2 object list  */   
#define KEYMGR_EH_GLOBALS_KEY           13 

/* Node of KEYMGR_GCC3_LIVE_IMAGE_LIST.  Info about each resident image.  */
struct live_images {
  unsigned long this_size;                      /* sizeof (live_images)  */
  struct mach_header *mh;                       /* the image info  */
  unsigned long vm_slide;
  void (*destructor)(struct live_images *);     /* destructor for this  */
  struct live_images *next;
  unsigned int examined_p;
  void *fde;
  void *object_info;
  unsigned long info[2];                        /* Future use.  */
};
//
// END copy of code from libgcc.a source file unwind-dw2-fde-darwin.c
//


//
// dyld is built as stand alone executable with a static copy of libc, libstdc++, and libgcc.
//
// In order for C++ exceptions to work within dyld, the C++ exception handling code
// must be able to find the exception handling frame data inside dyld.  The standard
// exception handling code uses crt and keymgr to keep track of all images and calls
// getsectdatafromheader("__eh_frame") to find the EH data for each image. We implement
// our own copy of those functions below to enable exceptions within dyld.
//
// Note: This exception handling is completely separate from any user code exception .
//               handling which has its own keymgr (in libSystem).
// 


static struct live_images   sDyldImage;  // zero filled
static void*                            sObjectList = NULL;
#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ >= 4))
static void*                            sEHGlobals = NULL;
#endif


// called by dyldStartup.s very early
void dyld_exceptions_init(struct mach_header *mh, uintptr_t slide)
{
        sDyldImage.this_size = sizeof(struct live_images);
        sDyldImage.mh = mh;
        sDyldImage.vm_slide = slide;
}



//  Hack for gcc 3.5's use of keymgr includes accessing __keymgr_global
#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ >= 4))
typedef struct Sinfo_Node {
  uint32_t size;                /* Size of this node.  */
  uint16_t major_version; /* API major version.  */
  uint16_t minor_version;       /* API minor version.  */
} Tinfo_Node;
static const Tinfo_Node keymgr_info = { sizeof (Tinfo_Node), KEYMGR_API_MAJOR_GCC3, 0 };
const Tinfo_Node* __keymgr_global[3] = { NULL, NULL, &keymgr_info };
#endif

static __attribute__((noreturn)) 
void dyld_abort() 
{
        //dyld::log("internal dyld error\n");
        _exit(1);
}

void* _keymgr_get_and_lock_processwide_ptr(unsigned int key)
{
        // The C++ exception handling code uses two keys. No other keys should be seen
        if ( key == KEYMGR_GCC3_LIVE_IMAGE_LIST ) {
                return &sDyldImage;
        }
        else if ( key == KEYMGR_GCC3_DW2_OBJ_LIST ) {
                return sObjectList;
        }
        dyld_abort();
}

void _keymgr_set_and_unlock_processwide_ptr(unsigned int key, void* value)
{
        // The C++ exception handling code uses just this key. No other keys should be seen
        if ( key == KEYMGR_GCC3_DW2_OBJ_LIST ) {
                sObjectList = value;
                return;
        }
        dyld_abort();
}

void _keymgr_unlock_processwide_ptr(unsigned int key)
{
        // The C++ exception handling code uses just this key. No other keys should be seen
        if ( key == KEYMGR_GCC3_LIVE_IMAGE_LIST ) {
                return;
        }
        dyld_abort();
}
        
void* _keymgr_get_per_thread_data(unsigned int key)
{
#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ >= 4))
        // gcc 3.5 and later use this key
        if ( key == KEYMGR_EH_GLOBALS_KEY )
                return sEHGlobals;
#endif

        // used by std::termination which dyld does not use
        dyld_abort();
}

void _keymgr_set_per_thread_data(unsigned int key, void *keydata)
{
#if defined(__GNUC__) && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 5)) || (__GNUC__ >= 4))
        // gcc 3.5 and later use this key
        if ( key == KEYMGR_EH_GLOBALS_KEY ) {
                sEHGlobals = keydata;
                return;
        }
#endif
        // used by std::termination which dyld does not use
        dyld_abort();
}


// needed by C++ exception handling code to find __eh_frame section
const void* getsectdatafromheader(struct mach_header* mh, const char* segname, const char* sectname, unsigned long* size)
{
        const struct load_command* cmd;
        unsigned long i;
        
        cmd = (struct load_command*) ((char *)mh + sizeof(struct macho_header));
        for(i = 0; i < mh->ncmds; i++) {
            if ( cmd->cmd == LC_SEGMENT_COMMAND ) {
                        const struct macho_segment_command* seg = (struct macho_segment_command*)cmd;
                        if ( strcmp(seg->segname, segname) == 0 ) {
                                const struct macho_section* sect = (struct macho_section*)( (char*)seg + sizeof(struct macho_segment_command) );
                                unsigned long j;
                                for (j = 0; j < seg->nsects; j++) {
                                        if ( strcmp(sect[j].sectname, sectname) == 0 ) {
                                                *size = sect[j].size;
                                                return (void*)(sect[j].addr);
                                        }
                                }
                    }
                }
            cmd = (struct load_command*)( (char*)cmd + cmd->cmdsize );
        }
        return NULL;
}


// Hack for transition of rdar://problem/3933738
// Can be removed later.
// Allow C++ runtime to call getsectdatafromheader or getsectdatafromheader_64
#if __LP64__
        #undef getsectdatafromheader
        const void* getsectdatafromheader(struct mach_header* mh, const char* segname, const char* sectname, unsigned long* size)
        {
                return getsectdatafromheader_64(mh, segname, sectname, size);
        }
#endif

#endif