--- /dev/null
+/*
+ * 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>
+#include <stdint.h>
+#include <sys/types.h>
+#include <mach-o/nlist.h>
+#include <mach-o/stab.h>
+
+#define DEBUG_ASSERT_COMPONENT_NAME_STRING "kxld"
+#include <AssertMacros.h>
+
+#include "kxld_sect.h"
+#include "kxld_sym.h"
+#include "kxld_util.h"
+
+#define CXX_PREFIX "__Z"
+#define VTABLE_PREFIX CXX_PREFIX "TV"
+#define OSOBJ_PREFIX CXX_PREFIX "N"
+#define RESERVED_TOKEN "_RESERVED"
+#define METACLASS_TOKEN "10gMetaClassE"
+#define SUPER_METACLASS_POINTER_TOKEN "10superClassE"
+#define METACLASS_VTABLE_PREFIX VTABLE_PREFIX "N"
+#define METACLASS_VTABLE_SUFFIX "9MetaClassE"
+#define CXX_PURE_VIRTUAL "___cxa_pure_virtual"
+#define FINAL_CLASS_TOKEN "14__OSFinalClassEv"
+
+/*******************************************************************************
+* Prototypes
+*******************************************************************************/
+
+static kern_return_t init_predicates(KXLDSym *sym, u_char n_type, u_short n_desc)
+ __attribute__((nonnull));
+static void init_sym_sectnum(KXLDSym *sym, u_int n_sect)
+ __attribute__((nonnull));
+static kern_return_t extract_inner_string(const char *str, const char *prefix,
+ const char *suffix, char *buf, u_long len);
+
+#if KXLD_USER_OR_ILP32
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_init_from_macho32(KXLDSym *sym, char *strtab, const struct nlist *src)
+{
+ kern_return_t rval = KERN_FAILURE;
+
+ check(sym);
+ check(strtab);
+ check(src);
+
+ bzero(sym, sizeof(*sym));
+ sym->name = strtab + src->n_un.n_strx;
+ sym->type = src->n_type;
+ sym->desc = src->n_desc;
+ sym->base_addr = src->n_value;
+ sym->link_addr = sym->base_addr;
+
+ rval = init_predicates(sym, src->n_type, src->n_desc);
+ require_noerr(rval, finish);
+
+ (void) init_sym_sectnum(sym, src->n_sect);
+
+ if (kxld_sym_is_indirect(sym)) {
+ sym->alias = strtab + src->n_value;
+ }
+
+ rval = KERN_SUCCESS;
+
+finish:
+ return rval;
+}
+#endif /* KXLD_USER_OR_ILP32 */
+
+#if KXLD_USER_OR_LP64
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_init_from_macho64(KXLDSym *sym, char *strtab, const struct nlist_64 *src)
+{
+ kern_return_t rval = KERN_FAILURE;
+
+ check(sym);
+ check(strtab);
+ check(src);
+
+ bzero(sym, sizeof(*sym));
+ sym->name = strtab + src->n_un.n_strx;
+ sym->type = src->n_type;
+ sym->desc = src->n_desc;
+ sym->base_addr = src->n_value;
+ sym->link_addr = sym->base_addr;
+
+ rval = init_predicates(sym, src->n_type, src->n_desc);
+ require_noerr(rval, finish);
+
+ (void) init_sym_sectnum(sym, src->n_sect);
+
+ if (kxld_sym_is_indirect(sym)) {
+ sym->alias = strtab + src->n_value;
+ }
+
+ rval = KERN_SUCCESS;
+
+finish:
+ return rval;
+}
+#endif /* KXLD_USER_OR_LP64 */
+
+/*******************************************************************************
+*******************************************************************************/
+void
+kxld_sym_init_absolute(KXLDSym *sym, char *name, kxld_addr_t link_addr)
+{
+ check(sym);
+ check(name);
+
+ bzero(sym, sizeof(*sym));
+
+ sym->name = name;
+ sym->link_addr = link_addr;
+ sym->type = N_ABS | N_EXT;
+ sym->sectnum = NO_SECT;
+
+ init_predicates(sym, N_ABS | N_EXT, 0);
+ sym->predicates.is_resolved = TRUE;
+}
+
+/*******************************************************************************
+*******************************************************************************/
+static kern_return_t
+init_predicates(KXLDSym *sym, u_char n_type, u_short n_desc)
+{
+ kern_return_t rval = KERN_FAILURE;
+
+ check(sym);
+
+ /* The type field is interpreted differently for normal symbols and stabs */
+ if (n_type & N_STAB) {
+ sym->predicates.is_stab = 1;
+
+ switch (n_type) {
+ /* Labeled as NO_SECT in stab.h */
+ case N_GSYM:
+ case N_FNAME:
+ case N_RSYM:
+ case N_SSYM:
+ case N_LSYM:
+ case N_BINCL:
+ case N_PARAMS:
+ case N_VERSION:
+ case N_OLEVEL:
+ case N_PSYM:
+ case N_EINCL:
+ case N_LBRAC:
+ case N_EXCL:
+ case N_RBRAC:
+ case N_BCOMM:
+ case N_LENG:
+ case N_OPT:
+ case N_OSO:
+ sym->predicates.is_absolute = 1;
+ break;
+ /* Labeled as n_sect in stab.h */
+ case N_FUN:
+ case N_STSYM:
+ case N_LCSYM:
+ case N_BNSYM:
+ case N_SLINE:
+ case N_ENSYM:
+ case N_SO:
+ case N_SOL:
+ case N_ENTRY:
+ case N_ECOMM:
+ case N_ECOML:
+ sym->predicates.is_section = 1;
+ break;
+ default:
+ rval = KERN_FAILURE;
+ kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
+ "Invalid N_STAB symbol type: %u.", n_type);
+ goto finish;
+ }
+
+ /* Don't care about the C++ predicates for stabs */
+
+ } else {
+ u_char type = n_type & N_TYPE;
+
+ /* Set the type-independent fields */
+ if ((n_type & N_EXT) && !(n_type & N_PEXT)) {
+ sym->predicates.is_external = 1;
+ }
+
+ if (n_desc & N_DESC_DISCARDED) {
+ sym->predicates.is_obsolete = 1;
+ }
+
+ if (n_desc & N_WEAK_REF) {
+ sym->predicates.is_weak = 1;
+ }
+
+ if (n_desc & N_ARM_THUMB_DEF) {
+ sym->predicates.is_thumb = 1;
+ }
+
+ /* The first set of type fields are mutually exclusive, so they can be
+ * set with a switch statement.
+ */
+ switch (type) {
+ case N_ABS:
+ sym->predicates.is_absolute = 1;
+ break;
+ case N_SECT:
+ sym->predicates.is_section = 1;
+ break;
+ case N_UNDF:
+ if (sym->base_addr) {
+ sym->predicates.is_common = 1;
+ } else {
+ sym->predicates.is_undefined = 1;
+ }
+ break;
+ case N_INDR:
+ sym->predicates.is_indirect = 1;
+ break;
+ default:
+ rval = KERN_FAILURE;
+ kxld_log(kKxldLogLinking, kKxldLogErr, kKxldLogMalformedMachO
+ "Invalid symbol type: %u.", type);
+ goto finish;
+ }
+
+ /* Set the C++-specific fields */
+ if ((0 == strncmp(CXX_PREFIX, sym->name, const_strlen(CXX_PREFIX)))) {
+ sym->predicates.is_cxx = 1;
+
+ if (0 == strncmp(sym->name, METACLASS_VTABLE_PREFIX,
+ const_strlen(METACLASS_VTABLE_PREFIX)))
+ {
+ sym->predicates.is_meta_vtable = 1;
+ } else if (0 == strncmp(sym->name, VTABLE_PREFIX,
+ const_strlen(VTABLE_PREFIX)))
+ {
+ sym->predicates.is_class_vtable = 1;
+ } else if (kxld_strstr(sym->name, RESERVED_TOKEN)) {
+ sym->predicates.is_padslot = 1;
+ } else if (kxld_strstr(sym->name, METACLASS_TOKEN)) {
+ sym->predicates.is_metaclass = 1;
+ } else if (kxld_strstr(sym->name, SUPER_METACLASS_POINTER_TOKEN)) {
+ sym->predicates.is_super_metaclass_pointer = 1;
+ }
+ } else if (streq_safe(CXX_PURE_VIRTUAL, sym->name, sizeof(CXX_PURE_VIRTUAL))) {
+ sym->predicates.is_cxx = 1;
+ sym->predicates.is_pure_virtual = 1;
+ }
+ }
+
+ rval = KERN_SUCCESS;
+
+finish:
+ return rval;
+}
+
+/*******************************************************************************
+*******************************************************************************/
+static void
+init_sym_sectnum(KXLDSym *sym, u_int n_sect)
+{
+ /* The n_sect field is set to 0 when the symbol is not section-based, and
+ * the number of the section in which the symbol exists otherwise.
+ * Sometimes, symbols can be labeled as section-based, so we make sure that
+ * they have a valid section number, and set them as absolute if they don't.
+ */
+
+ if (kxld_sym_is_section(sym)) {
+ if (n_sect) {
+ /* Convert the section number to an index into the section index */
+ sym->sectnum = n_sect - 1;
+ } else {
+ sym->predicates.is_absolute = 1;
+ sym->predicates.is_section = 0;
+ }
+ }
+
+}
+
+/*******************************************************************************
+*******************************************************************************/
+void
+kxld_sym_deinit(KXLDSym *sym __unused)
+{
+ check(sym);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+void
+kxld_sym_destroy(KXLDSym *sym)
+{
+ check(sym);
+ kxld_sym_deinit(sym);
+ kxld_free(sym, sizeof(*sym));
+}
+
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_absolute(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_absolute);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_section(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_section);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_defined(const KXLDSym *sym)
+{
+ check(sym);
+
+ return ((kxld_sym_is_absolute(sym) || kxld_sym_is_section(sym)) &&
+ !sym->predicates.is_replaced);
+}
+
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_defined_locally(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (kxld_sym_is_defined(sym) && !sym->predicates.is_resolved);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_external(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_external);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_exported(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (kxld_sym_is_defined_locally(sym) && kxld_sym_is_external(sym));
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_undefined(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_undefined);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_indirect(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_indirect);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_common(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_common);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_unresolved(const KXLDSym *sym)
+{
+ return ((kxld_sym_is_undefined(sym) && !sym->predicates.is_replaced) ||
+ kxld_sym_is_indirect(sym) || kxld_sym_is_common(sym));
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_obsolete(const KXLDSym *sym)
+{
+ return (0 != sym->predicates.is_obsolete);
+}
+
+#if KXLD_USER_OR_GOT
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_got(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_got);
+}
+#endif /* KXLD_USER_OR_GOT */
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_stab(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_stab);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_weak(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_weak);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_cxx(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_cxx);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_pure_virtual(const KXLDSym *sym)
+{
+ return (0 != sym->predicates.is_pure_virtual);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_vtable(const KXLDSym *sym)
+{
+ check(sym);
+
+ return kxld_sym_is_class_vtable(sym) || kxld_sym_is_metaclass_vtable(sym);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_class_vtable(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_class_vtable);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_metaclass_vtable(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_meta_vtable);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_padslot(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_padslot);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_metaclass(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_metaclass);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_is_super_metaclass_pointer(const KXLDSym *sym)
+{
+ check(sym);
+
+ return (0 != sym->predicates.is_super_metaclass_pointer);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+boolean_t
+kxld_sym_name_is_padslot(const char *name)
+{
+ check(name);
+
+ return (kxld_strstr(name, RESERVED_TOKEN) != 0);
+}
+
+/*******************************************************************************
+*******************************************************************************/
+u_int
+kxld_sym_get_section_offset(const KXLDSym *sym, const KXLDSect *sect)
+{
+ check(sym);
+
+ return (u_int) (sym->base_addr - sect->base_addr);
+}
+
+#if KXLD_USER_OR_COMMON
+/*******************************************************************************
+*******************************************************************************/
+kxld_size_t
+kxld_sym_get_common_size(const KXLDSym *sym)
+{
+ return sym->base_addr;
+}
+
+/*******************************************************************************
+*******************************************************************************/
+u_int
+kxld_sym_get_common_align(const KXLDSym *sym)
+{
+ u_int align = GET_COMM_ALIGN(sym->desc);
+ if (!align) align = 3;
+
+ return align;
+}
+#endif /* KXLD_USER_OR_COMMON */
+
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_get_class_name_from_metaclass(const KXLDSym *sym,
+ char class_name[], u_long class_name_len)
+{
+ kern_return_t rval = KERN_FAILURE;
+
+ check(sym);
+ require_action(kxld_sym_is_metaclass(sym), finish, rval=KERN_FAILURE);
+
+ rval = extract_inner_string(sym->name, OSOBJ_PREFIX, METACLASS_TOKEN,
+ class_name, class_name_len);
+ require_noerr(rval, finish);
+
+ rval = KERN_SUCCESS;
+finish:
+ return rval;
+}
+
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_get_class_name_from_super_metaclass_pointer(const KXLDSym *sym,
+ char class_name[], u_long class_name_len)
+{
+ kern_return_t rval = KERN_FAILURE;
+
+ check(sym);
+ require_action(kxld_sym_is_super_metaclass_pointer(sym), finish,
+ rval=KERN_FAILURE);
+
+ rval = extract_inner_string(sym->name, OSOBJ_PREFIX,
+ SUPER_METACLASS_POINTER_TOKEN, class_name, class_name_len);
+ require_noerr(rval, finish);
+
+ rval = KERN_SUCCESS;
+finish:
+ return rval;
+}
+
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_get_class_name_from_vtable(const KXLDSym *sym,
+ char class_name[], u_long class_name_len)
+{
+ kern_return_t rval = KERN_FAILURE;
+
+ check(sym);
+ require_action(kxld_sym_is_class_vtable(sym), finish, rval=KERN_FAILURE);
+
+ rval = kxld_sym_get_class_name_from_vtable_name(sym->name,
+ class_name, class_name_len);
+ require_noerr(rval, finish);
+
+ rval = KERN_SUCCESS;
+
+finish:
+ return rval;
+}
+
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_get_class_name_from_vtable_name(const char *vtable_name,
+ char class_name[], u_long class_name_len)
+{
+ kern_return_t rval = KERN_FAILURE;
+
+ check(vtable_name);
+
+ rval = extract_inner_string(vtable_name, VTABLE_PREFIX, NULL,
+ class_name, class_name_len);
+ require_noerr(rval, finish);
+
+ rval = KERN_SUCCESS;
+finish:
+ return rval;
+}
+
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_get_vtable_name_from_class_name(const char *class_name,
+ char vtable_name[], u_long vtable_name_len)
+{
+ kern_return_t rval = KERN_FAILURE;
+ u_long outlen = 0;
+
+ check(class_name);
+ check(vtable_name);
+
+ outlen = strlcpy(vtable_name, VTABLE_PREFIX, vtable_name_len);
+ require_action(outlen < vtable_name_len, finish,
+ rval=KERN_FAILURE);
+
+ outlen = strlcat(vtable_name, class_name, vtable_name_len);
+ require_action(outlen < vtable_name_len, finish,
+ rval=KERN_FAILURE);
+
+ rval = KERN_SUCCESS;
+finish:
+ return rval;
+}
+
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_get_meta_vtable_name_from_class_name(const char *class_name,
+ char meta_vtable_name[], u_long meta_vtable_name_len)
+{
+ kern_return_t rval = KERN_FAILURE;
+ u_long outlen = 0;
+
+ check(class_name);
+ check(meta_vtable_name);
+
+ outlen = strlcpy(meta_vtable_name, METACLASS_VTABLE_PREFIX,
+ meta_vtable_name_len);
+ require_action(outlen < meta_vtable_name_len, finish,
+ rval=KERN_FAILURE);
+
+ outlen = strlcat(meta_vtable_name, class_name, meta_vtable_name_len);
+ require_action(outlen < meta_vtable_name_len, finish,
+ rval=KERN_FAILURE);
+
+ outlen = strlcat(meta_vtable_name, METACLASS_VTABLE_SUFFIX,
+ meta_vtable_name_len);
+ require_action(outlen < meta_vtable_name_len, finish,
+ rval=KERN_FAILURE);
+
+ rval = KERN_SUCCESS;
+finish:
+ return rval;
+}
+
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_get_final_sym_name_from_class_name(const char *class_name,
+ char final_sym_name[], u_long final_sym_name_len)
+{
+ kern_return_t rval = KERN_FAILURE;
+ u_long outlen = 0;
+
+ check(class_name);
+ check(final_sym_name);
+
+ outlen = strlcpy(final_sym_name, OSOBJ_PREFIX, final_sym_name_len);
+ require_action(outlen < final_sym_name_len, finish,
+ rval=KERN_FAILURE);
+
+ outlen = strlcat(final_sym_name, class_name, final_sym_name_len);
+ require_action(outlen < final_sym_name_len, finish,
+ rval=KERN_FAILURE);
+
+ outlen = strlcat(final_sym_name, FINAL_CLASS_TOKEN, final_sym_name_len);
+ require_action(outlen < final_sym_name_len, finish,
+ rval=KERN_FAILURE);
+
+ rval = KERN_SUCCESS;
+
+finish:
+ return rval;
+}
+
+/*******************************************************************************
+*******************************************************************************/
+u_long
+kxld_sym_get_function_prefix_from_class_name(const char *class_name,
+ char function_prefix[], u_long function_prefix_len)
+{
+ u_long rval = 0;
+ u_long outlen = 0;
+
+ check(class_name);
+ check(function_prefix);
+
+ outlen = strlcpy(function_prefix, OSOBJ_PREFIX, function_prefix_len);
+ require(outlen < function_prefix_len, finish);
+
+ outlen = strlcat(function_prefix, class_name, function_prefix_len);
+ require(outlen < function_prefix_len, finish);
+
+ rval = outlen;
+finish:
+ return rval;
+}
+
+/*******************************************************************************
+*******************************************************************************/
+static kern_return_t
+extract_inner_string(const char *str, const char *prefix, const char *suffix,
+ char *buf, u_long len)
+{
+ kern_return_t rval = KERN_FAILURE;
+ u_long prelen = 0, suflen = 0, striplen = 0;
+
+ check(str);
+ check(buf);
+
+ prelen = (prefix) ? strlen(prefix) : 0;
+ suflen = (suffix) ? strlen(suffix) : 0;
+ striplen = strlen(str) - prelen - suflen;
+
+ require_action(striplen < len, finish, rval=KERN_FAILURE);
+
+ strncpy(buf, str + prelen, striplen);
+ buf[striplen] = '\0';
+
+ rval = KERN_SUCCESS;
+finish:
+ return rval;
+}
+
+#if KXLD_USER_OR_GOT
+/*******************************************************************************
+*******************************************************************************/
+void
+kxld_sym_set_got(KXLDSym *sym)
+{
+ sym->predicates.is_got = 1;
+}
+#endif /* KXLD_USER_OR_GOT */
+
+/*******************************************************************************
+*******************************************************************************/
+void
+kxld_sym_relocate(KXLDSym *sym, const KXLDSect *sect)
+{
+ if (kxld_sym_is_section(sym)) {
+ sym->link_addr = sym->base_addr - sect->base_addr + sect->link_addr;
+ sym->relocated_sectnum = sect->sectnum;
+ }
+}
+
+#if KXLD_USER_OR_ILP32
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_export_macho_32(const KXLDSym *sym, u_char *_nl, char *strtab,
+ u_long *stroff, u_long strsize, boolean_t is_link_state)
+{
+ kern_return_t rval = KERN_FAILURE;
+ struct nlist *nl = (struct nlist *) _nl;
+ char *str = NULL;
+ long bytes = 0;
+
+ check(sym);
+ check(nl);
+ check(strtab);
+ check(stroff);
+
+ bytes = strlen(sym->name) + 1;
+ require_action((u_long)bytes <= strsize - *stroff, finish,
+ rval = KERN_FAILURE);
+
+ if (is_link_state) {
+ nl->n_type = N_ABS | N_EXT;
+ nl->n_sect = NO_SECT;
+ nl->n_desc = 0;
+ } else {
+ nl->n_type = sym->type;
+ nl->n_sect = (kxld_sym_is_section(sym)) ? sym->relocated_sectnum + 1 : 0;
+ nl->n_desc = sym->desc;
+ }
+ nl->n_un.n_strx = (uint32_t) *stroff;
+ nl->n_value = (uint32_t) sym->link_addr;
+
+ str = (char *) (strtab + *stroff);
+ strlcpy(str, sym->name, strsize - *stroff);
+
+ *stroff += bytes;
+ rval = KERN_SUCCESS;
+
+finish:
+ return rval;
+}
+#endif /* KXLD_USER_OR_ILP32 */
+
+#if KXLD_USER_OR_LP64
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_export_macho_64(const KXLDSym *sym, u_char *_nl, char *strtab,
+ u_long *stroff, u_long strsize, boolean_t is_link_state)
+{
+ kern_return_t rval = KERN_FAILURE;
+ struct nlist_64 *nl = (struct nlist_64 *) _nl;
+ char *str = NULL;
+ long bytes = 0;
+
+ check(sym);
+ check(nl);
+ check(strtab);
+ check(stroff);
+
+ bytes = strlen(sym->name) + 1;
+ require_action((u_long)bytes <= strsize - *stroff, finish,
+ rval = KERN_FAILURE);
+
+ if (is_link_state) {
+ nl->n_type = N_ABS | N_EXT;
+ nl->n_sect = NO_SECT;
+ nl->n_desc = 0;
+ } else {
+ nl->n_type = sym->type;
+ nl->n_sect = (kxld_sym_is_section(sym)) ? sym->relocated_sectnum + 1 : 0;
+ nl->n_desc = sym->desc;
+ }
+ nl->n_un.n_strx = (uint32_t) *stroff;
+ nl->n_value = (uint64_t) sym->link_addr;
+
+ str = (char *) (strtab + *stroff);
+ strlcpy(str, sym->name, strsize - *stroff);
+
+ *stroff += bytes;
+ rval = KERN_SUCCESS;
+
+finish:
+ return rval;
+}
+#endif /* KXLD_USER_OR_LP64 */
+
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_resolve(KXLDSym *sym, kxld_addr_t addr, boolean_t export_sym)
+{
+ kern_return_t rval = KERN_FAILURE;
+
+ check(sym);
+
+ require_action(kxld_sym_is_undefined(sym) || kxld_sym_is_indirect(sym),
+ finish, rval=KERN_FAILURE);
+
+ /* Set the n_list data types */
+
+ sym->link_addr = addr;
+ sym->type = N_ABS | N_EXT;
+ sym->sectnum = NO_SECT;
+
+ /* Set the predicate bits for an externally resolved symbol. We re-export
+ * indirect symbols and any symbols that the caller wants re-exported (for
+ * example, symbols from a pseudo-kext). */
+
+ sym->predicates.is_external = TRUE;
+ sym->predicates.is_absolute = TRUE;
+ sym->predicates.is_resolved = !(kxld_sym_is_indirect(sym) || export_sym);
+
+ /* Clear the predicate bits for types that can be resolved */
+
+ sym->predicates.is_undefined = FALSE;
+ sym->predicates.is_indirect = FALSE;
+
+ rval = KERN_SUCCESS;
+
+finish:
+
+ return rval;
+}
+
+#if KXLD_USER_OR_COMMON
+/*******************************************************************************
+*******************************************************************************/
+kern_return_t
+kxld_sym_resolve_common(KXLDSym *sym, u_int sectnum, kxld_addr_t base_addr)
+{
+ kern_return_t rval = KERN_FAILURE;
+
+ check(sym);
+
+ require_action(kxld_sym_is_common(sym), finish,
+ rval=KERN_FAILURE);
+
+ sym->base_addr = base_addr;
+ sym->link_addr = base_addr;
+ sym->type = N_SECT | N_EXT;
+ sym->sectnum = sectnum;
+ sym->desc = 0;
+
+ sym->predicates.is_absolute = FALSE;
+ sym->predicates.is_section = TRUE;
+ sym->predicates.is_undefined = FALSE;
+ sym->predicates.is_indirect = FALSE;
+ sym->predicates.is_common = FALSE;
+ sym->predicates.is_external = TRUE;
+
+ rval = KERN_SUCCESS;
+
+finish:
+
+ return rval;
+}
+#endif /* KXLD_USER_OR_COMMON */
+
+/*******************************************************************************
+*******************************************************************************/
+void
+kxld_sym_delete(KXLDSym *sym)
+{
+ check(sym);
+
+ bzero(sym, sizeof(*sym));
+ sym->predicates.is_replaced = TRUE;
+}
+
+
+/*******************************************************************************
+*******************************************************************************/
+void
+kxld_sym_patch(KXLDSym *sym)
+{
+ check(sym);
+
+ sym->predicates.is_replaced = TRUE;
+}
+
+/*******************************************************************************
+*******************************************************************************/
+void
+kxld_sym_mark_private(KXLDSym *sym)
+{
+ check(sym);
+
+ sym->type |= N_PEXT;
+ sym->predicates.is_external = FALSE;
+}
+
projects / apple / xnu.git / blobdiff