/* * 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 #include #include #include #if KERNEL #include #else #include #include #endif #define DEBUG_ASSERT_COMPONENT_NAME_STRING "kxld" #include #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 #if KXLD_USER_OR_PPC #include #endif #if KXLD_USER_OR_X86_64 #include #endif #if KXLD_USER_OR_ARM #include #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 */