FreeBSD/Linux Kernel Cross Reference
sys/libkern/kxld/kxld_state.c

     /*
      * Copyright (c) 2008 Apple Inc. All rights reserved.
      *
      * @APPLE_OSREFERENCE_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. The rights granted to you under the License
     * may not be used to create, or enable the creation or redistribution of,
     * unlawful or unlicensed copies of an Apple operating system, or to
     * circumvent, violate, or enable the circumvention or violation of, any
     * terms of an Apple operating system software license agreement.
     * 
     * 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_OSREFERENCE_LICENSE_HEADER_END@
     */
    #include <string.h>
    
    #if !KERNEL
        #include <libkern/OSByteOrder.h>
    #endif
    
    #define DEBUG_ASSERT_COMPONENT_NAME_STRING "kxld"
    #include <AssertMacros.h>
    
    #include "kxld_array.h"
    #include "kxld_dict.h"
    #include "kxld_kext.h"
    #include "kxld_state.h"
    #include "kxld_sym.h"
    #include "kxld_symtab.h"
    #include "kxld_util.h"
    #include "kxld_vtable.h"
    
    #define LINK_STATE_MAGIC 0xF00DD00D
    #define CIGAM_ETATS_KNIL 0x0DD00DF0
    
    #define LINK_STATE_MAGIC_64 0xCAFEF00D
    #define CIGAM_ETATS_KNIL_64 0x0DF0FECA
    
    #define LINK_STATE_VERSION 1
    
    static kern_return_t init_string_index(KXLDDict *strings, KXLDArray *tmps, 
        KXLDSymtabIterator *iter, const KXLDArray *vtables, u_int nsymentries, 
        u_long *strsize);
    static kern_return_t add_string_to_index(KXLDDict *strings, const char *str, 
        KXLDArray *tmps, u_int *tmpi, u_long *stroff);
    static kern_return_t create_link_state(u_char **_file, u_long *_filesize, 
        const KXLDKext *kext,  KXLDSymtabIterator *iter, const KXLDArray *vtables, 
        KXLDDict *strings, u_int nsyms, u_int nsymentries, u_long strsize);
    static boolean_t state_is_32_bit(KXLDLinkStateHdr *state);
    
    #if KXLD_USER_OR_ILP32
    static kern_return_t get_symbols_32(KXLDState *state, KXLDDict *defined_symbols,
        KXLDDict *obsolete_symbols);
    static kern_return_t copy_symbols_32(u_char *file, u_long *data_offset, 
        KXLDSymtabIterator *iter, const KXLDDict *strings);
    static kern_return_t copy_vtables_32(u_char *file, u_long *header_offset, 
        u_long *data_offset, const KXLDArray *vtables, const KXLDDict *strings);
    #endif /* KXLD_USER_OR_ILP32*/
    #if KXLD_USER_OR_LP64
    static kern_return_t get_symbols_64(KXLDState *state, KXLDDict *defined_symbols,
        KXLDDict *obsolete_symbols);
    static kern_return_t copy_symbols_64(u_char *file, u_long *data_offset, 
        KXLDSymtabIterator *iter, const KXLDDict *strings);
    static kern_return_t copy_vtables_64(u_char *file, u_long *header_offset, 
        u_long *data_offset, const KXLDArray *vtables, const KXLDDict *strings);
    #endif /* KXLD_USER_OR_ILP64 */
    
    #if !KERNEL
    static boolean_t swap_link_state(u_char *state);
    static void swap_link_state_32(u_char *state);
    static void swap_link_state_64(u_char *state);
    static boolean_t unswap_link_state(u_char *state);
    static void unswap_link_state_32(u_char *state);
    static void unswap_link_state_64(u_char *state);
    static void swap_state_hdr(KXLDLinkStateHdr *state_hdr);
    static void swap_vtable_hdr(KXLDVTableHdr *vtable_hdr);
    static void swap_sym_entry_32(KXLDSymEntry32 *entry);
    static void swap_sym_entry_64(KXLDSymEntry64 *entry);
    #endif
    
    /*******************************************************************************
    *******************************************************************************/
    kern_return_t
    kxld_state_init_from_file(KXLDState *state, u_char *file, 
        KXLDArray *section_order __unused)
    {
       kern_return_t rval = KERN_FAILURE;
       KXLDLinkStateHdr *hdr = (KXLDLinkStateHdr *) file;
   #if KXLD_USER_OR_OBJECT
       KXLDSectionName *dstname = NULL;
       KXLDSectionName *srcname = NULL;
   #endif
       KXLDVTableHdr *vhdr = NULL;
       KXLDVTable *vtable = NULL;
       u_int i = 0;
   
       check(state);
       check(file);
   
   #if !KERNEL
       /* Swap the link state file to host byte order for as long this kxld_state
        * object owns the file.
        */
       state->swap = swap_link_state(file);
   #endif
       require_action(hdr->magic == LINK_STATE_MAGIC || 
           hdr->magic == LINK_STATE_MAGIC_64,
           finish, rval=KERN_FAILURE);
   
       state->file = file;
   
   #if KXLD_USER_OR_OBJECT
       if (section_order && !section_order->nitems && hdr->nsects) {
           rval = kxld_array_init(section_order, sizeof(*dstname), hdr->nsects);
           require_noerr(rval, finish);
   
           srcname = (KXLDSectionName *) (file + hdr->sectoff);
           for (i = 0; i < hdr->nsects; ++i, ++srcname) {
               dstname = kxld_array_get_item(section_order, i);
               memcpy(dstname, srcname, sizeof(*srcname));
           }
       }
   #endif
   
       rval = kxld_array_init(&state->vtables, sizeof(*vtable), hdr->nvtables);
       require_noerr(rval, finish);
       
       vhdr = (KXLDVTableHdr *) (file + hdr->voff);
       for (i = 0; i < hdr->nvtables; ++i, ++vhdr) {
           vtable = kxld_array_get_item(&state->vtables, i);
           KXLD_3264_FUNC(kxld_is_32_bit(hdr->cputype), rval,
               kxld_vtable_init_from_link_state_32,
               kxld_vtable_init_from_link_state_64,
               vtable, file, vhdr);
           require_noerr(rval, finish);
       }
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   void 
   kxld_state_clear(KXLDState *state)
   {
       KXLDVTable *vtable = NULL;
       u_int i = 0;
   
       check(state);
   
   #if !KERNEL
       /* We use kxld_state objects to wrap the link state files.  Whenever the
        * file is wrapped by a kxld_state object, the file is kept in host byte
        * order.  Once we are done, we must return it to target byte order.
        */
       if (state->swap) (void)unswap_link_state(state->file);
   #endif
   
       state->file = NULL;
       state->swap = FALSE;
       for (i = 0; i < state->vtables.nitems; ++i) {
           vtable = kxld_array_get_item(&state->vtables, i);
           kxld_vtable_clear(vtable);
       }
       kxld_array_reset(&state->vtables);
   }
   
   /*******************************************************************************
   *******************************************************************************/
   void 
   kxld_state_deinit(KXLDState *state)
   {
       KXLDVTable *vtable = NULL;
       u_int i = 0;
   
       check(state);
   
   #if !KERNEL
       if (state->file && state->swap) (void)unswap_link_state(state->file);
   #endif
      
       for (i = 0; i < state->vtables.maxitems; ++i) {
           vtable = kxld_array_get_slot(&state->vtables, i);
           kxld_vtable_deinit(vtable);
       }
       kxld_array_deinit(&state->vtables);
       bzero(state, sizeof(*state));
   }
   
   /*******************************************************************************
   *******************************************************************************/
   u_int 
   kxld_state_get_num_symbols(KXLDState *state)
   {
       KXLDLinkStateHdr *hdr = (KXLDLinkStateHdr *) state->file;
   
       return hdr->nsyms;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   kern_return_t 
   kxld_state_get_symbols(KXLDState *state, KXLDDict *defined_symbols,
       KXLDDict *obsolete_symbols)
   {
       KXLDLinkStateHdr * hdr = (KXLDLinkStateHdr *) state->file;
       kern_return_t rval = KERN_FAILURE;
   
       check(state);
       check(defined_symbols);
       check(obsolete_symbols);
   
       require_action(hdr->magic == LINK_STATE_MAGIC || 
           hdr->magic == LINK_STATE_MAGIC_64,
           finish, rval=KERN_FAILURE);
   
       KXLD_3264_FUNC(state_is_32_bit(hdr), rval,
           get_symbols_32, get_symbols_64,
           state, defined_symbols, obsolete_symbols);
       require_noerr(rval, finish);
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   #if KXLD_USER_OR_ILP32
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t
   get_symbols_32(KXLDState *state, KXLDDict *defined_symbols,
       KXLDDict *obsolete_symbols)
   {
       kern_return_t rval = KERN_FAILURE;
       KXLDLinkStateHdr *hdr = (KXLDLinkStateHdr *) state->file;
       KXLDSymEntry32 *entry = NULL;
       const char *name = NULL;
       u_int i = 0;
   
       entry = (KXLDSymEntry32 *) (state->file + hdr->symoff);
       for (i = 0; i < hdr->nsyms; ++i, ++entry) {
           name = (const char *) (state->file + entry->nameoff);
           rval = kxld_dict_insert(defined_symbols, name, &entry->addr);
           require_noerr(rval, finish);
   
           if (entry->flags & KXLD_SYM_OBSOLETE) {
               rval = kxld_dict_insert(obsolete_symbols, name, &entry->addr);
               require_noerr(rval, finish);
           }
       }
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   #endif /* KXLD_USER_OR_ILP32 */
   
   #if KXLD_USER_OR_LP64
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t
   get_symbols_64(KXLDState *state, KXLDDict *defined_symbols,
       KXLDDict *obsolete_symbols)
   {
       kern_return_t rval = KERN_FAILURE;
       KXLDLinkStateHdr *hdr = (KXLDLinkStateHdr *) state->file;
       KXLDSymEntry64 *entry = NULL;
       const char *name = NULL;
       u_int i = 0;
   
       entry = (KXLDSymEntry64 *) (state->file + hdr->symoff);
       for (i = 0; i < hdr->nsyms; ++i, ++entry) {
           name = (const char *) (state->file + entry->nameoff);
           rval = kxld_dict_insert(defined_symbols, name, &entry->addr);
           require_noerr(rval, finish);
   
           if (entry->flags & KXLD_SYM_OBSOLETE) {
               rval = kxld_dict_insert(obsolete_symbols, name, &entry->addr);
               require_noerr(rval, finish);
           }
       }
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   #endif /* KXLD_USER_OR_LP64 */
   
   /*******************************************************************************
   *******************************************************************************/
   u_int 
   kxld_state_get_num_vtables(KXLDState *state)
   {
       return state->vtables.nitems;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   kern_return_t 
   kxld_state_get_vtables(KXLDState *state, KXLDDict *patched_vtables)
   {
       kern_return_t rval = KERN_FAILURE;
       KXLDVTable *vtable = NULL;
       u_int i = 0;
   
       check(state);
       check(patched_vtables);
   
       for (i = 0; i < state->vtables.nitems; ++i) {
           vtable = kxld_array_get_item(&state->vtables, i);
           rval = kxld_dict_insert(patched_vtables, vtable->name, vtable);
           require_noerr(rval, finish);
       }
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   void
   kxld_state_get_cputype(const KXLDState *state, cpu_type_t *cputype, 
       cpu_subtype_t *cpusubtype)
   {
       KXLDLinkStateHdr *hdr = (KXLDLinkStateHdr *) state->file;
       
       check(state);
       check(cputype);
       check(cpusubtype);
   
       *cputype = hdr->cputype;
       *cpusubtype = hdr->cpusubtype;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   kern_return_t 
   kxld_state_export_kext_to_file(KXLDKext *kext, u_char **file, u_long *filesize, 
       KXLDDict *strings, KXLDArray *tmps)
   {
       kern_return_t rval = KERN_FAILURE;
       KXLDSymtabIterator iter;
       const KXLDSymtab *symtab = NULL;
       const KXLDArray *vtables = NULL;
       const KXLDVTable *vtable = NULL;
       u_int nsyms = 0;
       u_int nsymentries = 0;
       u_int i = 0;
       u_long strsize = 0;
   
       check(kext);
       check(file);
       check(tmps);
   
       bzero(&iter, sizeof(iter));
   
       /* Get the vtables and symbol tables from the kext */
   
       kxld_kext_get_vtables(kext, &vtables);
       symtab = kxld_kext_get_symtab(kext);
       require_action(symtab, finish, rval=KERN_FAILURE);
   
       /* Count the number of symentries we'll need in the linkstate */
   
       kxld_symtab_iterator_init(&iter, symtab, kxld_sym_is_exported, FALSE);
   
       nsyms = kxld_symtab_iterator_get_num_remaining(&iter);
       nsymentries = nsyms;
       for (i = 0; i < vtables->nitems; ++i) {
           vtable = kxld_array_get_item(vtables, i);
           nsymentries += vtable->entries.nitems;
       }
   
       /* Initialize the string index */
   
       rval = init_string_index(strings, tmps, &iter, vtables, nsymentries, 
           &strsize);
       require_noerr(rval, finish);
   
       /* Create the linkstate file */
   
       rval = create_link_state(file, filesize, kext, &iter, vtables, 
           strings, nsyms, nsymentries, strsize);
       require_noerr(rval, finish);
   
       /* Swap if necessary */
   
   #if !KERNEL
       if (kxld_kext_target_needs_swap(kext)) unswap_link_state(*file);
   #endif /* !KERNEL */
       
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t
   init_string_index(KXLDDict *strings, KXLDArray *tmps, KXLDSymtabIterator *iter,
       const KXLDArray *vtables, u_int nsymentries, u_long *_strsize)
   {
       kern_return_t rval = KERN_SUCCESS;
       const KXLDSym *sym = NULL;
       const KXLDVTable *vtable = NULL;
       const KXLDVTableEntry *ventry = NULL;
       u_long strsize = 0;
       u_int tmpi = 0;
       u_int i = 0;
       u_int j = 0;
   
       check(strings);
       check(tmps);
       check(iter);
       check(vtables);
       check(_strsize);
   
       *_strsize = 0;
   
       /* Initialize the string dictionary and string offset array */
       
       rval = kxld_dict_init(strings, kxld_dict_string_hash, kxld_dict_string_cmp,
           nsymentries);
       require_noerr(rval, finish);
   
       rval = kxld_array_init(tmps, sizeof(u_long), nsymentries);
       require_noerr(rval, finish);
   
       /* Add all of the strings from the symbol table to the dictionary */
   
       kxld_symtab_iterator_reset(iter);
       while ((sym = kxld_symtab_iterator_get_next(iter))) {
           rval = add_string_to_index(strings, sym->name, tmps, &tmpi, &strsize);
           require_noerr(rval, finish);
       }
   
       /* Add all of the strings from the vtables entries to the dictionary */
   
       for (i = 0; i < vtables->nitems; ++i) {
           vtable = kxld_array_get_item(vtables, i);
           rval = add_string_to_index(strings, vtable->name, tmps, &tmpi, &strsize);
           require_noerr(rval, finish);
   
           for (j = 0; j < vtable->entries.nitems; ++j) {
               ventry = kxld_array_get_item(&vtable->entries, j);
               if (ventry->patched.name) {
                   rval = add_string_to_index(strings, ventry->patched.name, tmps, 
                       &tmpi, &strsize);
                   require_noerr(rval, finish);
               }
           }
       }
   
       *_strsize = strsize;
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t
   add_string_to_index(KXLDDict *strings, const char *str, KXLDArray *tmps,
       u_int *tmpi, u_long *stroff)
   {
       kern_return_t rval = KERN_FAILURE;
       u_long *tmpp = NULL;
   
       if (!kxld_dict_find(strings, str)) {
           tmpp = kxld_array_get_item(tmps, (*tmpi)++);
           *tmpp = *stroff;
           
           rval = kxld_dict_insert(strings, str, tmpp);
           require_noerr(rval, finish);
       
           *stroff += strlen(str) + 1;
       }
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static boolean_t
   state_is_32_bit(KXLDLinkStateHdr *state)
   {
       return kxld_is_32_bit(state->cputype);
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t
   create_link_state(u_char **_file, u_long *_filesize, const KXLDKext *kext,
       KXLDSymtabIterator *iter, const KXLDArray *vtables, KXLDDict *strings, 
       u_int nsyms, u_int nsymentries, u_long strsize)
   {
       kern_return_t rval = KERN_SUCCESS;
       u_char *file = NULL;
       KXLDLinkStateHdr *hdr = NULL;
       KXLDDictIterator striter;
   #if KXLD_USER_OR_OBJECT
       KXLDSectionName *dstsectname = NULL;
       KXLDSectionName *srcsectname = NULL;
       const KXLDArray *section_order = NULL;
       u_int i = 0;
   #endif
       const char *name = NULL;
       char *dstname = NULL;
       u_long *stridx = 0;
       u_long hsize = 0;
       u_long dsize = 0;
       u_long filesize = 0;
       u_long hoff = 0;
       u_long doff = 0;
       u_long stroff = 0;
   
       check(_file);
       check(iter);
       check(vtables);
       check(strings);
   
       *_file = NULL;
       *_filesize = 0;
   
   #if KXLD_USER_OR_OBJECT
       section_order = kxld_kext_get_section_order(kext);
   #endif
   
       /* Calculate header and data size */
   
       hsize = sizeof(KXLDLinkStateHdr);
       hsize += vtables->nitems * sizeof(KXLDVTableHdr);
   #if KXLD_USER_OR_OBJECT
       if (section_order) {
           hsize += section_order->nitems * sizeof(KXLDSectionName);
       }
   #endif
   
       if (kxld_kext_is_32_bit(kext)) {
           dsize = nsymentries * sizeof(KXLDSymEntry32);
       } else {
           dsize = nsymentries * sizeof(KXLDSymEntry64);
       }
   
       filesize = hsize + dsize + strsize;
   
       hoff = 0;
       doff = hsize;
       stroff = hsize + dsize;
   
       /* Allocate the link state */
   
       file = kxld_alloc_pageable(filesize);
       require_action(file, finish, rval=KERN_RESOURCE_SHORTAGE);
   
       /* Initialize link state header */
   
       hdr = (KXLDLinkStateHdr *) file;
       hoff += sizeof(*hdr); 
   
       if (state_is_32_bit(hdr)) {
           hdr->magic = LINK_STATE_MAGIC;
       } else {
           hdr->magic = LINK_STATE_MAGIC_64;
       }
       hdr->version = LINK_STATE_VERSION;
       kxld_kext_get_cputype(kext, &hdr->cputype, &hdr->cpusubtype);
       hdr->nsects = 0;
       hdr->nvtables = vtables->nitems;
       hdr->nsyms = nsyms;
   
   #if KXLD_USER_OR_OBJECT
       if (section_order) {
           hdr->nsects = section_order->nitems;
           hdr->sectoff = (uint32_t) hoff;
   
           dstsectname = (KXLDSectionName *) (file + hoff);
           hoff += section_order->nitems * sizeof(*dstsectname);
   
           for (i = 0; i < section_order->nitems; ++i, ++dstsectname) {
               srcsectname = kxld_array_get_item(section_order, i);
               memcpy(dstsectname, srcsectname, sizeof(*srcsectname));
           }
       }
   #endif
   
       hdr->voff = (uint32_t) hoff;
       hdr->symoff = (uint32_t) doff;
   
       /* Copy strings */
       
       kxld_dict_iterator_init(&striter, strings);
       kxld_dict_iterator_get_next(&striter, (const void **) &name, (void **) &stridx);
       while (name) {
           *stridx += stroff;
           dstname = (char *) (file + *stridx);
           strlcpy(dstname, name, filesize - *stridx);
           kxld_dict_iterator_get_next(&striter, (const void **) &name, (void **) &stridx);
       }
   
       /* Copy symbols */
   
       KXLD_3264_FUNC(state_is_32_bit(hdr), rval,
           copy_symbols_32, copy_symbols_64,
           file, &doff, iter, strings);
       require_noerr(rval, finish);
   
       /* Copy vtables */
   
       KXLD_3264_FUNC(state_is_32_bit(hdr), rval,
           copy_vtables_32, copy_vtables_64,
           file, &hoff, &doff, vtables, strings);
       require_noerr(rval, finish);
   
       *_file = file;
       *_filesize = filesize;
       file = NULL;
       rval = KERN_SUCCESS;
   
   finish:
   
       if (file) {
           kxld_page_free(file, filesize);
           file = NULL;
       }
   
       return rval;
   }
   
   #if KXLD_USER_OR_ILP32
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t
   copy_symbols_32(u_char *file, u_long *data_offset, KXLDSymtabIterator *iter, 
       const KXLDDict *strings)
   {
       kern_return_t rval = KERN_FAILURE;
       KXLDSymEntry32 *symentry = NULL;
       const KXLDSym *sym = NULL;
       u_long *stridx = 0;
   
       kxld_symtab_iterator_reset(iter);
       while ((sym = kxld_symtab_iterator_get_next(iter))) {
           symentry = (KXLDSymEntry32 *) (file + *data_offset);
           stridx = kxld_dict_find(strings, sym->name);
           require_action(stridx, finish, rval=KERN_FAILURE);
   
           /* Initialize the symentry */
   
           symentry->nameoff = (uint32_t) *stridx;
           if (sym->predicates.is_thumb) {
               symentry->addr = (uint32_t) sym->link_addr | 1;
           } else {            
               symentry->addr = (uint32_t) sym->link_addr;
           }
           symentry->flags = 0;
   
           /* Set any flags */
   
           symentry->flags |= (kxld_sym_is_obsolete(sym)) ? KXLD_SYM_OBSOLETE : 0;
   
           *data_offset += sizeof(*symentry);
       }
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   #endif /* KXLD_USER_OR_ILP32 */
   
   #if KXLD_USER_OR_LP64
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t
   copy_symbols_64(u_char *file, u_long *data_offset, KXLDSymtabIterator *iter, 
       const KXLDDict *strings)
   {
       kern_return_t rval = KERN_FAILURE;
       KXLDSymEntry64 *symentry = NULL;
       const KXLDSym *sym = NULL;
       u_long *stridx = 0;
   
       kxld_symtab_iterator_reset(iter);
       while ((sym = kxld_symtab_iterator_get_next(iter))) {
           symentry = (KXLDSymEntry64 *) (file + *data_offset);
           stridx = kxld_dict_find(strings, sym->name);
           require_action(stridx, finish, rval=KERN_FAILURE);
   
           /* Initialize the symentry */
   
           symentry->nameoff = (uint32_t) *stridx;
           symentry->addr = (uint64_t) sym->link_addr;
           symentry->flags = 0;
   
           /* Set any flags */
   
           symentry->flags |= (kxld_sym_is_obsolete(sym)) ? KXLD_SYM_OBSOLETE : 0;
   
           *data_offset += sizeof(*symentry);
       }
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   #endif /* KXLD_USER_OR_LP64 */
   
   #if KXLD_USER_OR_ILP32
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t
   copy_vtables_32(u_char *file, u_long *header_offset, u_long *data_offset,
       const KXLDArray *vtables, const KXLDDict *strings)
   {
       kern_return_t rval = KERN_FAILURE;
       KXLDVTable *vtable = NULL;
       KXLDVTableHdr *vhdr = NULL;
       KXLDVTableEntry *ventry = NULL;
       KXLDSymEntry32 *symentry = NULL;
       u_long *stridx = 0;
       u_int i = 0;
       u_int j = 0;
   
       for (i = 0; i < vtables->nitems; ++i) {
           vtable = kxld_array_get_item(vtables, i);
           stridx = kxld_dict_find(strings, vtable->name);
           require_action(stridx, finish, rval=KERN_FAILURE);
   
           vhdr = (KXLDVTableHdr *) (file + *header_offset);
           vhdr->nameoff = (uint32_t) *stridx;
           vhdr->nentries = vtable->entries.nitems;
           vhdr->vtableoff = (uint32_t) (*data_offset);
   
           *header_offset += sizeof(*vhdr);
   
           for(j = 0; j < vtable->entries.nitems; ++j) {
   
               ventry = kxld_array_get_item(&vtable->entries, j);
               symentry = (KXLDSymEntry32 *) (file + *data_offset);
               
               if (ventry->patched.name) {
                   stridx = kxld_dict_find(strings, ventry->patched.name);
                   require_action(stridx, finish, rval=KERN_FAILURE);
   
                   symentry->nameoff = (uint32_t) *stridx;
                   symentry->addr = (uint32_t) ventry->patched.addr;
               } else {
                   symentry->nameoff = 0;
                   symentry->addr = 0;
               }
   
               *data_offset += sizeof(*symentry);
           }
       }
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   #endif /* KXLD_USER_OR_ILP32 */
   
   #if KXLD_USER_OR_LP64
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t
   copy_vtables_64(u_char *file, u_long *header_offset, u_long *data_offset,
       const KXLDArray *vtables, const KXLDDict *strings)
   {
       kern_return_t rval = KERN_FAILURE;
       KXLDVTable *vtable = NULL;
       KXLDVTableHdr *vhdr = NULL;
       KXLDVTableEntry *ventry = NULL;
       KXLDSymEntry64 *symentry = NULL;
       u_long *stridx = 0;
       u_int i = 0;
       u_int j = 0;
   
       for (i = 0; i < vtables->nitems; ++i) {
           vtable = kxld_array_get_item(vtables, i);
           stridx = kxld_dict_find(strings, vtable->name);
           require_action(stridx, finish, rval=KERN_FAILURE);
   
           vhdr = (KXLDVTableHdr *) (file + *header_offset);
           vhdr->nameoff = (uint32_t) *stridx;
           vhdr->nentries = vtable->entries.nitems;
           vhdr->vtableoff = (uint32_t) (*data_offset);
   
           *header_offset += sizeof(*vhdr);
   
           for(j = 0; j < vtable->entries.nitems; ++j) {
   
               ventry = kxld_array_get_item(&vtable->entries, j);
               symentry = (KXLDSymEntry64 *) (file + *data_offset);
               
               if (ventry->patched.name) {
                   stridx = kxld_dict_find(strings, ventry->patched.name);
                   require_action(stridx, finish, rval=KERN_FAILURE);
   
                   symentry->nameoff = (uint32_t) *stridx;
                   symentry->addr = (uint64_t) ventry->patched.addr;
               } else {
                   symentry->nameoff = 0;
                   symentry->addr = 0;
               }
   
               *data_offset += sizeof(*symentry);
           }
       }
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   #endif /* KXLD_USER_OR_LP64 */
   
   #if !KERNEL
   /*******************************************************************************
   *******************************************************************************/
   static boolean_t
   swap_link_state(u_char *state)
   {
       KXLDLinkStateHdr *state_hdr = (KXLDLinkStateHdr *) state;
   
       if (state_hdr->magic == CIGAM_ETATS_KNIL) {
           swap_link_state_32(state);
           return TRUE;
       } else if (state_hdr->magic == CIGAM_ETATS_KNIL_64) {
           swap_link_state_64(state);
           return TRUE;
       }
   
       return FALSE;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static void
   swap_link_state_32(u_char *state)
   {
       KXLDLinkStateHdr *state_hdr = NULL;
       KXLDVTableHdr *vtable_hdr = NULL;
       KXLDSymEntry32 *entry = NULL;
       u_int i = 0;
       u_int j = 0;
       
       state_hdr = (KXLDLinkStateHdr *) state;
   
       if (state_hdr->magic != CIGAM_ETATS_KNIL) return;
   
       /* Swap the header */
       swap_state_hdr(state_hdr);
   
       /* Swap the symbols */
       entry = (KXLDSymEntry32 *) (state + state_hdr->symoff);
       for (i = 0; i < state_hdr->nsyms; ++i, ++entry) {
           swap_sym_entry_32(entry);
       }
   
       /* Swap the vtable headers and entries */
       vtable_hdr = (KXLDVTableHdr *) (state + state_hdr->voff);
       for (i = 0; i < state_hdr->nvtables; ++i, ++vtable_hdr) {
           swap_vtable_hdr(vtable_hdr);
   
           entry = (KXLDSymEntry32 *) (state + vtable_hdr->vtableoff);
           for (j = 0; j < vtable_hdr->nentries; ++j, ++entry) {
               swap_sym_entry_32(entry);
           }
       }
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static void
   swap_link_state_64(u_char *state)
   {
       KXLDLinkStateHdr *state_hdr = NULL;
       KXLDVTableHdr *vtable_hdr = NULL;
       KXLDSymEntry64 *entry = NULL;
       u_int i = 0;
       u_int j = 0;
       
       state_hdr = (KXLDLinkStateHdr *) state;
   
       if (state_hdr->magic != CIGAM_ETATS_KNIL_64) return;
   
       /* Swap the header */
       swap_state_hdr(state_hdr);
   
       /* Swap the symbols */
       entry = (KXLDSymEntry64 *) (state + state_hdr->symoff);
       for (i = 0; i < state_hdr->nsyms; ++i, ++entry) {
           swap_sym_entry_64(entry);
       }
   
       /* Swap the vtable headers and entries */
       vtable_hdr = (KXLDVTableHdr *) (state + state_hdr->voff);
       for (i = 0; i < state_hdr->nvtables; ++i, ++vtable_hdr) {
           swap_vtable_hdr(vtable_hdr);
   
           entry = (KXLDSymEntry64 *) (state + vtable_hdr->vtableoff);
           for (j = 0; j < vtable_hdr->nentries; ++j, ++entry) {
               swap_sym_entry_64(entry);
           }
       }
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static boolean_t
   unswap_link_state(u_char *state)
   {
       KXLDLinkStateHdr *state_hdr = (KXLDLinkStateHdr *) state;
   
       if (state_hdr->magic == LINK_STATE_MAGIC) {
           unswap_link_state_32(state);
           return TRUE;
       } else if (state_hdr->magic == LINK_STATE_MAGIC_64) {
           unswap_link_state_64(state);
           return TRUE;
       }
   
       return FALSE;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static void
   unswap_link_state_32(u_char *state)
   {
       KXLDLinkStateHdr *state_hdr = NULL;
       KXLDVTableHdr *vtable_hdr = NULL;
       KXLDSymEntry32 *entry = NULL;
       u_int i = 0;
       u_int j = 0;
       
       state_hdr = (KXLDLinkStateHdr *) state;
   
       if (state_hdr->magic != LINK_STATE_MAGIC) return;
   
       /* Unswap the vtables and their headers */
       vtable_hdr = (KXLDVTableHdr *) (state + state_hdr->voff);
       for (i = 0; i < state_hdr->nvtables; ++i, ++vtable_hdr) {
           entry = (KXLDSymEntry32 *) (state + vtable_hdr->vtableoff);
           for (j = 0; j < vtable_hdr->nentries; ++j, ++entry) {
               swap_sym_entry_32(entry);
           }
   
           swap_vtable_hdr(vtable_hdr);
       }
   
       /* Unswap the symbols themselves */
       entry = (KXLDSymEntry32 *) (state + state_hdr->symoff);
       for (i = 0; i < state_hdr->nsyms; ++i, ++entry) {
           swap_sym_entry_32(entry);
       }
   
       /* Unswap the header */
       swap_state_hdr(state_hdr);
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static void
   unswap_link_state_64(u_char *state)
   {
       KXLDLinkStateHdr *state_hdr = NULL;
       KXLDVTableHdr *vtable_hdr = NULL;
       KXLDSymEntry64 *entry = NULL;
       u_int i = 0;
      u_int j = 0;
      
      state_hdr = (KXLDLinkStateHdr *) state;
  
      if (state_hdr->magic != LINK_STATE_MAGIC_64) return;
  
      /* Unswap the vtables and their headers */
      vtable_hdr = (KXLDVTableHdr *) (state + state_hdr->voff);
      for (i = 0; i < state_hdr->nvtables; ++i, ++vtable_hdr) {
          entry = (KXLDSymEntry64 *) (state + vtable_hdr->vtableoff);
          for (j = 0; j < vtable_hdr->nentries; ++j, ++entry) {
              swap_sym_entry_64(entry);
          }
  
          swap_vtable_hdr(vtable_hdr);
      }
  
      /* Unswap the symbols themselves */
      entry = (KXLDSymEntry64 *) (state + state_hdr->symoff);
      for (i = 0; i < state_hdr->nsyms; ++i, ++entry) {
          swap_sym_entry_64(entry);
      }
  
      /* Unswap the header */
      swap_state_hdr(state_hdr);
  }
  
  /*******************************************************************************
  *******************************************************************************/
  static void
  swap_state_hdr(KXLDLinkStateHdr *state_hdr)
  {
      state_hdr->magic = OSSwapInt32(state_hdr->magic);
      state_hdr->version = OSSwapInt32(state_hdr->version);
      state_hdr->cputype = OSSwapInt32(state_hdr->cputype);
      state_hdr->cpusubtype = OSSwapInt32(state_hdr->cpusubtype);
      state_hdr->nsects = OSSwapInt32(state_hdr->nsects);
      state_hdr->sectoff = OSSwapInt32(state_hdr->sectoff);
      state_hdr->nvtables = OSSwapInt32(state_hdr->nvtables);
      state_hdr->voff = OSSwapInt32(state_hdr->voff);
      state_hdr->nsyms = OSSwapInt32(state_hdr->nsyms);
      state_hdr->symoff = OSSwapInt32(state_hdr->symoff);
  }
  
  /*******************************************************************************
  *******************************************************************************/
  static void
  swap_vtable_hdr(KXLDVTableHdr *vtable_hdr)
  {
      vtable_hdr->nameoff = OSSwapInt32(vtable_hdr->nameoff);
      vtable_hdr->vtableoff = OSSwapInt32(vtable_hdr->vtableoff);
      vtable_hdr->nentries = OSSwapInt32(vtable_hdr->nentries);
  }
  
  /*******************************************************************************
  *******************************************************************************/
  static void
  swap_sym_entry_32(KXLDSymEntry32 *entry)
  {
      entry->nameoff = OSSwapInt32(entry->nameoff);
      entry->addr = OSSwapInt32(entry->addr);
  }
  
  /*******************************************************************************
  *******************************************************************************/
  static void
  swap_sym_entry_64(KXLDSymEntry64 *entry)
  {
      entry->nameoff = OSSwapInt32(entry->nameoff);
      entry->addr = OSSwapInt64(entry->addr);
  }
  #endif /* !KERNEL */
  

Cache object: c74074a2084d605332e9f9d129798fca