1 /* 2 * Copyright (c) 2008 Apple Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28 #ifndef _KXLD_SYMBOL_H_ 29 #define _KXLD_SYMBOL_H_ 30 31 #include <sys/types.h> 32 #if KERNEL 33 #include <libkern/kxld_types.h> 34 #else 35 #include "kxld_types.h" 36 #endif 37 38 struct kxld_sect; 39 struct nlist; 40 struct nlist_64; 41 typedef struct kxld_sym KXLDSym; 42 typedef boolean_t (*KXLDSymPredicateTest)(const KXLDSym *sym); 43 44 struct kxld_sym { 45 char *name; // The symbol's name 46 char *alias; // The indirect symbol's alias name 47 kxld_addr_t base_addr; // The symbol's base address 48 kxld_addr_t link_addr; // The relocated address 49 kxld_addr_t got_addr; // The address of this symbol's GOT entry 50 uint16_t desc; 51 uint8_t type; 52 uint8_t sectnum; // The symbol's section number 53 uint8_t relocated_sectnum; 54 u_int is_absolute:1, // Set for absolute symbols 55 is_section:1, // Set for section symbols 56 is_undefined:1, // Set for undefined symbols 57 is_indirect:1, // Set for indirect symbols 58 is_common:1, // Set for common symbols 59 is_external:1, // Set for external symbols 60 is_stab:1, // Set for stab symbols 61 is_weak:1, // Set for weak definition symbols 62 is_resolved:1, // For symbols that have been resolved 63 // externally and should not be exported 64 is_obsolete:1, // For symbols marked as obsolete 65 is_replaced:1, // Set for symbols replaced by patching 66 is_got:1, // Has an entry in the GOT 67 is_cxx:1, // Set for C++ symbols 68 is_pure_virtual:1, // Set for pure virtual symbols 69 is_class_vtable:1, // Set for vtable symbols of classes 70 is_meta_vtable:1, // Set for vtable symbols of MetaClasses 71 is_padslot:1, // Set for pad slot symbols 72 is_metaclass:1, // Set for metaclass symbols 73 is_super_metaclass_pointer:1, // Set for super metaclass pointer syms 74 is_thumb:1; // Set for thumb symbols (ARM only) 75 }; 76 77 /******************************************************************************* 78 * Constructors and destructors 79 *******************************************************************************/ 80 81 #if KXLD_USER_OR_ILP32 82 kern_return_t kxld_sym_init_from_macho32(KXLDSym *sym, char *strtab, 83 const struct nlist *src) __attribute__((nonnull, visibility("hidden"))); 84 #endif 85 86 #if KXLD_USER_OR_LP64 87 kern_return_t kxld_sym_init_from_macho64(KXLDSym *sym, char *strtab, 88 const struct nlist_64 *src) __attribute__((nonnull, visibility("hidden"))); 89 #endif 90 91 void kxld_sym_init_absolute(KXLDSym *sym, char *name, kxld_addr_t link_addr) 92 __attribute__((nonnull, visibility("hidden"))); 93 94 void kxld_sym_deinit(KXLDSym *sym) 95 __attribute__((nonnull, visibility("hidden"))); 96 97 void kxld_sym_destroy(KXLDSym *sym) 98 __attribute__((nonnull, visibility("hidden"))); 99 100 /******************************************************************************* 101 * Accessors 102 *******************************************************************************/ 103 104 boolean_t kxld_sym_is_absolute(const KXLDSym *sym) 105 __attribute__((pure, nonnull, visibility("hidden"))); 106 107 boolean_t kxld_sym_is_section(const KXLDSym *sym) 108 __attribute__((pure, nonnull, visibility("hidden"))); 109 110 boolean_t kxld_sym_is_defined(const KXLDSym *sym) 111 __attribute__((pure, nonnull, visibility("hidden"))); 112 113 boolean_t kxld_sym_is_defined_locally(const KXLDSym *sym) 114 __attribute__((pure, nonnull, visibility("hidden"))); 115 116 boolean_t kxld_sym_is_external(const KXLDSym *sym) 117 __attribute__((pure, nonnull, visibility("hidden"))); 118 119 boolean_t kxld_sym_is_exported(const KXLDSym *sym) 120 __attribute__((pure, nonnull, visibility("hidden"))); 121 122 boolean_t kxld_sym_is_undefined(const KXLDSym *sym) 123 __attribute__((pure, nonnull, visibility("hidden"))); 124 125 boolean_t kxld_sym_is_indirect(const KXLDSym *sym) 126 __attribute__((pure, nonnull, visibility("hidden"))); 127 128 boolean_t kxld_sym_is_replaced(const KXLDSym *sym) 129 __attribute__((pure, nonnull, visibility("hidden"))); 130 131 /* We don't wrap this in KXLD_USER_OR_COMMON because even though common symbols 132 * aren't always supported, we always need to be able to detect them. 133 */ 134 boolean_t kxld_sym_is_common(const KXLDSym *sym) 135 __attribute__((pure, nonnull, visibility("hidden"))); 136 137 boolean_t kxld_sym_is_unresolved(const KXLDSym *sym) 138 __attribute__((pure, nonnull, visibility("hidden"))); 139 140 boolean_t kxld_sym_is_obsolete(const KXLDSym *sym) 141 __attribute__((pure, nonnull, visibility("hidden"))); 142 143 #if KXLD_USER_OR_GOT 144 boolean_t kxld_sym_is_got(const KXLDSym *sym) 145 __attribute__((pure, nonnull, visibility("hidden"))); 146 #endif /* KXLD_USER_OR_GOT */ 147 148 boolean_t kxld_sym_is_stab(const KXLDSym *sym) 149 __attribute__((pure, nonnull, visibility("hidden"))); 150 151 boolean_t kxld_sym_is_weak(const KXLDSym *sym) 152 __attribute__((pure, nonnull, visibility("hidden"))); 153 154 boolean_t kxld_sym_is_cxx(const KXLDSym *sym) 155 __attribute__((pure, nonnull, visibility("hidden"))); 156 157 boolean_t kxld_sym_is_pure_virtual(const KXLDSym *sym) 158 __attribute__((pure, nonnull, visibility("hidden"))); 159 160 boolean_t kxld_sym_is_vtable(const KXLDSym *sym) 161 __attribute__((pure, nonnull, visibility("hidden"))); 162 163 boolean_t kxld_sym_is_class_vtable(const KXLDSym *sym) 164 __attribute__((pure, nonnull, visibility("hidden"))); 165 166 boolean_t kxld_sym_is_metaclass_vtable(const KXLDSym *sym) 167 __attribute__((pure, nonnull, visibility("hidden"))); 168 169 boolean_t kxld_sym_is_padslot(const KXLDSym *sym) 170 __attribute__((pure, nonnull, visibility("hidden"))); 171 172 boolean_t kxld_sym_is_metaclass(const KXLDSym *sym) 173 __attribute__((pure, nonnull, visibility("hidden"))); 174 175 boolean_t kxld_sym_is_super_metaclass_pointer(const KXLDSym *sym) 176 __attribute__((pure, nonnull, visibility("hidden"))); 177 178 boolean_t kxld_sym_name_is_pure_virtual(const char *name) 179 __attribute__((pure, nonnull, visibility("hidden"))); 180 181 boolean_t kxld_sym_name_is_padslot(const char *name) 182 __attribute__((pure, nonnull, visibility("hidden"))); 183 184 u_int kxld_sym_get_section_offset(const KXLDSym *sym, 185 const struct kxld_sect *sect) 186 __attribute__((pure, nonnull, visibility("hidden"))); 187 188 #if KXLD_USER_OR_COMMON 189 kxld_size_t kxld_sym_get_common_size(const KXLDSym *sym) 190 __attribute__((pure, nonnull, visibility("hidden"))); 191 192 u_int kxld_sym_get_common_align(const KXLDSym *sym) 193 __attribute__((pure, nonnull, visibility("hidden"))); 194 #endif /* KXLD_USER_OR_COMMON */ 195 196 kern_return_t kxld_sym_get_class_name_from_metaclass(const KXLDSym *sym, 197 char class_name[], u_long class_name_len) 198 __attribute__((nonnull, visibility("hidden"))); 199 200 kern_return_t kxld_sym_get_class_name_from_super_metaclass_pointer( 201 const KXLDSym *sym, char class_name[], u_long class_name_len) 202 __attribute__((nonnull, visibility("hidden"))); 203 204 kern_return_t kxld_sym_get_class_name_from_vtable(const KXLDSym *sym, 205 char class_name[], u_long class_name_len) 206 __attribute__((nonnull, visibility("hidden"))); 207 208 kern_return_t kxld_sym_get_class_name_from_vtable_name(const char *vtable_name, 209 char class_name[], u_long class_name_len) 210 __attribute__((nonnull, visibility("hidden"))); 211 212 kern_return_t kxld_sym_get_vtable_name_from_class_name(const char *class_name, 213 char vtable_name[], u_long vtable_name_len) 214 __attribute__((nonnull, visibility("hidden"))); 215 216 kern_return_t kxld_sym_get_meta_vtable_name_from_class_name(const char *class_name, 217 char meta_vtable_name[], u_long meta_vtable_name_len) 218 __attribute__((nonnull, visibility("hidden"))); 219 220 kern_return_t kxld_sym_get_final_sym_name_from_class_name(const char *class_name, 221 char final_sym_name[], u_long final_sym_name_len) 222 __attribute__((nonnull, visibility("hidden"))); 223 224 u_long kxld_sym_get_function_prefix_from_class_name(const char *class_name, 225 char function_prefix[], u_long function_prefix_len) 226 __attribute__((nonnull, visibility("hidden"))); 227 228 #if KXLD_USER_OR_ILP32 229 kern_return_t kxld_sym_export_macho_32(const KXLDSym *sym, u_char *nl, 230 char *strtab, u_long *stroff, u_long strsize) 231 __attribute__((nonnull, visibility("hidden"))); 232 #endif 233 234 #if KXLD_USER_OR_LP64 235 kern_return_t kxld_sym_export_macho_64(const KXLDSym *sym, u_char *nl, 236 char *strtab, u_long *stroff, u_long strsize) 237 __attribute__((nonnull, visibility("hidden"))); 238 #endif 239 240 /******************************************************************************* 241 * Mutators 242 *******************************************************************************/ 243 244 void kxld_sym_relocate(KXLDSym *sym, const struct kxld_sect *sect) 245 __attribute__((nonnull, visibility("hidden"))); 246 247 #if KXLD_USER_OR_GOT 248 void kxld_sym_set_got(KXLDSym *sym) 249 __attribute__((nonnull, visibility("hidden"))); 250 #endif /* KXLD_USER_OR_GOT */ 251 252 kern_return_t kxld_sym_resolve(KXLDSym *sym, const kxld_addr_t addr) 253 __attribute__((nonnull, visibility("hidden"))); 254 255 #if KXLD_USER_OR_COMMON 256 kern_return_t kxld_sym_resolve_common(KXLDSym *sym, u_int sectnum, 257 kxld_addr_t base_addr) 258 __attribute__((nonnull, visibility("hidden"))); 259 #endif /* KXLD_USER_OR_COMMON */ 260 261 void kxld_sym_delete(KXLDSym *sym) 262 __attribute__((nonnull, visibility("hidden"))); 263 264 void kxld_sym_patch(KXLDSym *sym) 265 __attribute__((nonnull, visibility("hidden"))); 266 267 void kxld_sym_mark_private(KXLDSym *sym) 268 __attribute__((nonnull, visibility("hidden"))); 269 270 #endif /* _KXLD_SYMBOL_H_ */ 271