libkern/kxld/kxld_vtable.c

66 static kern_return_t init_by_relocs(KXLDVTable *vtable, const KXLDSym *vtable_sym,
69 static kern_return_t init_by_entries_and_relocs(KXLDVTable *vtable,
73 static kern_return_t init_by_entries(KXLDVTable *vtable,
79 kxld_vtable_init(KXLDVTable *vtable, const KXLDSym *vtable_sym,
89     check(vtable);
99     vtable->name = vtable_sym->name;
100     vtable->vtable = vtable_sect->data +
104         rval = init_by_entries(vtable, relocator, defined_cxx_symbols);
107         vtable->is_patched = TRUE;
115                     kxld_demangle(vtable->name,
118             rval = init_by_entries_and_relocs(vtable, vtable_sym,
126                     kxld_demangle(vtable->name,
129             rval = init_by_relocs(vtable, vtable_sym, vtable_sect, relocator);
133         vtable->is_patched = FALSE;
162 * Initializes a vtable object by matching up relocation entries to the vtable's
166 init_by_relocs(KXLDVTable *vtable, const KXLDSym *vtable_sym,
182     check(vtable);
187     /* Find the first entry past the vtable padding */
195     /* Find the relocation entry at the start of the vtable */
202      * vtable entries.  For some reason, the __TEXT,__const relocations are
222     rval = kxld_array_init(&vtable->entries, sizeof(KXLDVTableEntry), nentries);
225     /* Find the symbols for each vtable entry */
227     for (i = 0; i < vtable->entries.nitems; ++i) {
229         entry = kxld_array_get_item(&vtable->entries, i);
249 * Initializes a vtable object by reading the symbol values out of the vtable
253 init_by_entries(KXLDVTable *vtable, const KXLDRelocator *relocator,
266     check(vtable);
272     /* Count the number of entries (the vtable is null-terminated) */
277             vtable->vtable, entry_offset);
286     rval = kxld_array_init(&vtable->entries, sizeof(KXLDVTableEntry), nentries);
292          i < vtable->entries.nitems;
296             vtable->vtable, entry_offset);
302         tmpentry = kxld_array_get_item(&vtable->entries, i);
321 * they exist in the vtable entry, and by looking through a matching relocation
322 * entry when the vtable entry is NULL.
324 * Final linked images require this hybrid vtable initialization approach
330 init_by_entries_and_relocs(KXLDVTable *vtable, const KXLDSym *vtable_sym,
347     check(vtable);
352     /* Find the first entry and its offset past the vtable padding */
357     /* In a final linked image, a vtable slot is valid if it is nonzero
359      * a relocation entry.  We'll know the end of the vtable when we find a
365             vtable->vtable, entry_offset);
378     rval = kxld_array_init(&vtable->entries, sizeof(KXLDVTableEntry), nentries);
381     /* Find the symbols for each vtable entry */
384          i < vtable->entries.nitems;
388             vtable->vtable, entry_offset);
406                     kxld_demangle(vtable->name, &demangled_name1,
412         tmpentry = kxld_array_get_item(&vtable->entries, i);
425 kxld_vtable_clear(KXLDVTable *vtable)
427     check(vtable);
429     vtable->vtable = NULL;
430     vtable->name = NULL;
431     vtable->is_patched = FALSE;
432     kxld_array_clear(&vtable->entries);
438 kxld_vtable_deinit(KXLDVTable *vtable)
440     check(vtable);
442     kxld_array_deinit(&vtable->entries);
443     bzero(vtable, sizeof(*vtable));
449 kxld_vtable_get_entry_for_offset(const KXLDVTable *vtable, u_long offset,
465     rval = kxld_array_get_item(&vtable->entries, vtable_entry_idx);
474 kxld_vtable_patch(KXLDVTable *vtable, const KXLDVTable *super_vtable,
492     check(vtable);
497     require_action(!vtable->is_patched, finish, rval=KERN_SUCCESS);
499     require_action(vtable->entries.nitems >= super_vtable->entries.nitems, finish,
502             kxld_demangle(vtable->name, &demangled_name1, &demangled_length1)));
505         child_entry = kxld_array_get_item(&vtable->entries, i);
544         /* 4) If the parent vtable entry is a pad slot, and the child does not
555                 kxld_demangle(vtable->name, &demangled_name2,
564          * the same class prefix as the vtable.  If it does, the symbol was
576             rval = kxld_sym_get_class_name_from_vtable_name(vtable->name,
592                     kxld_demangle(vtable->name,
603          * entry of the vtable entry to point to the symbol of the parent
604          * vtable entry.  If that symbol does not exist (i.e. we got the data
605          * from a link state object's vtable representation), then we create a
625             "In vtable '%s', patching '%s' with '%s'.",
626             kxld_demangle(vtable->name, &demangled_name1, &demangled_length1),
649     /* Change the vtable representation from the unpatched layout to the
653     for (i = 0; i < vtable->entries.nitems; ++i) {
657         child_entry = kxld_array_get_item(&vtable->entries, i);
670     vtable->is_patched = TRUE;