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#include <string.h>
29#include <mach-o/loader.h>
30#include <sys/types.h>
31
32#if KERNEL
33 #ifdef MACH_ASSERT
34 #undef MACH_ASSERT
35 #endif
36 #define MACH_ASSERT 1
37 #include <kern/assert.h>
38#else
39 #include <assert.h>
40#endif
41
42#define DEBUG_ASSERT_COMPONENT_NAME_STRING "kxld"
43#include <AssertMacros.h>
44
45#include "kxld_demangle.h"
46#include "kxld_dict.h"
47#include "kxld_object.h"
48#include "kxld_reloc.h"
49#include "kxld_sect.h"
50#include "kxld_sym.h"
51#include "kxld_symtab.h"
52#include "kxld_util.h"
53#include "kxld_vtable.h"
54
55#define VTABLE_ENTRY_SIZE_32 4
56#define VTABLE_HEADER_LEN_32 2
57#define VTABLE_HEADER_SIZE_32 (VTABLE_HEADER_LEN_32 * VTABLE_ENTRY_SIZE_32)
58
59#define VTABLE_ENTRY_SIZE_64 8
60#define VTABLE_HEADER_LEN_64 2
61#define VTABLE_HEADER_SIZE_64 (VTABLE_HEADER_LEN_64 * VTABLE_ENTRY_SIZE_64)
62
63static void get_vtable_base_sizes(boolean_t is_32_bit, u_int *vtable_entry_size,
64 u_int *vtable_header_size);
65
66static kern_return_t init_by_relocs(KXLDVTable *vtable, const KXLDSym *vtable_sym,
67 const KXLDSect *sect, const KXLDRelocator *relocator);
68
69static kern_return_t init_by_entries_and_relocs(KXLDVTable *vtable,
70 const KXLDSym *vtable_sym, const KXLDRelocator *relocator,
71 const KXLDArray *relocs, const KXLDDict *defined_cxx_symbols);
72
73static kern_return_t init_by_entries(KXLDVTable *vtable,
74 const KXLDRelocator *relocator, const KXLDDict *defined_cxx_symbols);
75
76/*******************************************************************************
77*******************************************************************************/
78kern_return_t
79kxld_vtable_init(KXLDVTable *vtable, const KXLDSym *vtable_sym,
80 const KXLDObject *object, const KXLDDict *defined_cxx_symbols)
81{
82 kern_return_t rval = KERN_FAILURE;
83 const KXLDArray *extrelocs = NULL;
84 const KXLDRelocator *relocator = NULL;
85 const KXLDSect *vtable_sect = NULL;
86 char *demangled_name = NULL;
87 size_t demangled_length = 0;
88
89 check(vtable);
90 check(vtable_sym);
91 check(object);
92
93 relocator = kxld_object_get_relocator(object);
94
95 vtable_sect = kxld_object_get_section_by_index(object,
96 vtable_sym->sectnum);
97 require_action(vtable_sect, finish, rval=KERN_FAILURE);
98
99 vtable->name = vtable_sym->name;
100 vtable->vtable = vtable_sect->data +
101 kxld_sym_get_section_offset(vtable_sym, vtable_sect);
102
103 if (kxld_object_is_linked(object)) {
104 rval = init_by_entries(vtable, relocator, defined_cxx_symbols);
105 require_noerr(rval, finish);
106
107 vtable->is_patched = TRUE;
108 } else {
109 if (kxld_object_is_final_image(object)) {
110 extrelocs = kxld_object_get_extrelocs(object);
111
112 require_action(extrelocs, finish,
113 rval=KERN_FAILURE;
114 kxld_log(kKxldLogPatching, kKxldLogErr,
115 kKxldLogMalformedVTable,
116 kxld_demangle(vtable->name,
117 &demangled_name, &demangled_length)));
118
119 rval = init_by_entries_and_relocs(vtable, vtable_sym,
120 relocator, extrelocs, defined_cxx_symbols);
121 require_noerr(rval, finish);
122 } else {
123
124 require_action(kxld_sect_get_num_relocs(vtable_sect) > 0, finish,
125 rval=KERN_FAILURE;
126 kxld_log(kKxldLogPatching, kKxldLogErr,
127 kKxldLogMalformedVTable,
128 kxld_demangle(vtable->name,
129 &demangled_name, &demangled_length)));
130
131 rval = init_by_relocs(vtable, vtable_sym, vtable_sect, relocator);
132 require_noerr(rval, finish);
133 }
134
135 vtable->is_patched = FALSE;
136 }
137
138 rval = KERN_SUCCESS;
139finish:
140
141 if (demangled_name) kxld_free(demangled_name, demangled_length);
142
143 return rval;
144}
145
146/*******************************************************************************
147*******************************************************************************/
148static void
149get_vtable_base_sizes(boolean_t is_32_bit, u_int *vtable_entry_size,
150 u_int *vtable_header_size)
151{
152 check(vtable_entry_size);
153 check(vtable_header_size);
154
155 if (is_32_bit) {
156 *vtable_entry_size = VTABLE_ENTRY_SIZE_32;
157 *vtable_header_size = VTABLE_HEADER_SIZE_32;
158 } else {
159 *vtable_entry_size = VTABLE_ENTRY_SIZE_64;
160 *vtable_header_size = VTABLE_HEADER_SIZE_64;
161 }
162}
163
164/*******************************************************************************
165* Initializes a vtable object by matching up relocation entries to the vtable's
166* entries and finding the corresponding symbols.
167*******************************************************************************/
168static kern_return_t
169init_by_relocs(KXLDVTable *vtable, const KXLDSym *vtable_sym,
170 const KXLDSect *sect, const KXLDRelocator *relocator)
171{
172 kern_return_t rval = KERN_FAILURE;
173 KXLDReloc *reloc = NULL;
174 KXLDVTableEntry *entry = NULL;
175 KXLDSym *sym = NULL;
176 kxld_addr_t vtable_base_offset = 0;
177 kxld_addr_t entry_offset = 0;
178 u_int i = 0;
179 u_int nentries = 0;
180 u_int vtable_entry_size = 0;
181 u_int vtable_header_size = 0;
182 u_int base_reloc_index = 0;
183 u_int reloc_index = 0;
184
185 check(vtable);
186 check(vtable_sym);
187 check(sect);
188 check(relocator);
189
190 /* Find the first entry past the vtable padding */
191
192 (void) get_vtable_base_sizes(relocator->is_32_bit,
193 &vtable_entry_size, &vtable_header_size);
194
195 vtable_base_offset = kxld_sym_get_section_offset(vtable_sym, sect) +
196 vtable_header_size;
197
198 /* Find the relocation entry at the start of the vtable */
199
200 rval = kxld_reloc_get_reloc_index_by_offset(&sect->relocs,
201 vtable_base_offset, &base_reloc_index);
202 require_noerr(rval, finish);
203
204 /* Count the number of consecutive relocation entries to find the number of
205 * vtable entries. For some reason, the __TEXT,__const relocations are
206 * sorted in descending order, so we have to walk backwards. Also, make
207 * sure we don't run off the end of the section's relocs.
208 */
209
210 reloc_index = base_reloc_index;
211 entry_offset = vtable_base_offset;
212 reloc = kxld_array_get_item(&sect->relocs, reloc_index);
213 while (reloc->address == entry_offset) {
214 ++nentries;
215 if (!reloc_index) break;
216
217 --reloc_index;
218
219 reloc = kxld_array_get_item(&sect->relocs, reloc_index);
220 entry_offset += vtable_entry_size;
221 }
222
223 /* Allocate the symbol index */
224
225 rval = kxld_array_init(&vtable->entries, sizeof(KXLDVTableEntry), nentries);
226 require_noerr(rval, finish);
227
228 /* Find the symbols for each vtable entry */
229
230 for (i = 0; i < vtable->entries.nitems; ++i) {
231 reloc = kxld_array_get_item(&sect->relocs, base_reloc_index - i);
232 entry = kxld_array_get_item(&vtable->entries, i);
233
234 /* If we can't find a symbol, it means it is a locally-defined,
235 * non-external symbol that has been stripped. We don't patch over
236 * locally-defined symbols, so we leave the symbol as NULL and just
237 * skip it. We won't be able to patch subclasses with this symbol,
238 * but there isn't much we can do about that.
239 */
240 sym = kxld_reloc_get_symbol(relocator, reloc, sect->data);
241
242 entry->unpatched.sym = sym;
243 entry->unpatched.reloc = reloc;
244 }
245
246 rval = KERN_SUCCESS;
247finish:
248 return rval;
249}
250
251/*******************************************************************************
252* Initializes a vtable object by reading the symbol values out of the vtable
253* entries and performing reverse symbol lookups on those values.
254*******************************************************************************/
255static kern_return_t
256init_by_entries(KXLDVTable *vtable, const KXLDRelocator *relocator,
257 const KXLDDict *defined_cxx_symbols)
258{
259 kern_return_t rval = KERN_FAILURE;
260 KXLDVTableEntry *tmpentry = NULL;
261 KXLDSym *sym = NULL;
262 kxld_addr_t entry_value = 0;
263 u_long entry_offset;
264 u_int vtable_entry_size = 0;
265 u_int vtable_header_size = 0;
266 u_int nentries = 0;
267 u_int i = 0;
268
269 check(vtable);
270 check(relocator);
271
272 (void) get_vtable_base_sizes(relocator->is_32_bit,
273 &vtable_entry_size, &vtable_header_size);
274
275 /* Count the number of entries (the vtable is null-terminated) */
276
277 entry_offset = vtable_header_size;
278 while (1) {
279 entry_value = kxld_relocator_get_pointer_at_addr(relocator,
280 vtable->vtable, entry_offset);
281 if (!entry_value) break;
282
283 entry_offset += vtable_entry_size;
284 ++nentries;
285 }
286
287 /* Allocate the symbol index */
288
289 rval = kxld_array_init(&vtable->entries, sizeof(KXLDVTableEntry), nentries);
290 require_noerr(rval, finish);
291
292 /* Look up the symbols for each entry */
293
294 for (i = 0, entry_offset = vtable_header_size;
295 i < vtable->entries.nitems;
296 ++i, entry_offset += vtable_entry_size)
297 {
298 entry_value = kxld_relocator_get_pointer_at_addr(relocator,
299 vtable->vtable, entry_offset);
300
301 /* If we can't find the symbol, it means that the virtual function was
302 * defined inline. There's not much I can do about this; it just means
303 * I can't patch this function.
304 */
305 tmpentry = kxld_array_get_item(&vtable->entries, i);
306 sym = kxld_dict_find(defined_cxx_symbols, &entry_value);
307
308 if (sym) {
309 tmpentry->patched.name = sym->name;
310 tmpentry->patched.addr = sym->link_addr;
311 } else {
312 tmpentry->patched.name = NULL;
313 tmpentry->patched.addr = 0;
314 }
315 }
316
317 rval = KERN_SUCCESS;
318finish:
319 return rval;
320}
321
322/*******************************************************************************
323* Initializes vtables by performing a reverse lookup on symbol values when
324* they exist in the vtable entry, and by looking through a matching relocation
325* entry when the vtable entry is NULL.
326*
327* Final linked images require this hybrid vtable initialization approach
328* because they are already internally resolved. This means that the vtables
329* contain valid entries to local symbols, but still have relocation entries for
330* external symbols.
331*******************************************************************************/
332static kern_return_t
333init_by_entries_and_relocs(KXLDVTable *vtable, const KXLDSym *vtable_sym,
334 const KXLDRelocator *relocator, const KXLDArray *relocs,
335 const KXLDDict *defined_cxx_symbols)
336{
337 kern_return_t rval = KERN_FAILURE;
338 KXLDReloc *reloc = NULL;
339 KXLDVTableEntry *tmpentry = NULL;
340 KXLDSym *sym = NULL;
341 u_int vtable_entry_size = 0;
342 u_int vtable_header_size = 0;
343 kxld_addr_t entry_value = 0;
344 u_long entry_offset = 0;
345 u_int nentries = 0;
346 u_int i = 0;
347 char *demangled_name1 = NULL;
348 size_t demangled_length1 = 0;
349
350 check(vtable);
351 check(vtable_sym);
352 check(relocator);
353 check(relocs);
354
355 /* Find the first entry and its offset past the vtable padding */
356
357 (void) get_vtable_base_sizes(relocator->is_32_bit,
358 &vtable_entry_size, &vtable_header_size);
359
360 /* In a final linked image, a vtable slot is valid if it is nonzero
361 * (meaning the userspace linker has already resolved it) or if it has
362 * a relocation entry. We'll know the end of the vtable when we find a
363 * slot that meets neither of these conditions.
364 */
365 entry_offset = vtable_header_size;
366 while (1) {
367 entry_value = kxld_relocator_get_pointer_at_addr(relocator,
368 vtable->vtable, entry_offset);
369 if (!entry_value) {
370 reloc = kxld_reloc_get_reloc_by_offset(relocs,
371 vtable_sym->base_addr + entry_offset);
372 if (!reloc) break;
373 }
374
375 ++nentries;
376 entry_offset += vtable_entry_size;
377 }
378
379 /* Allocate the symbol index */
380
381 rval = kxld_array_init(&vtable->entries, sizeof(KXLDVTableEntry), nentries);
382 require_noerr(rval, finish);
383
384 /* Find the symbols for each vtable entry */
385
386 for (i = 0, entry_offset = vtable_header_size;
387 i < vtable->entries.nitems;
388 ++i, entry_offset += vtable_entry_size)
389 {
390 entry_value = kxld_relocator_get_pointer_at_addr(relocator,
391 vtable->vtable, entry_offset);
392
393 /* If we can't find a symbol, it means it is a locally-defined,
394 * non-external symbol that has been stripped. We don't patch over
395 * locally-defined symbols, so we leave the symbol as NULL and just
396 * skip it. We won't be able to patch subclasses with this symbol,
397 * but there isn't much we can do about that.
398 */
399 if (entry_value) {
400 reloc = NULL;
401 sym = kxld_dict_find(defined_cxx_symbols, &entry_value);
402 } else {
403 reloc = kxld_reloc_get_reloc_by_offset(relocs,
404 vtable_sym->base_addr + entry_offset);
405
406 require_action(reloc, finish,
407 rval=KERN_FAILURE;
408 kxld_log(kKxldLogPatching, kKxldLogErr,
409 kKxldLogMalformedVTable,
410 kxld_demangle(vtable->name, &demangled_name1,
411 &demangled_length1)));
412
413 sym = kxld_reloc_get_symbol(relocator, reloc, /* data */ NULL);
414 }
415
416 tmpentry = kxld_array_get_item(&vtable->entries, i);
417 tmpentry->unpatched.reloc = reloc;
418 tmpentry->unpatched.sym = sym;
419 }
420
421 rval = KERN_SUCCESS;
422finish:
423 return rval;
424}
425
426/*******************************************************************************
427*******************************************************************************/
428void
429kxld_vtable_clear(KXLDVTable *vtable)
430{
431 check(vtable);
432
433 vtable->vtable = NULL;
434 vtable->name = NULL;
435 vtable->is_patched = FALSE;
436 kxld_array_clear(&vtable->entries);
437}
438
439/*******************************************************************************
440*******************************************************************************/
441void
442kxld_vtable_deinit(KXLDVTable *vtable)
443{
444 check(vtable);
445
446 kxld_array_deinit(&vtable->entries);
447 bzero(vtable, sizeof(*vtable));
448}
449
450/*******************************************************************************
451*******************************************************************************/
452KXLDVTableEntry *
453kxld_vtable_get_entry_for_offset(const KXLDVTable *vtable, u_long offset,
454 boolean_t is_32_bit)
455{
456 KXLDVTableEntry *rval = NULL;
457 u_int vtable_entry_size = 0;
458 u_int vtable_header_size = 0;
459 u_int vtable_entry_idx = 0;
460
461 (void) get_vtable_base_sizes(is_32_bit,
462 &vtable_entry_size, &vtable_header_size);
463
464 if (offset % vtable_entry_size) {
465 goto finish;
466 }
467
468 vtable_entry_idx = (u_int) ((offset - vtable_header_size) / vtable_entry_size);
469 rval = kxld_array_get_item(&vtable->entries, vtable_entry_idx);
470finish:
471 return rval;
472}
473
474/*******************************************************************************
475* Patching vtables allows us to preserve binary compatibility across releases.
476*******************************************************************************/
477kern_return_t
478kxld_vtable_patch(KXLDVTable *vtable, const KXLDVTable *super_vtable,
479 KXLDObject *object)
480{
481 kern_return_t rval = KERN_FAILURE;
482 const KXLDSymtab *symtab = NULL;
483 const KXLDSym *sym = NULL;
484 KXLDVTableEntry *child_entry = NULL;
485 KXLDVTableEntry *parent_entry = NULL;
486 u_int symindex = 0;
487 u_int i = 0;
488 char *demangled_name1 = NULL;
489 char *demangled_name2 = NULL;
490 char *demangled_name3 = NULL;
491 size_t demangled_length1 = 0;
492 size_t demangled_length2 = 0;
493 size_t demangled_length3 = 0;
494 boolean_t failure = FALSE;
495
496 check(vtable);
497 check(super_vtable);
498
499 symtab = kxld_object_get_symtab(object);
500
501 require_action(!vtable->is_patched, finish, rval=KERN_SUCCESS);
502 require_action(super_vtable->is_patched, finish, rval=KERN_FAILURE);
503 require_action(vtable->entries.nitems >= super_vtable->entries.nitems, finish,
504 rval=KERN_FAILURE;
505 kxld_log(kKxldLogPatching, kKxldLogErr, kKxldLogMalformedVTable,
506 kxld_demangle(vtable->name, &demangled_name1, &demangled_length1)));
507
508 for (i = 0; i < super_vtable->entries.nitems; ++i) {
509 child_entry = kxld_array_get_item(&vtable->entries, i);
510 parent_entry = kxld_array_get_item(&super_vtable->entries, i);
511
512 /* The child entry can be NULL when a locally-defined, non-external
513 * symbol is stripped. We wouldn't patch this entry anyway, so we
514 * just skip it.
515 */
516
517 if (!child_entry->unpatched.sym) continue;
518
519 /* It's possible for the patched parent entry not to have a symbol
520 * (e.g. when the definition is inlined). We can't patch this entry no
521 * matter what, so we'll just skip it and die later if it's a problem
522 * (which is not likely).
523 */
524
525 if (!parent_entry->patched.name) continue;
526
527 /* 1) If the symbol is defined locally, do not patch */
528
529 if (kxld_sym_is_defined_locally(child_entry->unpatched.sym)) continue;
530
531 /* 2) If the child is a pure virtual function, do not patch.
532 * In general, we want to proceed with patching when the symbol is
533 * externally defined because pad slots fall into this category.
534 * The pure virtual function symbol is special case, as the pure
535 * virtual property itself overrides the parent's implementation.
536 */
537
538 if (kxld_sym_is_pure_virtual(child_entry->unpatched.sym)) continue;
539
540 /* 3) If the symbols are the same, do not patch */
541
542 if (streq(child_entry->unpatched.sym->name,
543 parent_entry->patched.name))
544 {
545 continue;
546 }
547
548 /* 4) If the parent vtable entry is a pad slot, and the child does not
549 * match it, then the child was built against a newer version of the
550 * libraries, so it is binary-incompatible.
551 */
552
553 require_action(!kxld_sym_name_is_padslot(parent_entry->patched.name),
554 finish, rval=KERN_FAILURE;
555 kxld_log(kKxldLogPatching, kKxldLogErr,
556 kKxldLogParentOutOfDate,
557 kxld_demangle(super_vtable->name, &demangled_name1,
558 &demangled_length1),
559 kxld_demangle(vtable->name, &demangled_name2,
560 &demangled_length2)));
561
562#if KXLD_USER_OR_STRICT_PATCHING
563 /* 5) If we are doing strict patching, we prevent kexts from declaring
564 * virtual functions and not implementing them. We can tell if a
565 * virtual function is declared but not implemented because we resolve
566 * symbols before patching; an unimplemented function will still be
567 * undefined at this point. We then look at whether the symbol has
568 * the same class prefix as the vtable. If it does, the symbol was
569 * declared as part of the class and not inherited, which means we
570 * should not patch it.
571 */
572
573 if (kxld_object_target_supports_strict_patching(object) &&
574 !kxld_sym_is_defined(child_entry->unpatched.sym))
575 {
576 char class_name[KXLD_MAX_NAME_LEN];
577 char function_prefix[KXLD_MAX_NAME_LEN];
578 u_long function_prefix_len = 0;
579
580 rval = kxld_sym_get_class_name_from_vtable_name(vtable->name,
581 class_name, sizeof(class_name));
582 require_noerr(rval, finish);
583
584 function_prefix_len =
585 kxld_sym_get_function_prefix_from_class_name(class_name,
586 function_prefix, sizeof(function_prefix));
587 require(function_prefix_len, finish);
588
589 if (!strncmp(child_entry->unpatched.sym->name,
590 function_prefix, function_prefix_len))
591 {
592 failure = TRUE;
593 kxld_log(kKxldLogPatching, kKxldLogErr,
594 "The %s is unpatchable because its class declares the "
595 "method '%s' without providing an implementation.",
596 kxld_demangle(vtable->name,
597 &demangled_name1, &demangled_length1),
598 kxld_demangle(child_entry->unpatched.sym->name,
599 &demangled_name2, &demangled_length2));
600 continue;
601 }
602 }
603#endif /* KXLD_USER_OR_STRICT_PATCHING */
604
605 /* 6) The child symbol is unresolved and different from its parent, so
606 * we need to patch it up. We do this by modifying the relocation
607 * entry of the vtable entry to point to the symbol of the parent
608 * vtable entry. If that symbol does not exist (i.e. we got the data
609 * from a link state object's vtable representation), then we create a
610 * new symbol in the symbol table and point the relocation entry to
611 * that.
612 */
613
614 sym = kxld_symtab_get_locally_defined_symbol_by_name(symtab,
615 parent_entry->patched.name);
616 if (!sym) {
617 rval = kxld_object_add_symbol(object, parent_entry->patched.name,
618 parent_entry->patched.addr, &sym);
619 require_noerr(rval, finish);
620 }
621 require_action(sym, finish, rval=KERN_FAILURE);
622
623 rval = kxld_symtab_get_sym_index(symtab, sym, &symindex);
624 require_noerr(rval, finish);
625
626 rval = kxld_reloc_update_symindex(child_entry->unpatched.reloc, symindex);
627 require_noerr(rval, finish);
628
629 kxld_log(kKxldLogPatching, kKxldLogDetail,
630 "In vtable '%s', patching '%s' with '%s'.",
631 kxld_demangle(vtable->name, &demangled_name1, &demangled_length1),
632 kxld_demangle(child_entry->unpatched.sym->name,
633 &demangled_name2, &demangled_length2),
634 kxld_demangle(sym->name, &demangled_name3, &demangled_length3));
635
636 rval = kxld_object_patch_symbol(object, child_entry->unpatched.sym);
637 require_noerr(rval, finish);
638
639 child_entry->unpatched.sym = sym;
640
641 /*
642 * The C++ ABI requires that functions be aligned on a 2-byte boundary:
643 * http://www.codesourcery.com/public/cxx-abi/abi.html#member-pointers
644 * If the LSB of any virtual function's link address is 1, then the
645 * compiler has violated that part of the ABI, and we're going to panic
646 * in _ptmf2ptf() (in OSMetaClass.h). Better to panic here with some
647 * context.
648 */
649 assert(kxld_sym_is_pure_virtual(sym) || !(sym->link_addr & 1));
650 }
651
652 require_action(!failure, finish, rval=KERN_FAILURE);
653
654 /* Change the vtable representation from the unpatched layout to the
655 * patched layout.
656 */
657
658 for (i = 0; i < vtable->entries.nitems; ++i) {
659 char *name;
660 kxld_addr_t addr;
661
662 child_entry = kxld_array_get_item(&vtable->entries, i);
663 if (child_entry->unpatched.sym) {
664 name = child_entry->unpatched.sym->name;
665 addr = child_entry->unpatched.sym->link_addr;
666 } else {
667 name = NULL;
668 addr = 0;
669 }
670
671 child_entry->patched.name = name;
672 child_entry->patched.addr = addr;
673 }
674
675 vtable->is_patched = TRUE;
676 rval = KERN_SUCCESS;
677
678finish:
679 if (demangled_name1) kxld_free(demangled_name1, demangled_length1);
680 if (demangled_name2) kxld_free(demangled_name2, demangled_length2);
681 if (demangled_name3) kxld_free(demangled_name3, demangled_length3);
682
683 return rval;
684}
685
686