kxld_state.c   [plain text]

/*
 * 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 */