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

     /*
      * Copyright (c) 2007-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>
    #include <mach/boolean.h>
    #include <mach/machine.h>
    #include <sys/types.h>
    
    #if KERNEL
        #include <libkern/libkern.h>
    #else
        #include <libkern/OSByteOrder.h>
        #include <stdlib.h>
    #endif
    
    #define DEBUG_ASSERT_COMPONENT_NAME_STRING "kxld"
    #include <AssertMacros.h>
    
    #include "kxld_array.h"
    #include "kxld_reloc.h"
    #include "kxld_sect.h"
    #include "kxld_seg.h"
    #include "kxld_sym.h"
    #include "kxld_symtab.h"
    #include "kxld_util.h"
    
    /* include target-specific relocation prototypes */
    #include <mach-o/reloc.h>
    #if KXLD_USER_OR_PPC
    #include <mach-o/ppc/reloc.h>
    #endif
    #if KXLD_USER_OR_X86_64
    #include <mach-o/x86_64/reloc.h>
    #endif
    #if KXLD_USER_OR_ARM
    #include <mach-o/arm/reloc.h>
    #endif
    
    #define KXLD_TARGET_NONE        (u_int) 0x0
    #define KXLD_TARGET_VALUE       (u_int) 0x1
    #define KXLD_TARGET_SECTNUM     (u_int) 0x2
    #define KXLD_TARGET_SYMBOLNUM   (u_int) 0x3
    #define KXLD_TARGET_LOOKUP      (u_int) 0x4
    #define KXLD_TARGET_GOT         (u_int) 0x5
    
    #define ABSOLUTE_VALUE(x) (((x) < 0) ? -(x) : (x))
    
    #define LO16(x) (0x0000FFFF & x)
    #define LO16S(x) ((0x0000FFFF & x) << 16)
    #define HI16(x) (0xFFFF0000 & x)
    #define HI16S(x) ((0xFFFF0000 & x) >> 16)
    #define BIT15(x) (0x00008000 & x)
    #define BR14I(x) (0xFFFF0003 & x)
    #define BR14D(x) (0x0000FFFC & x)
    #define BR24I(x) (0xFC000003 & x)
    #define BR24D(x) (0x03FFFFFC & x)
    #define HADISP 0x00010000
    #define BR14_LIMIT 0x00008000
    #define BR24_LIMIT 0x02000000
    #define IS_COND_BR_INSTR(x) ((x & 0xFC000000) == 0x40000000)
    #define IS_NOT_ALWAYS_TAKEN(x) ((x & 0x03E00000) != 0x02800000)
    #define FLIP_PREDICT_BIT(x) x ^= 0x00200000
    
    #define SIGN_EXTEND_MASK(n) (1 << ((n) - 1))
    #define SIGN_EXTEND(x,n) (((x) ^ SIGN_EXTEND_MASK(n)) - SIGN_EXTEND_MASK(n))
    #define BR14_NBITS_DISPLACEMENT 16
    #define BR24_NBITS_DISPLACEMENT 26
    
    #define X86_64_RIP_RELATIVE_LIMIT 0x80000000UL
    
    /*******************************************************************************
    * Prototypes
    *******************************************************************************/
    #if KXLD_USER_OR_I386
    static boolean_t generic_reloc_has_pair(u_int _type) 
       __attribute__((const));
   static boolean_t generic_reloc_is_pair(u_int _type, u_int _prev_type)
       __attribute__((const));
   static boolean_t generic_reloc_has_got(u_int _type)
       __attribute__((const));
   static kern_return_t generic_process_reloc(u_char *instruction, u_int length, 
       u_int pcrel, kxld_addr_t base_pc, kxld_addr_t link_pc, kxld_addr_t link_disp,
       u_int type, kxld_addr_t target, kxld_addr_t pair_target, boolean_t swap);
   #endif /* KXLD_USER_OR_I386 */
   
   #if KXLD_USER_OR_PPC 
   static boolean_t ppc_reloc_has_pair(u_int _type) 
       __attribute__((const));
   static boolean_t ppc_reloc_is_pair(u_int _type, u_int _prev_type) 
       __attribute__((const));
   static boolean_t ppc_reloc_has_got(u_int _type)
       __attribute__((const));
   static kern_return_t ppc_process_reloc(u_char *instruction, u_int length, 
       u_int pcrel, kxld_addr_t base_pc, kxld_addr_t link_pc, kxld_addr_t link_disp,
       u_int type, kxld_addr_t target, kxld_addr_t pair_target, boolean_t swap);
   #endif /* KXLD_USER_OR_PPC */
   
   #if KXLD_USER_OR_X86_64 
   static boolean_t x86_64_reloc_has_pair(u_int _type) 
       __attribute__((const));
   static boolean_t x86_64_reloc_is_pair(u_int _type, u_int _prev_type) 
       __attribute__((const));
   static boolean_t x86_64_reloc_has_got(u_int _type)
       __attribute__((const));
   static kern_return_t x86_64_process_reloc(u_char *instruction, u_int length, 
       u_int pcrel, kxld_addr_t base_pc, kxld_addr_t link_pc, kxld_addr_t link_disp,
       u_int type, kxld_addr_t target, kxld_addr_t pair_target, boolean_t swap);
   static kern_return_t calculate_displacement_x86_64(uint64_t target, 
       uint64_t adjustment, int32_t *instr32);
   #endif /* KXLD_USER_OR_X86_64 */
   
   #if KXLD_USER_OR_ARM
   static boolean_t arm_reloc_has_pair(u_int _type) 
       __attribute__((const));
   static boolean_t arm_reloc_is_pair(u_int _type, u_int _prev_type) 
       __attribute__((const));
   static boolean_t arm_reloc_has_got(u_int _type)
       __attribute__((const));
   static kern_return_t arm_process_reloc(u_char *instruction, u_int length, 
       u_int pcrel, kxld_addr_t base_pc, kxld_addr_t link_pc, kxld_addr_t link_disp,
       u_int type, kxld_addr_t target, kxld_addr_t pair_target, boolean_t swap);
   #endif /* KXLD_USER_OR_ARM */
   
   #if KXLD_USER_OR_ILP32
   static kxld_addr_t get_pointer_at_addr_32(u_char *data, u_long offset,
       const KXLDRelocator *relocator __unused)
       __attribute__((pure, nonnull));
   #endif /* KXLD_USER_OR_ILP32 */
   #if KXLD_USER_OR_LP64
   static kxld_addr_t get_pointer_at_addr_64(u_char *data, u_long offset,
       const KXLDRelocator *relocator __unused)
       __attribute__((pure, nonnull));
   #endif /* KXLD_USER_OR_LP64 */
   
   static u_int count_relocatable_relocs(const KXLDRelocator *relocator, 
       const struct relocation_info *relocs, u_int nrelocs)
       __attribute__((pure));
   
   static kern_return_t calculate_targets(kxld_addr_t *_target, 
       kxld_addr_t *_pair_target, const KXLDReloc *reloc, 
       const KXLDArray *sectarray, const KXLDSymtab *symtab);
   static kern_return_t get_target_by_address_lookup(kxld_addr_t *target, 
       kxld_addr_t addr, const KXLDArray *sectarray);
   
   /*******************************************************************************
   *******************************************************************************/
   kern_return_t 
   kxld_relocator_init(KXLDRelocator *relocator, cpu_type_t cputype, 
       cpu_subtype_t cpusubtype __unused, boolean_t swap)
   {
       kern_return_t rval = KERN_FAILURE;
   
       check(relocator);
       
       switch(cputype) {
   #if KXLD_USER_OR_I386
       case CPU_TYPE_I386:
           relocator->reloc_has_pair = generic_reloc_has_pair;
           relocator->reloc_is_pair = generic_reloc_is_pair;
           relocator->reloc_has_got = generic_reloc_has_got;
           relocator->process_reloc = generic_process_reloc;
           relocator->is_32_bit = TRUE;
           break;
   #endif /* KXLD_USER_OR_I386 */
   #if KXLD_USER_OR_PPC
       case CPU_TYPE_POWERPC:
           relocator->reloc_has_pair = ppc_reloc_has_pair;
           relocator->reloc_is_pair = ppc_reloc_is_pair;
           relocator->reloc_has_got = ppc_reloc_has_got;
           relocator->process_reloc = ppc_process_reloc;
           relocator->is_32_bit = TRUE;
           break;
   #endif /* KXLD_USER_OR_PPC */
   #if KXLD_USER_OR_X86_64
       case CPU_TYPE_X86_64:
           relocator->reloc_has_pair = x86_64_reloc_has_pair;
           relocator->reloc_is_pair = x86_64_reloc_is_pair;
           relocator->reloc_has_got = x86_64_reloc_has_got;
           relocator->process_reloc = x86_64_process_reloc;
           relocator->is_32_bit = FALSE;
           break;
   #endif /* KXLD_USER_OR_X86_64 */
   #if KXLD_USER_OR_ARM
       case CPU_TYPE_ARM:
           relocator->reloc_has_pair = arm_reloc_has_pair;
           relocator->reloc_is_pair = arm_reloc_is_pair;
           relocator->reloc_has_got = arm_reloc_has_got;
           relocator->process_reloc = arm_process_reloc;
           relocator->is_32_bit = TRUE;
           break;
   #endif /* KXLD_USER_OR_ARM */
       default:
           rval = KERN_FAILURE;
           kxld_log(kKxldLogLinking, kKxldLogErr,
               kKxldLogArchNotSupported, cputype);
           goto finish;
       }
   
       relocator->is_32_bit = kxld_is_32_bit(cputype);
       relocator->swap = swap;
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   kern_return_t
   kxld_reloc_create_macho(KXLDArray *relocarray, const KXLDRelocator *relocator, 
       const struct relocation_info *srcs, u_int nsrcs)
   {
       kern_return_t rval = KERN_FAILURE;
       KXLDReloc *reloc = NULL;
       u_int nrelocs = 0;
       const struct relocation_info *src = NULL, *prev_src = NULL;
       const struct scattered_relocation_info *scatsrc = NULL, *prev_scatsrc = NULL;
       u_int i = 0;
       u_int reloc_index = 0;
   
       check(relocarray);
       check(srcs);
   
       /* If there are no relocation entries, just return */
       if (!nsrcs) {
           rval = KERN_SUCCESS;
           goto finish;
       }
   
       /* Count the number of non-pair relocs */
       nrelocs = count_relocatable_relocs(relocator, srcs, nsrcs);
   
       if (nrelocs) {
   
           /* Allocate the array of relocation entries */
   
           rval = kxld_array_init(relocarray, sizeof(KXLDReloc), nrelocs);
           require_noerr(rval, finish);
   
           /* Initialize the relocation entries */
           
           for (i = 0; i < nsrcs; ++i) {
               src = srcs + i;
               scatsrc = (const struct scattered_relocation_info *) src;
   
               /* A section-based relocation entry can be skipped for absolute 
                * symbols.
                */
   
               if (!(src->r_address & R_SCATTERED) && !(src->r_extern) && 
                   (R_ABS == src->r_symbolnum))
               {
                   continue;
               }
               
               /* Pull out the data from the relocation entries.  The target_type
                * depends on the r_extern bit:
                *  Scattered -> Section Lookup by Address
                *  Local (not extern) -> Section by Index
                *  Extern -> Symbolnum by Index
                */
               reloc = kxld_array_get_item(relocarray, reloc_index++);
               if (src->r_address & R_SCATTERED) {
                   reloc->address = scatsrc->r_address;
                   reloc->pcrel = scatsrc->r_pcrel;
                   reloc->length = scatsrc->r_length;
                   reloc->reloc_type = scatsrc->r_type;
                   reloc->target = scatsrc->r_value;
                   reloc->target_type = KXLD_TARGET_LOOKUP;
               } else {
                   reloc->address = src->r_address;
                   reloc->pcrel = src->r_pcrel;
                   reloc->length = src->r_length;
                   reloc->reloc_type = src->r_type;
                   reloc->target = src->r_symbolnum;
   
                   if (0 == src->r_extern) {
                       reloc->target_type = KXLD_TARGET_SECTNUM;
                       reloc->target -= 1;
                   } else {
                       reloc->target_type = KXLD_TARGET_SYMBOLNUM;
                   }
               }
               
               /* Find the pair entry if it exists */
   
               if (relocator->reloc_has_pair(reloc->reloc_type)) {
                   ++i;
                   require_action(i < nsrcs, finish, rval=KERN_FAILURE);
   
                   prev_src = src;
                   src = srcs + i;
                   prev_scatsrc = (const struct scattered_relocation_info *) prev_src;
                   scatsrc = (const struct scattered_relocation_info *) src;
                    
                   if (src->r_address & R_SCATTERED) {
                       require_action(relocator->reloc_is_pair(
                           scatsrc->r_type, reloc->reloc_type), 
                           finish, rval=KERN_FAILURE);
                       reloc->pair_target = scatsrc->r_value;
                       reloc->pair_target_type = KXLD_TARGET_LOOKUP;
                   } else {
                       require_action(relocator->reloc_is_pair(src->r_type, 
                           reloc->reloc_type), finish, rval=KERN_FAILURE);
   
                       if (src->r_extern) {
                           reloc->pair_target = src->r_symbolnum;
                           reloc->pair_target_type = KXLD_TARGET_SYMBOLNUM;
                       } else {
                           reloc->pair_target = src->r_address;
                           reloc->pair_target_type = KXLD_TARGET_VALUE;
                       }
                   }
               } else {
                   reloc->pair_target = 0;
                   if (relocator->reloc_has_got(reloc->reloc_type)) {
                      reloc->pair_target_type = KXLD_TARGET_GOT;
                   } else {
                      reloc->pair_target_type = KXLD_TARGET_NONE;
                   }
               }
           }
       }
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   
   /*******************************************************************************
   * Relocatable relocs :
   *   1) Are not _PAIR_ relocs
   *   2) Don't reference N_ABS symbols
   *******************************************************************************/
   static u_int
   count_relocatable_relocs(const KXLDRelocator *relocator, 
       const struct relocation_info *relocs, u_int nrelocs)
   {
       u_int num_nonpair_relocs = 0;
       u_int i = 0;
       u_int prev_type = 0;
       const struct relocation_info *reloc = NULL;
       const struct scattered_relocation_info *sreloc = NULL;
   
       check(relocator);
       check(relocs);
   
       /* Loop over all of the relocation entries */
   
       num_nonpair_relocs = 1;
       prev_type = relocs->r_type;
       for (i = 1; i < nrelocs; ++i) {
           reloc = relocs + i;
   
           if (reloc->r_address & R_SCATTERED) {
               /* A scattered relocation entry is relocatable as long as it's not a
                * pair.
                */
               sreloc = (const struct scattered_relocation_info *) reloc;
   
               num_nonpair_relocs += 
                   (!relocator->reloc_is_pair(sreloc->r_type, prev_type));
   
               prev_type = sreloc->r_type;
           } else {
               /* A normal relocation entry is relocatable if it is not a pair and
                * if it is not a section-based relocation for an absolute symbol.
                */
               num_nonpair_relocs += 
                   !(relocator->reloc_is_pair(reloc->r_type, prev_type)
                    || (0 == reloc->r_extern && R_ABS == reloc->r_symbolnum));
   
               prev_type = reloc->r_type;
           }
   
       }
       
       return num_nonpair_relocs;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   void
   kxld_relocator_clear(KXLDRelocator *relocator)
   {
       bzero(relocator, sizeof(*relocator));
   }
   
   /*******************************************************************************
   *******************************************************************************/
   boolean_t 
   kxld_relocator_has_pair(const KXLDRelocator *relocator, u_int r_type)
   {
       check(relocator);
   
       return relocator->reloc_has_pair(r_type);
   }
   
   /*******************************************************************************
   *******************************************************************************/
   boolean_t 
   kxld_relocator_is_pair(const KXLDRelocator *relocator, u_int r_type, 
       u_int prev_r_type)
   {
       check(relocator);
   
       return relocator->reloc_is_pair(r_type, prev_r_type);
   }
   
   /*******************************************************************************
   *******************************************************************************/
   boolean_t 
   kxld_relocator_has_got(const KXLDRelocator *relocator, u_int r_type)
   {
       check(relocator);
   
       return relocator->reloc_has_got(r_type);
   }
   
   /*******************************************************************************
   *******************************************************************************/
   KXLDSym *
   kxld_reloc_get_symbol(const KXLDRelocator *relocator, const KXLDReloc *reloc, 
       u_char *data, const KXLDSymtab *symtab)
   {
       KXLDSym *sym = NULL;
       kxld_addr_t value = 0;
   
       check(reloc);
       check(symtab);
   
       switch (reloc->target_type) {
       case KXLD_TARGET_SYMBOLNUM:
           sym = kxld_symtab_get_symbol_by_index(symtab, reloc->target);
           break;
       case KXLD_TARGET_SECTNUM:
           if (data) {
               KXLD_3264_FUNC(relocator->is_32_bit, value,
                   get_pointer_at_addr_32, get_pointer_at_addr_64,
                   data, reloc->address, relocator);
               sym = kxld_symtab_get_cxx_symbol_by_value(symtab, value);           
           }
           break;
       default:
           sym = NULL;
           break;
       }
   
       return sym;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   kern_return_t
   kxld_reloc_get_reloc_index_by_offset(const KXLDArray *relocs, 
       kxld_size_t offset, u_int *idx)
   {
       kern_return_t rval = KERN_FAILURE;
       KXLDReloc *reloc = NULL;
       u_int i = 0;
   
       for (i = 0; i < relocs->nitems; ++i) {
           reloc = kxld_array_get_item(relocs, i);
           if (reloc->address == offset) break;
       }
       
       if (i >= relocs->nitems) {
           rval = KERN_FAILURE;
           goto finish;
       }
   
       *idx = i;
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   KXLDReloc *
   kxld_reloc_get_reloc_by_offset(const KXLDArray *relocs, kxld_addr_t offset)
   {
       kern_return_t rval = KERN_FAILURE;
       KXLDReloc *reloc = NULL;
       u_int i = 0;
   
       rval = kxld_reloc_get_reloc_index_by_offset(relocs, offset, &i);
       if (rval) goto finish;
   
       reloc = kxld_array_get_item(relocs, i);
       
   finish:
       return reloc;
   }
   
   #if KXLD_USER_OR_ILP32
   /*******************************************************************************
   *******************************************************************************/
   static kxld_addr_t
   get_pointer_at_addr_32(u_char *data, u_long offset,
       const KXLDRelocator *relocator __unused)
   {
       uint32_t addr = 0;
       
       check(relocator);
       check(data);
   
       addr = *(uint32_t *) (data + offset);
   #if !KERNEL
       if (relocator->swap) {
           addr = OSSwapInt32(addr);
       }
   #endif
   
       return (kxld_addr_t) addr;
   }
   #endif /* KXLD_USER_OR_ILP32 */
   
   #if KXLD_USER_OR_LP64
   /*******************************************************************************
   *******************************************************************************/
   static kxld_addr_t
   get_pointer_at_addr_64(u_char *data, u_long offset,
       const KXLDRelocator *relocator __unused)
   {
       uint64_t addr = 0;
       
       check(relocator);
       check(data);
   
       addr = *(uint64_t *) (data + offset);
   #if !KERNEL
       if (relocator->swap) {
           addr = OSSwapInt64(addr);
       }
   #endif
   
       return (kxld_addr_t) addr;
   }
   #endif /* KXLD_USER_OR_LP64 */
   
   /*******************************************************************************
   *******************************************************************************/
   kern_return_t 
   kxld_relocator_process_sect_reloc(const KXLDRelocator *relocator,
       const KXLDReloc *reloc, const struct kxld_sect *sect,
       const KXLDArray *sectarray, const struct kxld_symtab *symtab)
   {
       kern_return_t rval = KERN_FAILURE;
       u_char *instruction = NULL;
       kxld_addr_t target = 0;
       kxld_addr_t pair_target = 0;
       kxld_addr_t base_pc = 0;
       kxld_addr_t link_pc = 0;
       kxld_addr_t link_disp = 0;
   
       check(relocator);
       check(reloc);
       check(sect);
       check(sectarray);
       check(symtab);
   
       /* Find the instruction */
   
       instruction = sect->data + reloc->address;
   
       /* Calculate the target */
   
       rval = calculate_targets(&target, &pair_target, reloc, sectarray, symtab);
       require_noerr(rval, finish);
   
       base_pc = reloc->address;
       link_pc = base_pc + sect->link_addr;
       link_disp = sect->link_addr - sect->base_addr;
   
       /* Relocate */
   
       rval = relocator->process_reloc(instruction, reloc->length, reloc->pcrel,
           base_pc, link_pc, link_disp, reloc->reloc_type, target, pair_target, 
           relocator->swap);
       require_noerr(rval, finish);
       
       /* Return */
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   kern_return_t 
   kxld_reloc_update_symindex(KXLDReloc *reloc, u_int symindex)
   {
       kern_return_t rval = KERN_FAILURE;
   
       require_action(reloc->target_type == KXLD_TARGET_SYMBOLNUM, 
           finish, rval = KERN_FAILURE);
   
       reloc->target = symindex;
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   kern_return_t 
   kxld_relocator_process_table_reloc(const KXLDRelocator *relocator,
       const KXLDReloc *reloc, const KXLDSeg *seg, u_char *file, 
       const struct kxld_array *sectarray, const struct kxld_symtab *symtab)
   {
       kern_return_t rval = KERN_FAILURE;
       u_char *instruction = NULL;
       kxld_addr_t target = 0;
       kxld_addr_t pair_target = 0;
       kxld_addr_t base_pc = 0;
       kxld_addr_t link_pc = 0;
       kxld_addr_t link_disp = 0;
   
       check(relocator);
       check(reloc);
       check(file);
       check(sectarray);
       check(symtab);
   
       /* Find the instruction */
   
       instruction = file + seg->fileoff + reloc->address;
   
       /* Calculate the target */
   
       rval = calculate_targets(&target, &pair_target, reloc, sectarray, symtab);
       require_noerr(rval, finish);
   
       base_pc = reloc->address;
       link_pc = base_pc + seg->link_addr;
       link_disp = seg->link_addr - seg->base_addr;
   
       /* Relocate */
   
       rval = relocator->process_reloc(instruction, reloc->length, reloc->pcrel,
           base_pc, link_pc, link_disp, reloc->reloc_type, target, pair_target, 
           relocator->swap);
       require_noerr(rval, finish);
       
       /* Return */
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t
   calculate_targets(kxld_addr_t *_target, kxld_addr_t *_pair_target,
       const KXLDReloc *reloc, const KXLDArray *sectarray, const KXLDSymtab *symtab)
   {
       kern_return_t rval = KERN_FAILURE;
       const KXLDSect *sect = NULL;
       const KXLDSym *sym = NULL;
       kxld_addr_t target = 0;
       kxld_addr_t pair_target = 0;
   
       check(_target);
       check(_pair_target);
       check(sectarray);
       check(symtab);
       *_target = 0;
       *_pair_target = 0;
   
       /* Find the target based on the lookup type */
   
       switch(reloc->target_type) {
       case KXLD_TARGET_LOOKUP:
           require_action(reloc->pair_target_type == KXLD_TARGET_NONE ||
               reloc->pair_target_type == KXLD_TARGET_LOOKUP ||
               reloc->pair_target_type == KXLD_TARGET_VALUE,
               finish, rval=KERN_FAILURE);
   
           rval = get_target_by_address_lookup(&target, reloc->target, sectarray);
           require_noerr(rval, finish);
   
           if (reloc->pair_target_type == KXLD_TARGET_LOOKUP) {
               rval = get_target_by_address_lookup(&pair_target,
                   reloc->pair_target, sectarray);
               require_noerr(rval, finish);
           } else if (reloc->pair_target_type == KXLD_TARGET_VALUE) {
               pair_target = reloc->pair_target;
           }
           break;
       case KXLD_TARGET_SECTNUM:
           require_action(reloc->pair_target_type == KXLD_TARGET_NONE ||
               reloc->pair_target_type == KXLD_TARGET_VALUE, 
               finish, rval=KERN_FAILURE);
   
           /* Get the target's section by section number */
           sect = kxld_array_get_item(sectarray, reloc->target);
           require_action(sect, finish, rval=KERN_FAILURE);
   
           /* target is the change in the section's address */
           target = sect->link_addr - sect->base_addr;
   
           if (reloc->pair_target_type) {
               pair_target = reloc->pair_target;
           } else {
               /* x86_64 needs to know when we have a non-external relocation,
                * so we hack that information in here.
                */
               pair_target = TRUE;
           }
           break;
       case KXLD_TARGET_SYMBOLNUM:
           require_action(reloc->pair_target_type == KXLD_TARGET_NONE ||
               reloc->pair_target_type == KXLD_TARGET_GOT ||
               reloc->pair_target_type == KXLD_TARGET_SYMBOLNUM ||
               reloc->pair_target_type == KXLD_TARGET_VALUE, finish,
               rval=KERN_FAILURE);
   
           /* Get the target's symbol by symbol number */
           sym = kxld_symtab_get_symbol_by_index(symtab, reloc->target);
           require_action(sym, finish, rval=KERN_FAILURE);
           target = sym->link_addr;
   
           /* Some relocation types need the GOT entry address instead of the
            * symbol's actual address.  These types don't have pair relocation
            * entries, so we store the GOT entry address as the pair target.
            */
           if (reloc->pair_target_type == KXLD_TARGET_VALUE) {
               pair_target = reloc->pair_target;
           } else if (reloc->pair_target_type == KXLD_TARGET_SYMBOLNUM ) {
               sym = kxld_symtab_get_symbol_by_index(symtab, reloc->pair_target);
               require_action(sym, finish, rval=KERN_FAILURE);
               pair_target = sym->link_addr;
           } else if (reloc->pair_target_type == KXLD_TARGET_GOT) {
               pair_target = sym->got_addr;
           }
           break;
       default:
           rval = KERN_FAILURE;
           goto finish;
       }
   
       *_target = target;
       *_pair_target = pair_target;
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t
   get_target_by_address_lookup(kxld_addr_t *target, kxld_addr_t addr,
       const KXLDArray *sectarray)
   {
       kern_return_t rval = KERN_FAILURE;
       const KXLDSect *sect = NULL;
       kxld_addr_t start = 0;
       kxld_addr_t end = 0;
       u_int i = 0;
   
       check(target);
       check(sectarray);
       *target = 0;
   
       for (i = 0; i < sectarray->nitems; ++i) {
           sect = kxld_array_get_item(sectarray, i);
           start = sect->base_addr;
           end = start + sect->size;
   
           if (start <= addr && addr < end) break;
       }
       require_action(i < sectarray->nitems, finish, 
           rval=KERN_FAILURE);
   
       *target = sect->link_addr - sect->base_addr;
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   
   #if KXLD_USER_OR_I386 
   /*******************************************************************************
   *******************************************************************************/
   static boolean_t
   generic_reloc_has_pair(u_int _type)
   {
       enum reloc_type_generic type = _type;
   
       return (type == GENERIC_RELOC_SECTDIFF || 
           type == GENERIC_RELOC_LOCAL_SECTDIFF);
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static boolean_t 
   generic_reloc_is_pair(u_int _type, u_int _prev_type __unused)
   {
       enum reloc_type_generic type = _type;
   
       return (type == GENERIC_RELOC_PAIR);
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static boolean_t generic_reloc_has_got(u_int _type __unused)
   {
       return FALSE;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t 
   generic_process_reloc(u_char *instruction, u_int length, u_int pcrel,
       kxld_addr_t _base_pc, kxld_addr_t _link_pc, kxld_addr_t _link_disp __unused, 
       u_int _type, kxld_addr_t _target, kxld_addr_t _pair_target, 
       boolean_t swap __unused)
   {
       kern_return_t rval = KERN_FAILURE;
       uint32_t base_pc = (uint32_t) _base_pc;
       uint32_t link_pc = (uint32_t) _link_pc;
       uint32_t *instr_addr = NULL;
       uint32_t instr_data = 0;
       uint32_t target = (uint32_t) _target;
       uint32_t pair_target = (uint32_t) _pair_target;
       enum reloc_type_generic type = _type;
   
       check(instruction);
       require_action(length == 2, finish, rval=KERN_FAILURE);
   
       if (pcrel) target = target + base_pc - link_pc;
   
       instr_addr = (uint32_t *)instruction;
       instr_data = *instr_addr;
   
   #if !KERNEL
       if (swap) instr_data = OSSwapInt32(instr_data);
   #endif
   
       switch (type) {
       case GENERIC_RELOC_VANILLA:
           instr_data += target;
           break;
       case GENERIC_RELOC_SECTDIFF:
       case GENERIC_RELOC_LOCAL_SECTDIFF:
           instr_data = instr_data + target - pair_target;
           break;
       case GENERIC_RELOC_PB_LA_PTR:
           rval = KERN_FAILURE;
           goto finish;
       case GENERIC_RELOC_PAIR:
       default:
           rval = KERN_FAILURE;
           goto finish;
       }
   
   #if !KERNEL
       if (swap) instr_data = OSSwapInt32(instr_data);
   #endif
   
       *instr_addr = instr_data;
   
       rval = KERN_SUCCESS;
   
   finish:
       return rval;
   }
   #endif /* KXLD_USER_OR_I386 */
   
   #if KXLD_USER_OR_PPC
   /*******************************************************************************
   *******************************************************************************/
   static boolean_t
   ppc_reloc_has_pair(u_int _type)
   {
       enum reloc_type_ppc type = _type;
   
       switch(type) {
       case PPC_RELOC_HI16:
       case PPC_RELOC_LO16:
       case PPC_RELOC_HA16:
       case PPC_RELOC_LO14:
       case PPC_RELOC_JBSR:
       case PPC_RELOC_SECTDIFF:
           return TRUE;
       default:
           return FALSE;
       }
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static boolean_t
   ppc_reloc_is_pair(u_int _type, u_int _prev_type __unused)
   {
       enum reloc_type_ppc type = _type;
   
       return (type == PPC_RELOC_PAIR);
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static boolean_t ppc_reloc_has_got(u_int _type __unused)
   {
       return FALSE;
   }
   
   /*******************************************************************************
   *******************************************************************************/
   static kern_return_t
   ppc_process_reloc(u_char *instruction, u_int length, u_int pcrel,
       kxld_addr_t _base_pc, kxld_addr_t _link_pc, kxld_addr_t _link_disp __unused,
       u_int _type, kxld_addr_t _target, kxld_addr_t _pair_target __unused,
       boolean_t swap __unused)
   {
       kern_return_t rval = KERN_FAILURE;
       uint32_t *instr_addr = NULL;
       uint32_t instr_data = 0;
       uint32_t base_pc = (uint32_t) _base_pc;
       uint32_t link_pc = (uint32_t) _link_pc;
       uint32_t target = (uint32_t) _target;
       uint32_t pair_target = (uint32_t) _pair_target;
       int32_t addend = 0;
       int32_t displacement = 0;
       uint32_t difference = 0;
       uint32_t br14_disp_sign = 0;
       enum reloc_type_ppc type = _type;
   
       check(instruction);
       require_action(length == 2 || length == 3, finish, 
           rval=KERN_FAILURE);
   
       if (pcrel) displacement = target + base_pc - link_pc;
   
       instr_addr = (uint32_t *)instruction;
       instr_data = *instr_addr;
       
   #if !KERNEL
       if (swap) instr_data = OSSwapInt32(instr_data);
   #endif
   
       switch (type) {
       case PPC_RELOC_VANILLA:
           require_action(!pcrel, finish, rval=KERN_FAILURE);
   
           instr_data += target;
           break;
       case PPC_RELOC_BR14:
           require_action(pcrel, finish, rval=KERN_FAILURE);
   
           addend = BR14D(instr_data);
           displacement += SIGN_EXTEND(addend, BR14_NBITS_DISPLACEMENT);
           difference = ABSOLUTE_VALUE(displacement);
           require_action(difference < BR14_LIMIT, finish, 
               rval=KERN_FAILURE;
               kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogRelocationOverflow));
   
   
           br14_disp_sign = BIT15(instr_data);
           instr_data = BR14I(instr_data) | BR14D(displacement);
           
           /* If this is a predicted conditional branch (signified by an
            * instruction length of 3) that is not branch-always, and the sign of
           * the displacement is different after relocation, then flip the y-bit
           * to preserve the branch prediction
           */
          if ((length == 3) && 
              IS_COND_BR_INSTR(instr_data) &&
              IS_NOT_ALWAYS_TAKEN(instr_data) && 
              (BIT15(instr_data) != br14_disp_sign))
          {     
              FLIP_PREDICT_BIT(instr_data);
          }
          break;
      case PPC_RELOC_BR24:
          require_action(pcrel, finish, rval=KERN_FAILURE);
  
          addend = BR24D(instr_data);
          displacement += SIGN_EXTEND(addend, BR24_NBITS_DISPLACEMENT);
          difference = ABSOLUTE_VALUE(displacement);
          require_action(difference < BR24_LIMIT, finish, 
              rval=KERN_FAILURE;
              kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogRelocationOverflow));
  
          instr_data = BR24I(instr_data) | BR24D(displacement);
          break;
      case PPC_RELOC_HI16:
          require_action(!pcrel, finish, rval=KERN_FAILURE);
  
          target += LO16S(instr_data) | LO16(pair_target);
          instr_data = HI16(instr_data) | HI16S(target);
          break;
      case PPC_RELOC_LO16:
          require_action(!pcrel, finish, rval=KERN_FAILURE);
  
          target += LO16S(pair_target) | LO16(instr_data);
          instr_data = HI16(instr_data) | LO16(target);
          break;
      case PPC_RELOC_HA16:
          require_action(!pcrel, finish, rval=KERN_FAILURE);
  
          instr_data -= BIT15(pair_target) ? 1 : 0;
          target += LO16S(instr_data) | LO16(pair_target);
          instr_data = HI16(instr_data) | HI16S(target);
          instr_data += BIT15(target) ? 1 : 0;
          break;
      case PPC_RELOC_JBSR:
          require_action(!pcrel, finish, rval=KERN_FAILURE);
  
          /* The generated code as written branches to an island that loads the
           * absolute address of the target.  If we can branch to the target 
           * directly with less than 24 bits of displacement, we modify the branch
           * instruction to do so which avoids the cost of the island.
           */
  
          displacement = target + pair_target - link_pc;
          difference = ABSOLUTE_VALUE(displacement);
          if (difference < BR24_LIMIT) {
              instr_data = BR24I(instr_data) | BR24D(displacement);
          }
          break;
      case PPC_RELOC_SECTDIFF:
          require_action(!pcrel, finish, rval=KERN_FAILURE);
          
          instr_data = instr_data + target - pair_target;
          break;
      case PPC_RELOC_LO14:
      case PPC_RELOC_PB_LA_PTR:
      case PPC_RELOC_HI16_SECTDIFF:
      case PPC_RELOC_LO16_SECTDIFF:
      case PPC_RELOC_HA16_SECTDIFF:
      case PPC_RELOC_LO14_SECTDIFF:
      case PPC_RELOC_LOCAL_SECTDIFF:
          rval = KERN_FAILURE;
          goto finish;
      case PPC_RELOC_PAIR:
      default:
          rval = KERN_FAILURE;
          goto finish;
      }
  
  #if !KERNEL
      if (swap) instr_data = OSSwapInt32(instr_data);
  #endif
  
      *instr_addr = instr_data;
  
      rval = KERN_SUCCESS;
  finish:
  
      return rval;
  }
  #endif /* KXLD_USER_OR_PPC */
  
  #if KXLD_USER_OR_X86_64
  /*******************************************************************************
  *******************************************************************************/
  static boolean_t 
  x86_64_reloc_has_pair(u_int _type)
  {
      enum reloc_type_x86_64 type = _type;
  
      return (type == X86_64_RELOC_SUBTRACTOR);
  }
  
  /*******************************************************************************
  *******************************************************************************/
  static boolean_t 
  x86_64_reloc_is_pair(u_int _type, u_int _prev_type)
  {
      enum reloc_type_x86_64 type = _type;
      enum reloc_type_x86_64 prev_type = _prev_type;
  
      return (x86_64_reloc_has_pair(prev_type) && type == X86_64_RELOC_UNSIGNED);
  }
  
  /*******************************************************************************
  *******************************************************************************/
  static boolean_t 
  x86_64_reloc_has_got(u_int _type)
  {
      enum reloc_type_x86_64 type = _type;
  
      return (type == X86_64_RELOC_GOT_LOAD || type == X86_64_RELOC_GOT);
  }
  
  /*******************************************************************************
  *******************************************************************************/
  static kern_return_t 
  x86_64_process_reloc(u_char *instruction, u_int length, u_int pcrel,
      kxld_addr_t _base_pc __unused, kxld_addr_t _link_pc, kxld_addr_t _link_disp,
      u_int _type, kxld_addr_t _target, kxld_addr_t _pair_target, 
      boolean_t swap __unused)
  {
      kern_return_t rval = KERN_FAILURE;
      enum reloc_type_x86_64 type = _type;
      int32_t *instr32p = NULL;
      int32_t instr32 = 0;
      uint64_t *instr64p = NULL;
      uint64_t instr64 = 0;
      uint64_t target = _target;
      uint64_t pair_target = _pair_target;
      uint64_t link_pc = (uint64_t) _link_pc;
      uint64_t link_disp = (uint64_t) _link_disp;
      uint64_t adjustment = 0;
  
      check(instruction);
      require_action(length == 2 || length == 3, 
          finish, rval=KERN_FAILURE);
  
      if (length == 2) {
          instr32p = (int32_t *) instruction;
          instr32 = *instr32p;
  
  #if !KERNEL
          if (swap) instr32 = OSSwapInt32(instr32);
  #endif
  
          /* There are a number of different small adjustments for pc-relative
           * relocation entries.  The general case is to subtract the size of the
           * relocation (represented by the length parameter), and it applies to
           * the GOT types and external SIGNED types.  The non-external signed types
           * have a different adjustment corresponding to the specific type.
           */
          switch (type) {
          case X86_64_RELOC_SIGNED:
              if (pair_target) {
                  adjustment = 0;    
                  break;
              }
              /* Fall through */
          case X86_64_RELOC_SIGNED_1:
              if (pair_target) {
                  adjustment = 1;
                  break;
              }
              /* Fall through */
          case X86_64_RELOC_SIGNED_2:
              if (pair_target) {
                  adjustment = 2;
                  break;
              }
              /* Fall through */
          case X86_64_RELOC_SIGNED_4:
              if (pair_target) {
                  adjustment = 4;
                  break;
              }
              /* Fall through */
          case X86_64_RELOC_BRANCH:
          case X86_64_RELOC_GOT:
          case X86_64_RELOC_GOT_LOAD:
              adjustment = (1 << length);
              break;
          default:
              break;
          }
  
          /* Perform the actual relocation.  All of the 32-bit relocations are 
           * pc-relative except for SUBTRACTOR, so a good chunk of the logic is
           * stuck in calculate_displacement_x86_64.  The signed relocations are
           * a special case, because when they are non-external, the instruction
           * already contains the pre-relocation displacement, so we only need to
           * find the difference between how far the PC was relocated, and how
           * far the target is relocated.  Since the target variable already
           * contains the difference between the target's base and link
           * addresses, we add the difference between the PC's base and link
           * addresses to the adjustment variable.  This will yield the
           * appropriate displacement in calculate_displacement.
           */
          switch (type) {
          case X86_64_RELOC_BRANCH:
              require_action(pcrel, finish, rval=KERN_FAILURE);
              adjustment += link_pc;
              break;
          case X86_64_RELOC_SIGNED:
          case X86_64_RELOC_SIGNED_1:
          case X86_64_RELOC_SIGNED_2:
          case X86_64_RELOC_SIGNED_4:
              require_action(pcrel, finish, rval=KERN_FAILURE);
              adjustment += (pair_target) ? (link_disp) : (link_pc);
              break;
          case X86_64_RELOC_GOT:
          case X86_64_RELOC_GOT_LOAD:
              require_action(pcrel, finish, rval=KERN_FAILURE);
              adjustment += link_pc;
              target = pair_target;
              break;
          case X86_64_RELOC_SUBTRACTOR:
              require_action(!pcrel, finish, rval=KERN_FAILURE);
              instr32 = (int32_t) (target - pair_target);
              break;
          case X86_64_RELOC_UNSIGNED:
          default:
              rval = KERN_FAILURE;
              goto finish;
          }
  
          /* Call calculate_displacement for the pc-relative relocations */
          if (pcrel) {
              rval = calculate_displacement_x86_64(target, adjustment, &instr32); 
              require_noerr(rval, finish);
          }
  
  #if !KERNEL
          if (swap) instr32 = OSSwapInt32(instr32);
  #endif
  
          *instr32p = instr32;
      } else {
          instr64p = (uint64_t *) instruction;
          instr64 = *instr64p;
  
  #if !KERNEL
          if (swap) instr64 = OSSwapInt64(instr64);
  #endif
  
          switch (type) {
          case X86_64_RELOC_UNSIGNED:
              require_action(!pcrel, finish, rval=KERN_FAILURE);
              
              instr64 += target;
              break;
          case X86_64_RELOC_SUBTRACTOR:
              require_action(!pcrel, finish, rval=KERN_FAILURE);
  
              instr64 = target - pair_target;
              break;
          case X86_64_RELOC_SIGNED_1:
          case X86_64_RELOC_SIGNED_2:
          case X86_64_RELOC_SIGNED_4:
          case X86_64_RELOC_GOT_LOAD:
          case X86_64_RELOC_BRANCH:
          case X86_64_RELOC_SIGNED:
          case X86_64_RELOC_GOT:
          default:
              rval = KERN_FAILURE;
              goto finish;
          }
  
  #if !KERNEL
          if (swap) instr64 = OSSwapInt64(instr64);
  #endif
  
          *instr64p = instr64;
      }
  
      rval = KERN_SUCCESS;
  
  finish:
      return rval;
  }
  
  /*******************************************************************************
  *******************************************************************************/
  static kern_return_t
  calculate_displacement_x86_64(uint64_t target, uint64_t adjustment, 
      int32_t *instr32)
  {
      kern_return_t rval = KERN_FAILURE;
      int64_t displacement;
      uint64_t difference;
  
      displacement = *instr32 + target - adjustment;
      difference = ABSOLUTE_VALUE(displacement);
      require_action(difference < X86_64_RIP_RELATIVE_LIMIT, finish, 
          rval=KERN_FAILURE;
          kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogRelocationOverflow));
  
      *instr32 = (int32_t) displacement;
      rval = KERN_SUCCESS;
  
  finish:
      return rval;
  }
  #endif /* KXLD_USER_OR_X86_64 */
  
  #if KXLD_USER_OR_ARM
  /*******************************************************************************
  *******************************************************************************/
  static boolean_t 
  arm_reloc_has_pair(u_int _type)
  {
      enum reloc_type_arm type = _type;
  
      switch(type) {
      case ARM_RELOC_SECTDIFF:
          return TRUE;
      default:
          return FALSE;
      }
      return FALSE;
  }
  
  /*******************************************************************************
  *******************************************************************************/
  static boolean_t 
  arm_reloc_is_pair(u_int _type, u_int _prev_type __unused)
  {
      enum reloc_type_arm type = _type;
  
      return (type == ARM_RELOC_PAIR);
  }
  
  /*******************************************************************************
  *******************************************************************************/
  static boolean_t 
  arm_reloc_has_got(u_int _type __unused)
  {
      return FALSE;
  }
  
  /*******************************************************************************
  *******************************************************************************/
  static kern_return_t 
  arm_process_reloc(u_char *instruction, u_int length, u_int pcrel,
      kxld_addr_t _base_pc __unused, kxld_addr_t _link_pc __unused, kxld_addr_t _link_disp __unused,
      u_int _type __unused, kxld_addr_t _target __unused, kxld_addr_t _pair_target __unused, 
      boolean_t swap __unused)
  {
      kern_return_t rval = KERN_FAILURE;
      uint32_t *instr_addr = NULL;
      uint32_t instr_data = 0;
      uint32_t base_pc = (uint32_t) _base_pc;
      uint32_t link_pc = (uint32_t) _link_pc;
      uint32_t target = (uint32_t) _target;
      int32_t displacement = 0;
      enum reloc_type_arm type = _type;
  
      check(instruction);
      require_action(length == 2, finish, rval=KERN_FAILURE);
  
      if (pcrel) displacement = target + base_pc - link_pc;
  
      instr_addr = (uint32_t *)instruction;
      instr_data = *instr_addr;
      
  #if !KERNEL
      if (swap) instr_data = OSSwapInt32(instr_data);
  #endif
  
      switch (type) {
      case ARM_RELOC_VANILLA:
          require_action(!pcrel, finish, rval=KERN_FAILURE);
          instr_data += target;
          break;
  
      /*
       * If the displacement is 0 (the offset between the pc and the target has
       * not changed), then we don't need to do anything for BR24 and BR22
       * relocs.  As it turns out, because kexts build with -mlong-calls all
       * relocations currently end up being either vanilla (handled above) or 
       * BR22/BR24 with a displacement of 0.
       * We could handle other displacements here but to keep things simple, we
       * won't until it is needed (at which point the kernelcache will fail to
       * link)
       */
      case ARM_RELOC_BR24:
          require_action(pcrel, finish, rval=KERN_FAILURE);
          require_action(displacement == 0, finish, rval=KERN_FAILURE);
          break;
      case ARM_THUMB_RELOC_BR22:
          require_action(pcrel, finish, rval=KERN_FAILURE);
          require_action(displacement == 0, finish, rval=KERN_FAILURE);
          break;
  
      case ARM_RELOC_SECTDIFF:
      case ARM_RELOC_LOCAL_SECTDIFF:
      case ARM_RELOC_PB_LA_PTR:
          rval = KERN_FAILURE;
          goto finish;
  
      case ARM_RELOC_PAIR:
      default:
          rval = KERN_FAILURE;
          goto finish;
      }
  
  #if !KERNEL
      if (swap) instr_data = OSSwapInt32(instr_data);
  #endif
  
      *instr_addr = instr_data;
  
      rval = KERN_SUCCESS;
  
  finish:
      return rval;
  }
  
  #endif /* KXLD_USER_OR_ARM */
  

Cache object: 0d05eacc37b436da8b7f8f7e259c0200