FreeBSD/Linux Kernel Cross Reference
sys/libsa/kld_patch.c

     /*
      * Copyright (c) 2001-2007 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@
     */
    /*
     * History:
     *  2001-05-30  gvdl    Initial implementation of the vtable patcher.
     */
    // 45678901234567890123456789012345678901234567890123456789012345678901234567890
    
    #include <mach-o/fat.h>
    #include <mach-o/loader.h>
    #include <mach-o/nlist.h>
    #include <mach-o/reloc.h>
    #if !KERNEL
    #include <mach-o/swap.h>
    #include <libkern/OSByteOrder.h>
    #endif
    
    #ifdef CONFIG_NOLIBKLD
    int kld_address_func = 0;
    int kld_forget_symbol = 0;
    int kld_load_basefile_from_memory = 0;
    int kld_load_from_memory = 0;
    int kld_lookup = 0;
    int kld_set_link_options = 0;
    int kld_unload_all = 0;
    #endif
    
    #if KERNEL
    
    #include <stdarg.h>
    //#include <string.h>
    
    #include <sys/systm.h>
    
    #include <libkern/OSTypes.h>
    
    #include <libsa/stdlib.h>
    #include <libsa/mach/mach.h>
    
    #include "mach_loader.h"
    
    #include <vm/vm_kern.h>
    
    enum { false = 0, true = 1 };
    
    #define vm_page_size page_size
    
    extern void kld_error_vprintf(const char *format, va_list ap);
    
    extern struct mach_header _mh_execute_header;
    extern struct segment_command *getsegbyname(char *seg_name);    // 32 bit only
    
    #else /* !KERNEL */
    
    #include <unistd.h>
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #include <sys/errno.h> 
    #include <sys/fcntl.h>
    #include <sys/stat.h>   
    #include <sys/mman.h>   
    #include <sys/vm.h>   
    
    #include <mach/mach.h>
    #include <mach/mach_error.h>
    
    #include <mach-o/arch.h>
    
    #include <CoreFoundation/CoreFoundation.h>
    
    #define PAGE_SIZE vm_page_size
   #define PAGE_MASK (PAGE_SIZE - 1)
   
   #endif /* KERNEL */
   
   #include "kld_patch.h"
   #include "c++rem3.h"
   
   #if 0
   #define DIE() do { for (;;) ; } while(0)
   
   #if KERNEL
   #    define LOG_DELAY()         /* IODelay(200000) */
   #    define DEBUG_LOG(x)        do { IOLog x; LOG_DELAY(); } while(0)
   #else
   #    define LOG_DELAY()
   #    define DEBUG_LOG(x)        do { printf x; } while(0)
   #endif
   
   #else
   
   #define DIE()
   #define LOG_DELAY()
   #define DEBUG_LOG(x)
   
   #endif
   
   // OSObject symbol prefixes and suffixes
   #define kCPPSymbolPrefix        "_Z"
   #define kVTablePrefix           "_" kCPPSymbolPrefix "TV"
   #define kOSObjPrefix            "_" kCPPSymbolPrefix "N"
   #define kReservedNamePrefix     "_RESERVED"
   #define k29SuperClassSuffix     "superClass"
   #define k31SuperClassSuffix     "10superClassE"
   #define kGMetaSuffix            "10gMetaClassE"
   #define kLinkEditSegName        SEG_LINKEDIT
   
   // GCC 2.95 drops 2 leading constants in the vtable
   #define kVTablePreambleLen 2
   
   // Last address that I'm willing to try find vm in
   #define kTopAddr  ((unsigned char *) (1024 * 1024 * 1024))
   
   // Size in bytes that Data Ref object's get increased in size
   // Must be a power of 2
   #define kDataCapacityIncrement 128
   
   // My usual set of helper macros.  I personally find these macros
   // easier to read in the code rather than an explicit error condition
   // check.  If I don't make it easy then I may get lazy ond not check
   // everything.  I'm sorry if you find this code harder to read.
   
   // break_if will evaluate the expression and if it is true
   // then it will print the msg, which is enclosed in parens
   // and then break.  Usually used in loops are do { } while (0)
   #define break_if(expr, msg)                                     \
       if (expr) {                                                 \
           errprintf msg;                                          \
           break;                                                  \
       }
   
   // return_if will evaluate expr and if true it will log the
   // msg, which is enclosed in parens, and then it will return
   // with the return code of ret.
   #define return_if(expr, ret, msg) do {                          \
       if (expr) {                                                 \
           errprintf msg;                                          \
           return ret;                                             \
       }                                                           \
   } while (0)
   
   #ifndef MIN
   #define MIN(a,b) (((a)<(b))?(a):(b))
   #endif /* MIN */
   #ifndef MAX
   #define MAX(a,b) (((a)>(b))?(a):(b))
   #endif /* MAX */
   
   typedef struct Data {
       unsigned long fLength, fCapacity;
       char *fData;
   } Data, *DataRef;
   
   struct sectionRecord {
       const struct section *fSection;     // 32 bit mach object section
       DataRef fRelocCache;
   };
   
   enum patchState {
       kSymbolIdentical,
       kSymbolLocal,
       kSymbolPadUpdate,
       kSymbolSuperUpdate,
       kSymbolMismatch
   };
   
   struct patchRecord {
       struct nlist *fSymbol;
       const struct fileRecord *fFile;
       enum patchState fType;
   };
   
   struct relocRecord {
       void *fValue;
       struct nlist *fSymbol;
       struct relocation_info *fRInfo;
       void *reserved;
   };
   
   struct metaClassRecord {
       char *fSuperName;
       struct fileRecord *fFile;
       const struct nlist *fVTableSym;
       struct patchRecord *fPatchedVTable;
       char fClassName[1];
   };
   
   struct fileRecord {
       size_t fMapSize, fMachOSize;
       unsigned char *fMap, *fMachO, *fPadEnd;
       DataRef fClassList;
       DataRef fSectData;
       DataRef fNewSymbols, fNewStringBlocks;
       DataRef fSym2Strings;
       struct symtab_command *fSymtab;
       struct sectionRecord *fSections;
       vm_offset_t fVMAddr, fVMEnd;
       struct segment_command *fLinkEditSeg;
       char **fSymbToStringTable;
       char *fStringBase;
       struct nlist *fSymbolBase;
       struct nlist *fLocalSyms;
       unsigned int fNSects;
       int fNLocal;
       Boolean fIsKernel, fIsReloc, fIsIncrLink, fNoKernelExecutable, fIsKmem;
       Boolean fImageDirty, fSymbolsDirty;
       Boolean fRemangled, fFoundOSObject;
       Boolean fIgnoreFile;
   #if !KERNEL
       Boolean fSwapped;
   #endif
       char fPath[1];
   };
   
   static DataRef sFilesTable;
   static struct fileRecord *sKernelFile;
   
   static DataRef    sMergedFiles;
   static DataRef    sMergeMetaClasses;
   static Boolean    sMergedKernel;
   #if !KERNEL
   static const NXArchInfo * sPreferArchInfo;
   #endif
   static const struct nlist *
   findSymbolByName(struct fileRecord *file, const char *symname);
   
   static void errprintf(const char *fmt, ...)
   {
       va_list ap;
   
       va_start(ap, fmt);
       kld_error_vprintf(fmt, ap);
       va_end(ap);
   
   DIE();
   }
   
   static __inline__ unsigned long DataGetLength(DataRef data)
   {
       return data->fLength;
   }
   
   static __inline__ char *DataGetPtr(DataRef data)
   {
       return data->fData;
   }
   
   static __inline__ char *DataGetEndPtr(DataRef data)
   {
       return data->fData + data->fLength;
   }
   
   static __inline__ unsigned long DataRemaining(DataRef data)
   {
       return data->fCapacity - data->fLength;
   }
   
   static __inline__ Boolean DataContainsAddr(DataRef data, void *vAddr)
   {
       vm_offset_t offset = (vm_address_t) vAddr;
   
       if (!data)
           return false;
   
       offset = (vm_address_t) vAddr - (vm_address_t) data->fData;
       return (offset < data->fLength);
   }
   
   static Boolean DataEnsureCapacity(DataRef data, unsigned long capacity)
   {
       // Don't bother to ever shrink a data object.
       if (capacity > data->fCapacity) {
           char *newData;
   
           capacity += kDataCapacityIncrement - 1;
           capacity &= ~(kDataCapacityIncrement - 1);
           newData = (char *) realloc(data->fData, capacity);
           if (!newData)
               return false;
   
           bzero(newData + data->fCapacity, capacity - data->fCapacity);
           data->fData = newData;
           data->fCapacity = capacity;
       }
   
       return true;
   }
   
   static __inline__ Boolean DataSetLength(DataRef data, unsigned long length)
   {
       if (DataEnsureCapacity(data, length)) {
           data->fLength = length;
           return true;
       }
       else
           return false;
   }
   
   static __inline__ Boolean DataAddLength(DataRef data, unsigned long length)
   {
       return DataSetLength(data, data->fLength + length);
   }
   
   static __inline__ Boolean
   DataAppendBytes(DataRef data, const void *addr, unsigned int len)
   {
       unsigned long size = DataGetLength(data);
   
       if (!DataAddLength(data, len))
           return false;
   
       bcopy(addr, DataGetPtr(data) + size, len);
       return true;
   }
   
   static __inline__ Boolean DataAppendData(DataRef dst, DataRef src)
   {
       return DataAppendBytes(dst, DataGetPtr(src), DataGetLength(src));
   }
   
   static DataRef DataCreate(unsigned long capacity)
   {
       DataRef data = (DataRef) malloc(sizeof(Data));
   
       if (data) {
           if (!capacity)
               data->fCapacity = kDataCapacityIncrement;
           else {
               data->fCapacity  = capacity + kDataCapacityIncrement - 1;
               data->fCapacity &= ~(kDataCapacityIncrement - 1);
           }
   
           data->fData = (char *) malloc(data->fCapacity);
           if (!data->fData) {
               free(data);
               return NULL;
           }
   
           bzero(data->fData, data->fCapacity);
           data->fLength = 0;
       }
       return data;
   }
   
   static void DataRelease(DataRef data)
   {
       if (data) {
           if (data->fData)
               free(data->fData);
           data->fData = 0;
           free(data);
       }
   }
   
   static __inline__ char *
   symNameByIndex(const struct fileRecord *file, unsigned int symInd)
   {
       return file->fSymbToStringTable[symInd];
   }
   
   static __inline__  char *
   symbolname(const struct fileRecord *file, const struct nlist *sym)
   {
       unsigned int index;
   
       index = sym - file->fSymbolBase;
   
       if (index && !sym->n_un.n_strx)
          return file->fStringBase + sym->n_value;
   
       if (index < file->fSymtab->nsyms)
           return symNameByIndex(file,  index);
   
       if (-1 == sym->n_un.n_strx)
           return (char *) sym->n_value;
   
       // If the preceding tests fail then we have a getNewSymbol patch and
       // the file it refers to has already been patched as the n_strx is set
       // to -1 temporarily while we are still processing a file.
       // Once we have finished with a file then we repair the 'strx' offset 
       // to be valid for the repaired file's string table.
       return file->fStringBase + sym->n_un.n_strx;
   }
   
   static struct fileRecord *
   getFile(const char *path)
   {
       if (sFilesTable) {
           int i, nfiles;
           struct fileRecord **files;
   
           // Check to see if we have already merged this file
           nfiles = DataGetLength(sFilesTable) / sizeof(struct fileRecord *);
           files = (struct fileRecord **) DataGetPtr(sFilesTable);
           for (i = 0; i < nfiles; i++) {
               if (!strcmp(path, files[i]->fPath))
                   return files[i];
           }
       }
   
       return NULL;
   }
   
   static struct fileRecord *
   addFile(struct fileRecord *file, const char *path)
   {
       struct fileRecord *newFile;
   
       if (!sFilesTable) {
           sFilesTable = DataCreate(0);
           if (!sFilesTable)
               return NULL;
       }
   
       newFile = (struct fileRecord *) 
           malloc(sizeof(struct fileRecord) + strlen(path));
       if (!newFile)
           return NULL;
   
       if (!DataAppendBytes(sFilesTable, &newFile, sizeof(newFile))) {
           free(newFile);
           return NULL;
       }
   
       bcopy(file, newFile, sizeof(struct fileRecord) - 1);
       strlcpy((char *) newFile->fPath, path, strlen(path) + 1);
   
       return newFile;
   }
   
   // @@@ gvdl: need to clean up the sMergeMetaClasses
   // @@@ gvdl: I had better fix the object file up again
   static void unmapFile(struct fileRecord *file)
   {
       if (file->fSectData) {
           struct sectionRecord *section;
           unsigned int i, nsect;
   
           nsect = file->fNSects;
           section = file->fSections;
           for (i = 0; i < nsect; i++, section++) {
               if (section->fRelocCache) {
                   DataRelease(section->fRelocCache);
                   section->fRelocCache = 0;
               }
           }
   
           DataRelease(file->fSectData);
           file->fSectData = 0;
           file->fSections = 0;
           file->fNSects = 0;
       }
   
       if (file->fSym2Strings) {
           DataRelease(file->fSym2Strings);
           file->fSym2Strings = 0;
       }
   
       if (file->fMap) {
   #if KERNEL
           if (file->fIsKmem)
               kmem_free(kernel_map, (vm_address_t) file->fMap, file->fMapSize);
   #else /* !KERNEL */
           if (file->fPadEnd) {
               vm_address_t padVM;
               vm_size_t padSize;
   
               padVM = round_page((vm_address_t) file->fMap + file->fMapSize);
               padSize  = (vm_size_t) ((vm_address_t) file->fPadEnd - padVM);
               (void) vm_deallocate(mach_task_self(), padVM, padSize);
               file->fPadEnd = 0;
           }
   
           (void) munmap((caddr_t) file->fMap, file->fMapSize);
   #endif /* !KERNEL */
           file->fMap = 0;
       }
   }
   
   static void removeFile(struct fileRecord *file)
   {
       int i, count;
   
       if (file->fClassList) {
           struct metaClassRecord ** fileClasses =
               (struct metaClassRecord **)DataGetPtr(file->fClassList);
           
           count = DataGetLength(file->fClassList) / sizeof(struct metaClassRecord *);
   
           for (i = 0; i < count; i++) {
               struct metaClassRecord * thisClass = fileClasses[i];
   
               if (thisClass->fSuperName) {
                   free(thisClass->fSuperName);
               }
               if (thisClass->fPatchedVTable) {
                   free(thisClass->fPatchedVTable);
               }
   
               free(thisClass);
           }
           
           DataRelease(file->fClassList);
           file->fClassList = 0;
       }
   
       // unmapFile() releases file->fSectData
   
       if (file->fNewSymbols) {
           struct nlist ** syms =
               (struct nlist **)DataGetPtr(file->fNewSymbols);
   
           count = DataGetLength(file->fNewSymbols) / sizeof(struct nlist *);
   
           for (i = 0; i < count; i++) {
               free(syms[i]);
           }
           DataRelease(file->fNewSymbols);
           file->fNewSymbols = 0;
       }
   
       if (file->fNewStringBlocks) {
           DataRef * stringBlocks = (DataRef *)DataGetPtr(file->fNewStringBlocks);
           count = DataGetLength(file->fNewStringBlocks) / sizeof(DataRef);
   
           for (i = 0; i < count; i++) {
               DataRelease(stringBlocks[i]);
           }
   
           DataRelease(file->fNewStringBlocks);
           file->fNewStringBlocks = 0;
       }
   
       // unmapFile() releases file->fSym2Strings
   
       unmapFile(file);
   
       free(file);
   }
   
   
   #if !KERNEL
   static Boolean
   mapObjectFile(struct fileRecord *file, const char *pathName)
   {
       Boolean result = false;
       static unsigned char *sFileMapBaseAddr = 0;
   
       int fd = 0;
   
       if (!sFileMapBaseAddr) {
           kern_return_t ret;
           vm_address_t probeAddr;
   
           // If we don't already have a base addr find any random chunk
           // of 32 meg of VM and to use the 16 meg boundrary as a base.
           ret = vm_allocate(mach_task_self(), &probeAddr,
                               32 * 1024 * 1024, VM_FLAGS_ANYWHERE);
           return_if(KERN_SUCCESS != ret, false,
               ("Unable to allocate base memory %s\n", mach_error_string(ret)));
           (void) vm_deallocate(mach_task_self(), probeAddr, 32 * 1024 * 1024);
   
           // Now round to the next 16 Meg boundrary
           probeAddr = (probeAddr +  (16 * 1024 * 1024 - 1))
                                  & ~(16 * 1024 * 1024 - 1);
           sFileMapBaseAddr = (unsigned char *) probeAddr;
       }
   
       fd = open(pathName, O_RDONLY, 0);
       return_if(fd == -1, false, ("Can't open %s for reading - %s\n",
           pathName, strerror(errno)));
   
       do {
           kern_return_t ret;
           struct stat sb;
           int retaddr = -1;
   
           break_if(fstat(fd, &sb) == -1,
               ("Can't stat %s - %s\n", file->fPath, strerror(errno)));
   
           file->fMapSize = sb.st_size;
           file->fMap = sFileMapBaseAddr;
           ret = KERN_SUCCESS;
           while (file->fMap < kTopAddr) {
               vm_address_t padVM;
               vm_address_t padVMEnd;
               vm_size_t padSize;
   
               padVM = round_page((vm_address_t) file->fMap + file->fMapSize);
               retaddr = (int) mmap(file->fMap, file->fMapSize,
                                    PROT_READ|PROT_WRITE, 
                                    MAP_FIXED|MAP_FILE|MAP_PRIVATE,
                                    fd, 0);
               if (-1 == retaddr) {
                   break_if(ENOMEM != errno,
                       ("mmap failed %d - %s\n", errno, strerror(errno)));
   
                   file->fMap = (unsigned char *) padVM;
                   continue;
               }
   
   
               // Round up padVM to the next page after the file and assign at
               // least another fMapSize more room rounded up to the next page
               // boundary.
               padVMEnd = round_page(padVM + file->fMapSize);
               padSize  = padVMEnd - padVM;
               ret = vm_allocate(
                   mach_task_self(), &padVM, padSize, VM_FLAGS_FIXED);
               if (KERN_SUCCESS == ret) {
                   file->fPadEnd = (unsigned char *) padVMEnd;
                   break;
               }
               else {
                   munmap(file->fMap, file->fMapSize);
                   break_if(KERN_INVALID_ADDRESS != ret,
                       ("Unable to allocate pad vm for %s - %s\n",
                           pathName, mach_error_string(ret)));
   
                   file->fMap = (unsigned char *) padVMEnd;
                   continue; // try again wherever the vm system wants
               }
           }
   
           if (-1 == retaddr || KERN_SUCCESS != ret)
               break;
   
           break_if(file->fMap >= kTopAddr,
               ("Unable to map memory %s\n", file->fPath));
   
           sFileMapBaseAddr = file->fPadEnd;
           result = true;
       } while(0);
   
       close(fd);
       return result;
   }
   
   void
   kld_set_architecture(const NXArchInfo * arch)
   {
       sPreferArchInfo = arch;
   }
   
   // This function can only operate on 32 bit mach-o files
   Boolean
   kld_macho_swap(struct mach_header * mh)
   {
       struct segment_command * seg;
       struct section *         section;
       CFIndex                  ncmds, cmd, sect;
       enum NXByteOrder         hostOrder = NXHostByteOrder();
   
       if (MH_CIGAM != mh->magic)
           return (false);
   
       swap_mach_header(mh, hostOrder);
   
       ncmds = mh->ncmds;
       seg = (struct segment_command *)(mh + 1);
       for (cmd = 0;
               cmd < ncmds;
               cmd++, seg = (struct segment_command *)(((vm_offset_t)seg) + seg->cmdsize))
       {
           if (OSSwapConstInt32(LC_SYMTAB) == seg->cmd) {
               swap_symtab_command((struct symtab_command *) seg, hostOrder);
               swap_nlist((struct nlist *) (((vm_offset_t) mh) + ((struct symtab_command *) seg)->symoff),
                          ((struct symtab_command *) seg)->nsyms, hostOrder);
               continue;
           }
           if (OSSwapConstInt32(LC_SEGMENT) != seg->cmd) {
               swap_load_command((struct load_command *) seg, hostOrder);
               continue;
           }
           swap_segment_command(seg, hostOrder);
           swap_section((struct section *) (seg + 1), seg->nsects, hostOrder);
   
           section = (struct section *) (seg + 1);
           for (sect = 0; sect < seg->nsects; sect++, section++) {
               if (section->nreloc)
                   swap_relocation_info((struct relocation_info *) (((vm_offset_t) mh) + section->reloff),
                                         section->nreloc, hostOrder);
           }
       }
   
       return (true);
   }
   
   // This function can only operate on 32 bit mach-o files
   void
   kld_macho_unswap(struct mach_header * mh, Boolean didSwap, int symbols)
   {
       // symbols ==  0 => everything
       // symbols ==  1 => just nlists
       // symbols == -1 => everything but nlists
   
       struct segment_command * seg;
       struct section *         section;
       unsigned long            cmdsize;
       CFIndex                  ncmds, cmd, sect;
       enum NXByteOrder         hostOrder = (NXHostByteOrder() == NX_LittleEndian)
                                           ? NX_BigEndian : NX_LittleEndian;
       if (!didSwap)
           return;
   
       ncmds = mh->ncmds;
       seg = (struct segment_command *)(mh + 1);
       for (cmd = 0;
               cmd < ncmds;
               cmd++, seg = (struct segment_command *)(((vm_offset_t)seg) + cmdsize))
       {
           cmdsize = seg->cmdsize;
           if (LC_SYMTAB == seg->cmd) {
               if (symbols >= 0)
                   swap_nlist((struct nlist *) (((vm_offset_t) mh) + ((struct symtab_command *) seg)->symoff),
                           ((struct symtab_command *) seg)->nsyms, hostOrder);
               if (symbols > 0)
                   break;
               swap_symtab_command((struct symtab_command *) seg, hostOrder);
               continue;
           }
           if (symbols > 0)
               continue;
           if (LC_SEGMENT != seg->cmd) {
               swap_load_command((struct load_command *) seg, hostOrder);
               continue;
           }
   
           section = (struct section *) (seg + 1);
           for (sect = 0; sect < seg->nsects; sect++, section++) {
               if (section->nreloc)
                   swap_relocation_info((struct relocation_info *) (((vm_offset_t) mh) + section->reloff),
                                         section->nreloc, hostOrder);
           }
           swap_section((struct section *) (seg + 1), seg->nsects, hostOrder);
           swap_segment_command(seg, hostOrder);
       }
       if (symbols <= 0)
           swap_mach_header(mh, hostOrder);
   }
   
   #endif /* !KERNEL */
   
   // Note: This functions is only called from kld_file_map()
   // This function can only operate on 32 bit mach-o files
   static Boolean findBestArch(struct fileRecord *file, const char *pathName)
   {
       unsigned long magic;
       struct fat_header *fat;
   
   
       file->fMachOSize = file->fMapSize;
       file->fMachO = file->fMap;
       magic = ((const struct mach_header *) file->fMachO)->magic;
       fat = (struct fat_header *) file->fMachO;
   
       // Try to figure out what type of file this is
       return_if(file->fMapSize < sizeof(unsigned long), false,
           ("%s isn't a valid object file - no magic\n", pathName));
   
   #if KERNEL
   
       // CIGAM is byte-swapped MAGIC
       if (magic == FAT_MAGIC || magic == FAT_CIGAM) {
   
           load_return_t load_return;
           struct fat_arch fatinfo;
   
           load_return = fatfile_getarch(NULL, (vm_address_t) fat, &fatinfo);
           return_if(load_return != LOAD_SUCCESS, false,
               ("Extension \"%s\": has no code for this computer\n", pathName));
   
           file->fMachO = file->fMap + fatinfo.offset;
           file->fMachOSize = fatinfo.size;
           magic = ((const struct mach_header *) file->fMachO)->magic;
       }
   
   #else /* !KERNEL */
   
       // Do we need to in-place swap the endianness of the fat header?
       if (magic == FAT_CIGAM) {
           unsigned long i;
           struct fat_arch *arch;
   
           fat->nfat_arch = OSSwapBigToHostInt32(fat->nfat_arch);
           return_if(file->fMapSize < sizeof(struct fat_header)
                                       + fat->nfat_arch * sizeof(struct fat_arch),
               false, ("%s is too fat\n", file->fPath));
   
           arch = (struct fat_arch *) &fat[1];
           for (i = 0; i < fat->nfat_arch; i++) {
               arch[i].cputype    = OSSwapBigToHostInt32(arch[i].cputype);
               arch[i].cpusubtype = OSSwapBigToHostInt32(arch[i].cpusubtype);
               arch[i].offset     = OSSwapBigToHostInt32(arch[i].offset);
               arch[i].size       = OSSwapBigToHostInt32(arch[i].size);
               arch[i].align      = OSSwapBigToHostInt32(arch[i].align);
           }
   
           magic = OSSwapBigToHostInt32(fat->magic);
       }
   
       // Now see if we can find any valid architectures
       if (magic == FAT_MAGIC) {
           const NXArchInfo *myArch;
           unsigned long fatsize;
           struct fat_arch *arch;
   
           fatsize = sizeof(struct fat_header)
               + fat->nfat_arch * sizeof(struct fat_arch);
           return_if(file->fMapSize < fatsize,
               false, ("%s isn't a valid fat file\n", pathName));
   
           if (sPreferArchInfo)
               myArch = sPreferArchInfo;
           else
               myArch = NXGetLocalArchInfo();
       
           arch = NXFindBestFatArch(myArch->cputype, myArch->cpusubtype,
                   (struct fat_arch *) &fat[1], fat->nfat_arch);
           return_if(!arch,
               false, ("%s hasn't got arch for %s\n", pathName, myArch->name));
           return_if(arch->offset + arch->size > file->fMapSize,
               false, ("%s's %s arch is incomplete\n", pathName, myArch->name));
           file->fMachO = file->fMap + arch->offset;
           file->fMachOSize = arch->size;
           magic = ((const struct mach_header *) file->fMachO)->magic;
       }
   
       file->fSwapped = kld_macho_swap((struct mach_header *) file->fMachO);
       if (file->fSwapped)
           magic = ((const struct mach_header *) file->fMachO)->magic;
   
   #endif /* KERNEL */
   
       return_if(magic != MH_MAGIC,
           false, ("%s isn't a valid mach-o (magic is %08x)\n", pathName, magic));
   
       return true;
   }
   
   // This function can only operate on segments from 32 bit mach-o files
   static Boolean
   parseSegments(struct fileRecord *file, struct segment_command *seg)
   {
       struct sectionRecord *sections;
       int i, nsects = seg->nsects;
       const struct segmentMap {
           struct segment_command seg;
           const struct section sect[1];
       } *segMap;
   
       if (!file->fSectData) {
           file->fSectData = DataCreate(0);
           if (!file->fSectData)
               return false;
       }
   
       // Increase length of section DataRef and cache data pointer
       if (!DataAddLength(file->fSectData, nsects * sizeof(struct sectionRecord)))
           return false;
       file->fSections = (struct sectionRecord *) DataGetPtr(file->fSectData);
   
       // Initialise the new sections
       sections = &file->fSections[file->fNSects];
       file->fNSects += nsects;
       for (i = 0, segMap = (struct segmentMap *) seg; i < nsects; i++)
       {
           sections[i].fSection = &segMap->sect[i];
           file->fIsReloc |= (0 != segMap->sect[i].nreloc);
       }
   
       return true;
   }
   
   static Boolean
   remangleExternSymbols(struct fileRecord *file, const char *pathName)
   {
       const struct nlist *sym;
       int i, nsyms, len;
       DataRef strings = NULL;
   
       DEBUG_LOG(("Remangling %s\n", pathName));
   
       file->fNewStringBlocks = DataCreate(0);
       return_if(!file->fNewStringBlocks, false,
           ("Unable to allocate new string table for %s\n", pathName));
   
       nsyms = file->fSymtab->nsyms;
       for (i = 0, sym = file->fSymbolBase; i < nsyms; i++, sym++) {
           Rem3Return ret;
           const char *symname;
           char *newname;
           unsigned char n_type = sym->n_type;
   
           // Not an external symbol or it is a stab in any case don't bother
           if ((n_type ^ N_EXT) & (N_STAB | N_EXT))
               continue;
   
           symname = symNameByIndex(file, i);
   
   tryRemangleAgain:
           if (!strings) {
               strings = DataCreate(16 * 1024);    // Arbitrary block size
               return_if(!strings, false,
                   ("Unable to allocate new string block for %s\n", pathName));
           }
   
           len = DataRemaining(strings);
           newname = DataGetEndPtr(strings);
           ret = rem3_remangle_name(newname, &len, symname);
           switch (ret) {
           case kR3InternalNotRemangled:
               errprintf("Remangler fails on %s in %s\n", symname, pathName);
               /* No break */
           case kR3NotRemangled:
               break;
   
           case kR3Remangled:
               file->fSymbToStringTable[i] = newname;
               file->fRemangled = file->fSymbolsDirty = true; 
               DataAddLength(strings, len + 1);    // returns strlen
               break;
   
           case kR3BufferTooSmallRemangled:
               return_if(!DataAppendBytes
                           (file->fNewStringBlocks, &strings, sizeof(strings)),
                   false, ("Unable to allocate string table for %s\n", pathName));
               strings = NULL;
               goto tryRemangleAgain;
   
           case kR3BadArgument:
           default:
               return_if(true, false,
                        ("Internal error - remangle of %s\n", pathName));
           }
       }
   
       if (strings) {
           return_if(!DataAppendBytes
                           (file->fNewStringBlocks, &strings, sizeof(strings)),
               false, ("Unable to allocate string table for %s\n", pathName));
       }
   
       return true;
   }
   
   // This function can only operate on symbol table files from  32 bit
   // mach-o files
   static Boolean parseSymtab(struct fileRecord *file, const char *pathName)
   {
       struct nlist *sym;
       unsigned int i, firstlocal, nsyms;
       unsigned long strsize;
       char *strbase;
       Boolean foundOSObject, found295CPP, havelocal;
   
       // we found a link edit segment so recompute the bases
       if (file->fLinkEditSeg) {
           struct segment_command *link = file->fLinkEditSeg;
   
           file->fSymbolBase = (struct nlist *)
               (link->vmaddr + (file->fSymtab->symoff - link->fileoff));
           file->fStringBase = (char *)
               (link->vmaddr + (file->fSymtab->stroff - link->fileoff));
           return_if( ( (caddr_t) file->fStringBase + file->fSymtab->strsize
                       > (caddr_t) link->vmaddr + link->vmsize ), false,
               ("%s isn't a valid mach-o le, bad symbols\n", pathName));
       }
       else {
           file->fSymbolBase = (struct nlist *)
               (file->fMachO + file->fSymtab->symoff); 
          file->fStringBase = (char *)
              (file->fMachO + file->fSymtab->stroff); 
          return_if( ( file->fSymtab->stroff + file->fSymtab->strsize
                      > file->fMachOSize ), false,
              ("%s isn't a valid mach-o, bad symbols\n", pathName));
      }
  
      nsyms = file->fSymtab->nsyms;
  
      // If this file the kernel and do we have an executable image
      file->fNoKernelExecutable = (vm_page_size == file->fSymtab->symoff)
                              && (file->fSections[0].fSection->size == 0);
  
      // Generate a table of pointers to strings indexed by the symbol number
  
      file->fSym2Strings = DataCreate(nsyms * sizeof(const char *));
      DataSetLength(file->fSym2Strings, nsyms * sizeof(const char *));
      return_if(!file->fSym2Strings, false, 
              ("Unable to allocate memory - symbol string trans\n", pathName));
      file->fSymbToStringTable = (char **) DataGetPtr(file->fSym2Strings);
  
      // Search for the first non-stab symbol in table
      strsize = file->fSymtab->strsize;
      strbase = file->fStringBase;
      firstlocal = 0;
      havelocal = false;
      found295CPP = foundOSObject = false;
      for (i = 0, sym = file->fSymbolBase; i < nsyms; i++, sym++) {
          long strx = sym->n_un.n_strx;
          char *symname = strbase + strx;
          unsigned char n_type;
  
          return_if(((unsigned long) strx > strsize), false,
              ("%s has an illegal string offset in symbol %d\n", pathName, i));
  #if 0
          // Make all syms abs
          if (file->fIsIncrLink) {
              if ( (sym->n_type & N_TYPE) == N_SECT) {
                  sym->n_sect = NO_SECT;
                  sym->n_type = (sym->n_type & ~N_TYPE) | N_ABS;
              }
          }
  #endif
  
          if (file->fIsIncrLink && !file->fNSects)
          {
              // symbol set
              struct nlist *patchsym = sym;
              const char * lookname;
              const struct nlist * realsym;
  
              if ( (patchsym->n_type & N_TYPE) == N_INDR)
                  lookname = strbase + patchsym->n_value;
              else
                  lookname = symname;
              realsym = findSymbolByName(sKernelFile, lookname);
  
              patchsym->n_sect  = NO_SECT;
              if (realsym)
              {
                  patchsym->n_type  = realsym->n_type;
                  patchsym->n_desc  = realsym->n_desc;
                  patchsym->n_value = realsym->n_value;
                  if ((patchsym->n_type & N_TYPE) == N_SECT)
                      patchsym->n_type = (patchsym->n_type & ~N_TYPE) | N_ABS;
              }
              else
              {
                  errprintf("%s: Undefined in symbol set: %s\n", pathName, symname);
                  patchsym->n_type = N_ABS;
                  patchsym->n_desc  = 0;
                  patchsym->n_value = patchsym->n_un.n_strx;
                  patchsym->n_un.n_strx = 0;
              }
  
              if (!havelocal && (patchsym->n_type & N_EXT)) {
                  firstlocal = i;
                  havelocal = true;
                  file->fLocalSyms = patchsym;
              }
              continue;
          } /* symbol set */
  
          // Load up lookup symbol look table with sym names
          file->fSymbToStringTable[i] = symname;
  
          n_type = sym->n_type & (N_TYPE | N_EXT);
  
          // Find the first exported symbol
          if ( !firstlocal && (n_type & N_EXT) ) {
              firstlocal = i;
              havelocal = true;
              file->fLocalSyms = sym;
          }
  
          // Find the a OSObject based subclass by searching for symbols
          // that have a suffix of '10superClassE'
          symname++; // Skip leading '_'
  
          if (!foundOSObject
          && (n_type == (N_SECT | N_EXT) || n_type == (N_ABS | N_EXT))
          &&  strx) {
              const char *suffix, *endSym;
  
              endSym = symname + strlen(symname);
  
              // Find out if this symbol has the superclass suffix.
              if (symname[0] == kCPPSymbolPrefix[0]
              &&  symname[1] == kCPPSymbolPrefix[1]) {
  
                  suffix = endSym - sizeof(k31SuperClassSuffix) + 1;
  
                  // Check for a gcc3 OSObject subclass
                  if (suffix > symname
                  && !strcmp(suffix, k31SuperClassSuffix))
                      foundOSObject = true;
              }
              else {
                  suffix = endSym - sizeof(k29SuperClassSuffix);
  
                  // Check for a gcc295 OSObject subclass
                  if (suffix > symname
                  && ('.' == *suffix || '$' == *suffix)
                  && !strcmp(suffix+1, k29SuperClassSuffix)) {
                      found295CPP = foundOSObject = true;
                  }
                  else if (!found295CPP) {
                      // Finally just check if we need to remangle
                      symname++; // skip leading '__'
                      while (*symname) {
                          if ('_' == symname[0] && '_' == symname[1]) {
                              found295CPP = true;
                              break;
                          }
                          symname++;
                      }
                  }
              }
          }
          else if (sym->n_type == (N_EXT | N_UNDF)) {
              if ( !file->fNLocal)        // Find the last local symbol
                  file->fNLocal = i - firstlocal;
              if (!found295CPP) {
                  symname++;      // Skip possible second '_' at start.
                  while (*symname) {
                      if ('_' == symname[0] && '_' == symname[1]) {
                          found295CPP = true;
                          break;
                      }
                      symname++;
                  }
              }
          }
          // Note symname is trashed at this point
      }
      return_if(i < nsyms, false,
          ("%s isn't a valid mach-o, bad symbol strings\n", pathName));
  
      return_if(!file->fLocalSyms, false, ("%s has no symbols?\n", pathName));
  
      // If we don't have any undefined symbols then all symbols
      // must be local so just compute it now if necessary.
      if ( !file->fNLocal )
          file->fNLocal = i - firstlocal;
  
      file->fFoundOSObject = foundOSObject;
  
      if (found295CPP && !remangleExternSymbols(file, pathName))
          return false;
              
      return true;
  }
  
  // @@@ gvdl:  These functions need to be hashed they are
  // going to be way too slow for production code.
  static struct nlist *
  findSymbolByAddress(const struct fileRecord *file, void *entry)
  {
      // not quite so dumb linear search of all symbols
      struct nlist *sym;
      int i, nsyms;
  
      // First try to find the symbol in the most likely place which is the
      // extern symbols
      sym = file->fLocalSyms;
      for (i = 0, nsyms = file->fNLocal; i < nsyms; i++, sym++) {
          if (sym->n_value == (unsigned long) entry && !(sym->n_type & N_STAB) )
              return sym;
      }
  
      // Didn't find it in the external symbols so try to local symbols before
      // giving up.
      sym = file->fSymbolBase;
      for (i = 0, nsyms = file->fSymtab->nsyms; i < nsyms; i++, sym++) {
          if ( (sym->n_type & N_EXT) )
              return NULL;
          if ( sym->n_value == (unsigned long) entry && !(sym->n_type & N_STAB) )
              return sym;
      }
  
      return NULL;
  }
  
  static struct nlist *
  findSymbolByAddressInAllFiles(__unused const struct fileRecord * fromFile, 
                              void *entry, const struct fileRecord **resultFile)
  {
      int i, nfiles = 0;
      struct fileRecord **files;
  
      if (sFilesTable) {
  
          // Check to see if we have already merged this file
          nfiles = DataGetLength(sFilesTable) / sizeof(struct fileRecord *);
          files = (struct fileRecord **) DataGetPtr(sFilesTable);
          for (i = 0; i < nfiles; i++) {
              if ((((vm_offset_t)entry) >= files[i]->fVMAddr)
               && (((vm_offset_t)entry) <  files[i]->fVMEnd))
              {
                  struct nlist * result;
                  if (resultFile)
                      *resultFile = files[i];
                  result = findSymbolByAddress(files[i], entry);
                  return result;
              }
          }
      }
  
      return NULL;
  }
  
  struct searchContext {
      const char *fSymname;
      const struct fileRecord *fFile;
  };
  
  static int symbolSearch(const void *vKey, const void *vSym)
  {
      const struct searchContext *key = (const struct searchContext *) vKey;
      const struct nlist *sym = (const struct nlist *) vSym;
  
      return strcmp(key->fSymname, symbolname(key->fFile, sym));
  }
  
  static const struct nlist *
  findSymbolByName(struct fileRecord *file, const char *symname)
  {
      if (file->fRemangled) {
          // @@@ gvdl: Performance problem
          // Linear search as we don't sort after remangling
          const struct nlist *sym;
          int i = file->fLocalSyms - file->fSymbolBase;
          int nLocal = file->fNLocal + i;
  
          for (sym = file->fLocalSyms; i < nLocal; i++, sym++)
              if (!strcmp(symNameByIndex(file, i), symname))
                  return sym;
          return NULL;
      }
      else {
          struct searchContext context;
  
          context.fSymname = symname;
          context.fFile = file;
          return (const struct nlist *)
              bsearch(&context,
                      file->fLocalSyms, file->fNLocal, sizeof(struct nlist),
                      symbolSearch);
      }
  }
  
  static Boolean
  relocateSection(struct fileRecord *file, struct sectionRecord *sectionRec)
  {
      struct nlist *symbol;
      const struct section *section;
      struct relocRecord *rec;
      struct relocation_info *rinfo;
      unsigned long i;
      unsigned long r_address, r_symbolnum, r_length;
      enum reloc_type_generic r_type;
      UInt8 *sectionBase;
      void **entry;
  
      sectionRec->fRelocCache = DataCreate(
          sectionRec->fSection->nreloc * sizeof(struct relocRecord));
      if (!sectionRec->fRelocCache)
          return false;
  
      section = sectionRec->fSection;
      sectionBase = file->fMachO + section->offset;
  
      rec = (struct relocRecord *) DataGetPtr(sectionRec->fRelocCache);
      rinfo = (struct relocation_info *) (file->fMachO + section->reloff);
      for (i = 0; i < section->nreloc; i++, rec++, rinfo++) {
  
          // Totally uninterested in scattered relocation entries
          if ( (rinfo->r_address & R_SCATTERED) )
              continue;
  
          r_address = rinfo->r_address;
          entry = (void **) (sectionBase + r_address);
  
          /*
           * The r_address field is really an offset into the contents of the
           * section and must reference something inside the section (Note
           * that this is not the case for PPC_RELOC_PAIR entries but this
           * can't be one with the above checks).
           */
          return_if(r_address >= section->size, false,
              ("Invalid relocation entry in %s - not in section\n", file->fPath));
  
          // If we don't have a VANILLA entry or the Vanilla entry isn't
          // a 'long' then ignore the entry and try the next.
          r_type = (enum reloc_type_generic) rinfo->r_type;
          r_length = rinfo->r_length;
          if (r_type != GENERIC_RELOC_VANILLA || r_length != 2)
              continue;
  
          r_symbolnum = rinfo->r_symbolnum;
  
          /*
           * If rinfo->r_extern is set this relocation entry is an external entry
           * else it is a local entry.
           */
          if (rinfo->r_extern) {
              /*
               * This is an external relocation entry.
               * r_symbolnum is an index into the input file's symbol table
               * of the symbol being refered to.  The symbol must be
               * undefined to be used in an external relocation entry.
               */
              return_if(r_symbolnum >= file->fSymtab->nsyms, false, 
                  ("Invalid relocation entry in %s - no symbol\n", file->fPath));
  
              /*
               * If this is an indirect symbol resolve indirection (all chains
               * of indirect symbols have been resolved so that they point at
               * a symbol that is not an indirect symbol).
               */
              symbol = file->fSymbolBase;
              if ((symbol[r_symbolnum].n_type & N_TYPE) == N_INDR)
                  r_symbolnum = symbol[r_symbolnum].n_value;
              symbol = &symbol[r_symbolnum];
  
              return_if(symbol->n_type != (N_EXT | N_UNDF), false, 
                  ("Invalid relocation entry in %s - extern\n", file->fPath));
          }
          else {
              void * addr = *entry;
              /*
               * If the symbol is not in any section then it can't be a
               * pointer to a local segment and I don't care about it.
               */
              if (r_symbolnum == R_ABS)
                  continue;
  
              // Note segment references are offset by 1 from 0.
              return_if(r_symbolnum > file->fNSects, false,
                  ("Invalid relocation entry in %s - local\n", file->fPath));
  
              // Find the symbol, if any, that backs this entry 
  #if !KERNEL
              if (file->fSwapped)
                  addr = (void *) OSSwapInt32((uint32_t) addr);
  #endif
              symbol = findSymbolByAddress(file, addr);
          }
  
          rec->fValue  = *entry;          // Save the previous value
          rec->fRInfo  =  rinfo;          // Save a pointer to the reloc
          rec->fSymbol =  symbol;         // Record the current symbol
  
          *entry = (void *) rec;  // Save pointer to record in object image
      }
  
      DataSetLength(sectionRec->fRelocCache, i * sizeof(struct relocRecord));
      file->fImageDirty = true;
  
      return true;
  }
  
  static const struct nlist *
  findSymbolRefAtLocation(struct fileRecord *file,
                          struct sectionRecord *sctn, void **loc, const struct fileRecord **foundInFile)
  {
      const struct nlist * result;
  
      *foundInFile = file;
  
      if (!file->fIsReloc) {
          if (*loc) {
              void * addr = *loc;
  #if !KERNEL
              if (file->fSwapped)
                  addr = (void *) OSSwapInt32((uint32_t) addr);
  #endif
              result = findSymbolByAddress(file, addr);
              if (!result)
                  result = findSymbolByAddressInAllFiles(file, addr, foundInFile);
              return result;
          }
      }
      else if (sctn->fRelocCache || relocateSection(file, sctn)) {
          struct relocRecord *reloc = (struct relocRecord *) *loc;
  
          if (DataContainsAddr(sctn->fRelocCache, reloc))
              return reloc->fSymbol;
      }
  
      return NULL;
  }
  
  static Boolean
  addClass(struct fileRecord *file,
           struct metaClassRecord *inClass,
           const char *cname)
  {
      Boolean result = false;
      struct metaClassRecord *newClass = NULL;
      struct metaClassRecord **fileClasses = NULL;
      int len;
  
      if (!file->fClassList) {
          file->fClassList = DataCreate(0);
          if (!file->fClassList)
              return false;
      }
  
      do {
          // Attempt to allocate all necessary resource first
          len = strlen(cname) + 1
              + (int) (&((struct metaClassRecord *) 0)->fClassName);
          newClass = (struct metaClassRecord *) malloc(len);
          if (!newClass)
              break;
  
          if (!DataAddLength(file->fClassList, sizeof(struct metaClassRecord *)))
              break;
          fileClasses = (struct metaClassRecord **)
              (DataGetPtr(file->fClassList) + DataGetLength(file->fClassList));
  
          // Copy the meta Class structure and string name into newClass and
          // insert object at end of the file->fClassList and sMergeMetaClasses
          memcpy(newClass, inClass, sizeof(*inClass));
          // metaClassRecord declares fClassName[1]
          strlcpy(newClass->fClassName, cname, strlen(cname) + sizeof(newClass->fClassName));
          fileClasses[-1] = newClass;
  
          return true;
      } while (0);
  
      if (fileClasses)
          DataAddLength(file->fClassList, -sizeof(struct metaClassRecord *));
  
      if (newClass)
          free(newClass);
  
      return result;
  }
  
  static struct metaClassRecord *getClass(DataRef classList, const char *cname)
  {
      if (classList) {
          int i, nclass;
          struct metaClassRecord **classes, *thisClass;
      
          nclass = DataGetLength(classList) / sizeof(struct metaClassRecord *);
          classes = (struct metaClassRecord **) DataGetPtr(classList);
          for (i = 0; i < nclass; i++) {
              thisClass = classes[i];
              if (!strcmp(thisClass->fClassName, cname))
                  return thisClass;
          }
      }
  
      return NULL;
  }
  
  // Add the class 'cname' to the list of known OSObject based classes
  // Note 'sym' is the <cname>10superClassE symbol. 
  static Boolean
  recordClass(struct fileRecord *file, const char *cname, const struct nlist *sym)
  {
      Boolean result = false;
      char *supername = NULL;
      const char *classname = NULL;
      struct metaClassRecord newClass;
      char strbuffer[1024];
  
      // Only do the work to find the super class if we are
      // not currently working on the kernel.  The kernel is the end
      // of all superclass chains by definition as the kernel must be binary
      // compatible with itself.
      if (file->fIsReloc) {
          const char *suffix;
          const struct fileRecord *superfile;
          const struct nlist *supersym;
          const struct section *section;
          struct sectionRecord *sectionRec;
          unsigned char sectind = sym->n_sect;
          const char *superstr;
          void **location;
          int snamelen;
  
          // We can't resolve anything that isn't in a real section
          // Note that the sectind is starts at one to make room for the
          // NO_SECT flag but the fNSects field isn't offset so we have a
          // '>' test.  Which means this isn't an OSObject based class
          if (sectind == NO_SECT || sectind > file->fNSects) {
              result = true;
              goto finish;
          }
          sectionRec = file->fSections + sectind - 1;
          section = sectionRec->fSection;
          location = (void **) ( file->fMachO + section->offset
                              + sym->n_value - section->addr );
          
          supersym = findSymbolRefAtLocation(file, sectionRec, location, &superfile);
          if (!supersym) {
              result = true; // No superclass symbol then it isn't an OSObject.
              goto finish;
          }
  
          // Find string in file and skip leading '_' and then find the suffix
          superstr = symbolname(superfile, supersym) + 1;
          suffix = superstr + strlen(superstr) - sizeof(kGMetaSuffix) + 1;
          if (suffix <= superstr || strcmp(suffix, kGMetaSuffix)) {
              result = true;      // Not an OSObject superclass so ignore it..
              goto finish;
          }
  
          // Got a candidate so hand it over for class processing.
          snamelen = suffix - superstr - sizeof(kOSObjPrefix) + 2;
          supername = (char *) malloc(snamelen + 1);
          bcopy(superstr + sizeof(kOSObjPrefix) - 2, supername, snamelen);
          supername[snamelen] = '\0';
      }
  
      do {
          break_if(getClass(file->fClassList, cname),
              ("Duplicate class %s in %s\n", cname, file->fPath));
  
          snprintf(strbuffer, sizeof(strbuffer), "%s%s", kVTablePrefix, cname);
          newClass.fVTableSym = findSymbolByName(file, strbuffer);
          break_if(!newClass.fVTableSym,
              ("Can't find vtable %s in %s\n", cname, file->fPath));
  
          newClass.fFile = file;
          newClass.fSuperName = supername;
          newClass.fPatchedVTable = NULL;
      
          // Can't use cname as it may be a stack variable
          // However the vtable's string has the class name as a suffix
          // so why don't we use that rather than mallocing a string.
          classname = symbolname(file, newClass.fVTableSym)
                  + sizeof(kVTablePrefix) - 1;
          break_if(!addClass(file, &newClass, classname),
                      ("recordClass - no memory?\n"));
  
          supername = NULL;
          result = true;
      } while (0);
  
  finish:
      if (supername)
          free(supername);
  
      return result;
  }
  
  
  static Boolean getMetaClassGraph(struct fileRecord *file)
  {
      const struct nlist *sym;
      int i, nsyms;
  
      // Search the symbol table for the local symbols that are generated
      // by the metaclass system.  There are three metaclass variables
      // that are relevant.
      //
      //   <ClassName>.metaClass  A pointer to the meta class structure.
      //   <ClassName>.superClass A pointer to the super class's meta class.
      //   <ClassName>.gMetaClass The meta class structure itself.
      //   ___vt<ClassName>       The VTable for the class <ClassName>.
      //
      // In this code I'm going to search for any symbols that
      // ends in k31SuperClassSuffix as this indicates this class is a conforming
      // OSObject subclass and will need to be patched, and it also
      // contains a pointer to the super class's meta class structure.
      sym = file->fLocalSyms;
      for (i = 0, nsyms = file->fNLocal; i < nsyms; i++, sym++) {
          const char *symname;
          const char *suffix;
          char classname[1024];
          unsigned char n_type = sym->n_type & (N_TYPE | N_EXT);
          int cnamelen;
  
          // Check that the symbols is a global and that it has a name.
          if (((N_SECT | N_EXT) != n_type && (N_ABS | N_EXT) != n_type)
          ||  !sym->n_un.n_strx)
              continue;
  
          // Only search from the last *sep* in the symbol.
          // but skip the leading '_' in all symbols first.
          symname = symbolname(file, sym) + 1;
          if (symname[0] != kCPPSymbolPrefix[0]
          ||  symname[1] != kCPPSymbolPrefix[1])
              continue;
  
          suffix = symname + strlen(symname) - sizeof(k31SuperClassSuffix) + 1;
          if (suffix <= symname || strcmp(suffix, k31SuperClassSuffix))
              continue;
  
          // Got a candidate so hand it over for class processing.
          cnamelen = suffix - symname - sizeof(kOSObjPrefix) + 2;
          return_if(cnamelen + 1 >= (int) sizeof(classname),
              false, ("Symbol %s is too long", symname));
  
          bcopy(symname + sizeof(kOSObjPrefix) - 2, classname, cnamelen);
          classname[cnamelen] = '\0';
          if (!recordClass(file, classname, sym))
              return false;
      }
  
      return_if(!file->fClassList, false, ("Internal error, "
                "getMetaClassGraph(%s) found no classes", file->fPath)); 
  
      DEBUG_LOG(("Found %ld classes in %p for %s\n",
          DataGetLength(file->fClassList)/sizeof(void*),
          file->fClassList, file->fPath));
  
      return true;
  }
  
  static Boolean mergeOSObjectsForFile(const struct fileRecord *file)
  {
      int i, nmerged;
      Boolean foundDuplicates = false;
  
      DEBUG_LOG(("Merging file %s\n", file->fPath));      // @@@ gvdl:
  
      if (!file->fClassList)
          return true;
  
      if (!sMergedFiles) {
          sMergedFiles = DataCreate(0);
          return_if(!sMergedFiles, false,
              ("Unable to allocate memory metaclass list\n", file->fPath));
      }
  
      // Check to see if we have already merged this file
      nmerged = DataGetLength(sMergedFiles) / sizeof(struct fileRecord *);
      for (i = 0; i < nmerged; i++) {
          if (file == ((void **) DataGetPtr(sMergedFiles))[i])
              return true;
      }
  
      if (!sMergeMetaClasses) {
          sMergeMetaClasses = DataCreate(0);
          return_if(!sMergeMetaClasses, false,
              ("Unable to allocate memory metaclass list\n", file->fPath));
      }
      else {      /* perform a duplicate check */
          int k, j, cnt1, cnt2;
          struct metaClassRecord **list1, **list2;
  
          list1 = (struct metaClassRecord **) DataGetPtr(file->fClassList);
          cnt1  = DataGetLength(file->fClassList)  / sizeof(*list1);
          list2 = (struct metaClassRecord **) DataGetPtr(sMergeMetaClasses);
          cnt2  = DataGetLength(sMergeMetaClasses) / sizeof(*list2);
  
          for (k = 0; k < cnt1; k++) {
              for (j = 0; j < cnt2; j++) {
                  if (!strcmp(list1[k]->fClassName, list2[j]->fClassName)) {
                      errprintf("duplicate class %s in %s & %s\n",
                                list1[k]->fClassName,
                                file->fPath, list2[j]->fFile->fPath);
  
                      foundDuplicates = true;
                  }
              }
          }
      }
      if (foundDuplicates)
          return false;
  
      return_if(!DataAppendBytes(sMergedFiles, &file, sizeof(file)), false,
          ("Unable to allocate memory to merge %s\n", file->fPath));
  
      return_if(!DataAppendData(sMergeMetaClasses, file->fClassList), false,
          ("Unable to allocate memory to merge %s\n", file->fPath));
  
      if (file == sKernelFile)
          sMergedKernel = true;
  
      return true;
  }
  
  // Returns a pointer to the base of the section offset by the sections
  // base address.  The offset is so that we can add nlist::n_values directly
  // to this address and get a valid pointer in our memory.
  static unsigned char *
  getSectionForSymbol(const struct fileRecord *file, const struct nlist *symb,
                      void ***endP)
  {
      const struct section *section;
      unsigned char sectind;
      unsigned char *base;
  
      sectind = symb->n_sect;     // Default to symbols section
      if ((symb->n_type & N_TYPE) == N_ABS && !file->fIsReloc) {
          // Absolute symbol so we have to iterate over our sections
          for (sectind = 1; sectind <= file->fNSects; sectind++) {
              unsigned long start, end;
  
              section = file->fSections[sectind - 1].fSection;
              start = section->addr;
              end   = start + section->size;
              if (start <= symb->n_value && symb->n_value < end) {
                  // Found the relevant section
                  break;
              }
          }
      }
  
      // Is the vtable in a valid section?
      return_if(sectind == NO_SECT || sectind > file->fNSects,
          (unsigned char *) -1,
          ("%s isn't a valid kext, bad section reference\n", file->fPath));
  
      section = file->fSections[sectind - 1].fSection;
  
      // for when we start walking the vtable so compute offset's now.
      base = file->fMachO + section->offset;
      *endP = (void **) (base + section->size);
  
      return base - section->addr;        // return with addr offset
  }
  
  static Boolean resolveKernelVTable(struct metaClassRecord *metaClass)
  {
      const struct fileRecord *file;
      struct patchRecord *patchedVTable;
      void **curEntry, **vtableEntries, **endSection;
      unsigned char *sectionBase;
      struct patchRecord *curPatch;
      int classSize;
  
      // Should never occur but it doesn't cost us anything to check.
      if (metaClass->fPatchedVTable)
          return true;
  
      DEBUG_LOG(("Kernel vtable %s\n", metaClass->fClassName));   // @@@ gvdl:
  
      // Do we have a valid vtable to patch?
      return_if(!metaClass->fVTableSym,
          false, ("Internal error - no class vtable symbol?\n"));
  
      file = metaClass->fFile;
  
      // If the metaClass we are being to ask is in the kernel then we
      // need to do a quick scan to grab the fPatchList in a reliable format
      // however we don't need to check the superclass in the kernel
      // as the kernel vtables are always correct wrt themselves.
      // Note this ends the superclass chain recursion.
      return_if(file->fIsReloc,
          false, ("Internal error - resolveKernelVTable is relocateable\n"));
  
      if (file->fNoKernelExecutable) {
          // Oh dear attempt to map the kernel's VM into my memory space
          return_if(file->fNoKernelExecutable, false,
              ("Internal error - fNoKernelExecutable not implemented yet\n"));
      }
  
      // We are going to need the base and the end
      sectionBase = getSectionForSymbol(file, metaClass->fVTableSym, &endSection);
      if (-1 == (long) sectionBase)
          return false;
  
      vtableEntries  = (void **) (sectionBase + metaClass->fVTableSym->n_value);
      curEntry = vtableEntries + kVTablePreambleLen;
      for (classSize = 0; curEntry < endSection && *curEntry; classSize++)
          curEntry++;
  
      return_if(*curEntry, false, ("Bad kernel image, short section\n"));
  
      patchedVTable = (struct patchRecord *)
          malloc((classSize + 1) * sizeof(struct patchRecord));
      return_if(!patchedVTable, false, ("resolveKernelVTable - no memory\n"));
  
      // Copy the vtable of this class into the patch table
      curPatch = patchedVTable;
      curEntry = vtableEntries + kVTablePreambleLen;
      for (; *curEntry; curEntry++, curPatch++) {
          void * addr = *curEntry;
  #if !KERNEL
          if (file->fSwapped)
              addr = (void *) OSSwapInt32((uint32_t) addr);
  #endif
          curPatch->fSymbol =
              findSymbolByAddress(file, addr);
          if (curPatch->fSymbol)
          {
              curPatch->fType = kSymbolLocal;
              curPatch->fFile = file;
          }
          else
          {
              curPatch->fSymbol =
                  findSymbolByAddressInAllFiles(file, addr, &curPatch->fFile);
              if (!curPatch->fSymbol) {
                  errprintf("%s: !findSymbolByAddressInAllFiles(%p)\n",
                              file->fPath, addr);
                  return false;
              }
              curPatch->fType = kSymbolLocal;
          }
      }
  
      // Tag the end of the patch vtable
      curPatch->fSymbol = NULL;
      metaClass->fPatchedVTable = patchedVTable;
  
      return true;
  }
  
  static char *addNewString(struct fileRecord *file, 
                                  const char *strname, unsigned int namelen)
  {
      DataRef strings = 0;
      char *newStr;
  
      namelen++;  // Include terminating '\0';
  
      // Make sure we have a string table as well for this symbol
      if (file->fNewStringBlocks) {
          DataRef *blockTable = (DataRef *) DataGetPtr(file->fNewStringBlocks);
          int index = DataGetLength(file->fNewStringBlocks) / sizeof(DataRef*);
          strings = blockTable[index - 1];
          if (DataRemaining(strings) < namelen)
              strings = 0;
      }
      else
      {
          file->fNewStringBlocks = DataCreate(0);
          return_if(!file->fNewStringBlocks, NULL,
              ("Unable to allocate new string table %s\n", file->fPath));
      }
  
      if (!strings) {
          int size = (namelen + 1023) & ~1023;
          if (size < 16 * 1024)
              size = 16 * 1024; 
          strings = DataCreate(size);
          return_if(!strings, NULL,
              ("Unable to allocate new string block %s\n", file->fPath));
          return_if(
              !DataAppendBytes(file->fNewStringBlocks, &strings, sizeof(strings)),
              false, ("Unable to allocate string table for %s\n", file->fPath));
      }
  
      newStr = DataGetEndPtr(strings);
      DataAppendBytes(strings, strname, namelen);
      return newStr;
  }
  
  // reloc->fPatch must contain a valid pointer
  static struct nlist *
  getNewSymbol(struct fileRecord *file,
               struct relocRecord *reloc, const char *supername)
  {
      unsigned int size, i;
      struct nlist **sym;
      struct nlist *msym;
      struct relocation_info *rinfo;
      const char *newStr;
  
      if (!file->fNewSymbols) {
          file->fNewSymbols = DataCreate(0);
          return_if(!file->fNewSymbols, NULL,
              ("Unable to allocate new symbol table for %s\n", file->fPath));
      }
  
      rinfo = (struct relocation_info *) reloc->fRInfo;
      size = DataGetLength(file->fNewSymbols) / sizeof(struct nlist *);
      sym = (struct nlist **) DataGetPtr(file->fNewSymbols);
      for (i = 0; i < size; i++, sym++) {
          int symnum = i + file->fSymtab->nsyms;
          newStr = symNameByIndex(file, symnum);
          if (!strcmp(newStr, supername)) {
              rinfo->r_symbolnum = symnum;
              file->fSymbolsDirty = true; 
              return *sym;
          }
      }
  
      if (reloc->fSymbol->n_un.n_strx >= 0) {
          // This symbol has not been previously processed, so assert that it
          // is a valid non-local symbol.  I need this condition to be true for
          // the later code to set to -1.  Now, being the first time through,
          // I'd better make sure that n_sect is NO_SECT.
  
          return_if(reloc->fSymbol->n_sect != NO_SECT, NULL,
              ("Undefined symbol entry with non-zero section %s:%s\n",
              file->fPath, symbolname(file, reloc->fSymbol)));
  
          // Mark the original symbol entry as having been processed.
          // This means that we wont attempt to create the symbol again
          // in the future if we come through a different path.
          reloc->fSymbol->n_un.n_strx =
              -reloc->fSymbol->n_un.n_strx;    
  
          // Mark the old symbol as being potentially deletable I can use the
          // n_sect field as the input symbol must be of type N_UNDF which means
          // that the n_sect field must be set to NO_SECT otherwise it is an
          // invalid input file.
          reloc->fSymbol->n_sect = (unsigned char) -1;
      }
  
      // If we are here we didn't find the symbol so create a new one now
      msym = (struct nlist *) malloc(sizeof(struct nlist));
      return_if(!msym,
          NULL, ("Unable to create symbol table entry for %s", file->fPath));
      return_if(!DataAppendBytes(file->fNewSymbols, &msym, sizeof(msym)),
              NULL, ("Unable to grow symbol table for %s\n", file->fPath));
  
      newStr = addNewString(file, supername, strlen(supername));
      if (!newStr)
          return NULL;
  
      // If we are here we didn't find the symbol so create a new one now
      return_if(!DataAppendBytes(file->fSym2Strings, &newStr, sizeof(newStr)),
              NULL, ("Unable to grow symbol table for %s\n", file->fPath));
      file->fSymbToStringTable = (char **) DataGetPtr(file->fSym2Strings);
  
      // Offset the string index by the original string table size
      // and negate the address to indicate that this is a 'new' symbol
      msym->n_un.n_strx = -1;
      msym->n_type = (N_EXT | N_UNDF);
      msym->n_sect = NO_SECT;
      msym->n_desc = 0;
      msym->n_value = (unsigned long) newStr;
  
      rinfo->r_symbolnum = i + file->fSymtab->nsyms;
      file->fSymbolsDirty = true; 
      return msym;
  }
  
  static struct nlist *
  fixOldSymbol(struct fileRecord *file,
               const struct relocRecord *reloc, const char *supername)
  {
      unsigned int namelen, oldnamelen;
      struct nlist *sym = (struct nlist *) reloc->fSymbol;
      char *oldname = symbolname(file, sym);
  
      // assert(sym->n_un.n_strx >= 0);
  
      namelen = strlen(supername);
  
      sym->n_un.n_strx = -sym->n_un.n_strx;
      if (oldname && namelen < (oldnamelen = strlen(oldname)))
      {
          // Overwrite old string in string table
          strlcpy((char *) oldname, supername, oldnamelen + 1);
          file->fSymbolsDirty = true; 
          return sym;
      }
  
      oldname = addNewString(file, supername, namelen);
      if (!oldname)
          return NULL;
  
      file->fSymbToStringTable[sym - file->fSymbolBase] = oldname;
      file->fSymbolsDirty = true; 
      return sym;
  }
  
  static enum patchState
  symbolCompare(const struct fileRecord *file,
                const struct nlist *classsym,
                const char *supername)
  {
      const char *classname;
      
  
      // Check to see if the target function is locally defined
      // if it is then we can assume this is a local vtable override
      if ((classsym->n_type & N_TYPE) != N_UNDF)
          return kSymbolLocal;
  
      // Check to see if both symbols point to the same symbol name
      // if so then we are still identical.
      classname = symbolname(file, classsym);
      if (!strcmp(classname, supername))
          return kSymbolIdentical;
  
      // We know that the target's vtable entry is different from the
      // superclass' vtable entry.  This means that we will have to apply a
      // patch to the current entry, however before returning lets check to
      // see if we have a _RESERVEDnnn field 'cause we can use this as a
      // registration point that must align between vtables.
      if (strstr(supername, kReservedNamePrefix))
          return kSymbolMismatch;
  
      // OK, we have a superclass difference where the superclass doesn't
      // reference a pad function so assume that the superclass is correct.
      if (strstr(classname, kReservedNamePrefix))
          return kSymbolPadUpdate; 
      else
          return kSymbolSuperUpdate;
  }
  
  static Boolean patchVTable(struct metaClassRecord *metaClass)
  {
      struct metaClassRecord *super = NULL;
      struct fileRecord *file;
      struct patchRecord *patchedVTable;
      struct relocRecord **curReloc, **vtableRelocs, **endSection;
      unsigned char *sectionBase;
      int classSize;
  
      // Should never occur but it doesn't cost us anything to check.
      if (metaClass->fPatchedVTable)
          return true;
  
      // Do we have a valid vtable to patch?
      return_if(!metaClass->fVTableSym,
          false, ("Internal error - no class vtable symbol?\n"));
  
      file = metaClass->fFile;
  
      if (!file->fIsReloc)
      {
          // If the metaClass we are being to ask is already relocated then we
          // need to do a quick scan to grab the fPatchList in a reliable format
          // however we don't need to check the superclass in the already linked
          // modules as the vtables are always correct wrt themselves.
          // Note this ends the superclass chain recursion.
          Boolean res;
          res = resolveKernelVTable(metaClass);
          return res;
      }
  
      if (!metaClass->fSuperName)
          return false;
  
      // The class isn't in the kernel so make sure that the super class 
      // is patched before patching ouselves.
      super = getClass(sMergeMetaClasses, metaClass->fSuperName);
      return_if(!super, false, ("Can't find superclass for %s : %s\n",
          metaClass->fClassName, metaClass->fSuperName));
  
      // Superclass recursion if necessary
      if (!super->fPatchedVTable) {
          Boolean res;
          res = patchVTable(super);
          if (!res)
              return false;
      }
  
      DEBUG_LOG(("Patching %s\n", metaClass->fClassName));        // @@@ gvdl:
  
      // We are going to need the base and the end
  
      sectionBase = getSectionForSymbol(file,
          metaClass->fVTableSym, (void ***) &endSection);
      if (-1 == (long) sectionBase)
          return false;
  
      vtableRelocs  = (struct relocRecord **)
                          (sectionBase + metaClass->fVTableSym->n_value);
      curReloc = vtableRelocs + kVTablePreambleLen;
      for (classSize = 0; curReloc < endSection && *curReloc; classSize++)
          curReloc++;
  
      return_if(*curReloc, false,
          ("%s isn't a valid kext, short section\n", file->fPath));
  
      patchedVTable = (struct patchRecord *)
          malloc((classSize + 1) * sizeof(struct patchRecord));
      return_if(!patchedVTable, false, ("patchedVTable - no memory\n"));
  
      do {
          struct patchRecord *curPatch;
          struct nlist *symbol;
  
          curPatch = patchedVTable;
          curReloc = vtableRelocs + kVTablePreambleLen;
  
          // Grab the super table patches if necessary
          // Can't be patching a kernel table as we don't walk super
          // class chains in the kernel symbol space.
          if (super && super->fPatchedVTable) {
              const struct patchRecord *spp;
  
              spp = super->fPatchedVTable;
  
              for ( ; spp->fSymbol; curReloc++, spp++, curPatch++) {
                  const char *supername =
                      symbolname(spp->fFile, spp->fSymbol);
  
                  symbol = (struct nlist *) (*curReloc)->fSymbol;
  
                  curPatch->fType = symbolCompare(file, symbol, supername);
                  switch (curPatch->fType) {
                  case kSymbolIdentical:
                  case kSymbolLocal:
                      break;
      
                  case kSymbolSuperUpdate:
                      symbol = getNewSymbol(file, (*curReloc), supername);
                      break;
  
                  case kSymbolPadUpdate:
                      symbol = fixOldSymbol(file, (*curReloc), supername);
                      break;
  
                  case kSymbolMismatch:
                      errprintf("%s is not compatible with its superclass, "
                                "%s superclass changed?\n",
                                metaClass->fClassName, super->fClassName);
                      goto abortPatch;
  
                  default:
                      errprintf("Internal error - unknown patch type\n");
                      goto abortPatch;
                  }
                  if (symbol) {
                      curPatch->fSymbol = symbol;
                      (*curReloc)->fSymbol = symbol;
                      curPatch->fFile = file;
                  }
                  else
                      goto abortPatch;
              }
          }
  
          // Copy the remainder of this class' vtable into the patch table
          for (; *curReloc; curReloc++, curPatch++) {
              // Local reloc symbols
              curPatch->fType = kSymbolLocal;
              curPatch->fSymbol = (struct nlist *) (*curReloc)->fSymbol;
              curPatch->fFile = file;
          }
  
          // Tag the end of the patch vtable
          curPatch->fSymbol = NULL;
  
          metaClass->fPatchedVTable = patchedVTable;
          return true;
      } while(0);
  
  abortPatch:
      if (patchedVTable)
          free(patchedVTable);
  
      return false;
  }
  
  static Boolean growImage(struct fileRecord *file, vm_size_t delta)
  {
  #if !KERNEL
      file->fMachOSize += delta;
      return (file->fMachO + file->fMachOSize <= file->fPadEnd);
  #else /* KERNEL */
      vm_address_t startMachO, endMachO, endMap;
      vm_offset_t newMachO;
      vm_size_t newsize;
      unsigned long i, last = 0;
      struct metaClassRecord **classes = NULL;
      struct sectionRecord *section;
      kern_return_t ret;
  
      startMachO = (vm_address_t) file->fMachO;
      endMachO = startMachO + file->fMachOSize + delta;
      endMap   = (vm_address_t) file->fMap + file->fMapSize;
  
      // Do we have room in the current mapped image
      if (endMachO < round_page_32(endMap)) {
          file->fMachOSize += delta;
          return true;
      }
  
      newsize = endMachO - startMachO;
      if (newsize < round_page_32(file->fMapSize)) {
          DEBUG_LOG(("Growing image %s by moving\n", file->fPath));
  
          // We have room in the map if we shift the macho image within the
          // current map.  We will have to patch up pointers into the object.
          newMachO = (vm_offset_t) file->fMap;
          bcopy((char *) startMachO, (char *) newMachO, file->fMachOSize);
      }
      else if (file->fIsKmem) {
          // kmem_alloced mapping so we can try a kmem_realloc
          ret = kmem_realloc(kernel_map,
                            (vm_address_t) file->fMap,
                            (vm_size_t) file->fMapSize,
                            &newMachO,
                            newsize);
          if (KERN_SUCCESS != ret)
              return false;
  
          // If the mapping didn't move then just return
          if ((vm_address_t) file->fMap == newMachO) {
              file->fMachOSize = file->fMapSize = newsize;
              return true;
          }
  
          DEBUG_LOG(("Growing image %s by reallocing\n", file->fPath));
          // We have relocated the kmem image so we are going to have to
          // move all of the pointers into the image around.
      }
      else {
          DEBUG_LOG(("Growing image %s by allocating\n", file->fPath));
          // The image doesn't have room for us and I can't kmem_realloc
          // then I just have to bite the bullet and copy the object code
          // into a bigger memory segment
          ret = kmem_alloc(kernel_map, &newMachO, newsize);
          
          if (KERN_SUCCESS != ret)
              return false;
          bcopy((char *) startMachO, (void *) newMachO, file->fMachOSize);
          file->fIsKmem = true;
      }
  
  
      file->fMap = file->fMachO = (unsigned char *) newMachO;
      file->fMapSize = newsize;
      file->fMachOSize += delta; // Increment the image size
  
      // If we are here then we have shifted the object image in memory
      // I really should change all of my pointers into the image to machO offsets
      // but I have run out of time.  So I'm going to very quickly go over the
      // cached data structures and add adjustments to the addresses that are
      // affected.  I wonder how long it will take me to get them all.
      //
      // For every pointer into the MachO I need to add an adjustment satisfying
      // the following simultanous equations
      // addr_old = macho_old + fixed_offset
      // addr_new = macho_new + fixed_offset      therefore:
      // addr_new = addr_old + (macho_new - macho_old)
  #define REBASE(addr, delta)     ( *(vm_address_t*)(&addr) += (delta) )
      delta = newMachO - startMachO;
  
      // Rebase the cached-in object 'struct symtab_command' pointer
      REBASE(file->fSymtab, delta);
  
      // Rebase the cached-in object 'struct nlist' pointer for all symbols
      REBASE(file->fSymbolBase, delta);
  
      // Rebase the cached-in object 'struct nlist' pointer for local symbols
      REBASE(file->fLocalSyms, delta);
  
      // Rebase the cached-in object 'char' pointer for the string table
      REBASE(file->fStringBase, delta);
  
      // Ok now we have to go over all of the relocs one last time
      // to clean up the pad updates which had their string index negated
      // to indicate that we have finished with them.
      section = file->fSections;
      for (i = 0, last = file->fNSects; i < last; i++, section++)
          REBASE(section->fSection, delta);
  
      // We only ever grow images that contain class lists so dont bother
      // the check if file->fClassList is non-zero 'cause it can't be
      // assert(file->fClassList);
      last = DataGetLength(file->fClassList)
             / sizeof(struct metaClassRecord *);
      classes = (struct metaClassRecord **) DataGetPtr(file->fClassList);
      for (i = 0; i < last; i++) {
          struct patchRecord *patch;
  
          for (patch = classes[i]->fPatchedVTable; patch->fSymbol; patch++) {
              vm_address_t symAddr = (vm_address_t) patch->fSymbol;
              
              // Only need to rebase if the symbol is part of the image
              // If this is a new symbol then it was independantly allocated
              if (symAddr >= startMachO && symAddr < endMachO)
                  REBASE(patch->fSymbol, delta);
          }
      }
  
      // Finally rebase all of the string table pointers
      last = file->fSymtab->nsyms;
      for (i = 0; i < last; i++)
          REBASE(file->fSymbToStringTable[i], delta);
  
  #undef REBASE
  
      return true;
  
  #endif /* KERNEL */
  }
  
  // Note: This function is only called from kld_file_prepare_for_link()
  // This function can only operate on 32 bit mach-o files
  static Boolean
  prepareFileForLink(struct fileRecord *file)
  {
      unsigned long i, last, numnewsyms, newsymsize, newstrsize;
      struct sectionRecord *section;
      struct nlist **symp, *sym;
      DataRef newStrings, *stringBlocks;
  
      // If we didn't even do a pseudo 'relocate' and dirty the image
      // then we can just return now.
      if (!file->fImageDirty) {
  #if !KERNEL
          if (file->fSwapped) {
              kld_macho_unswap((struct mach_header *) file->fMachO, file->fSwapped, false);
              file->fSwapped = false;
          }
  #endif
          return true;
      }
  
  DEBUG_LOG(("Linking 2 %s\n", file->fPath));     // @@@ gvdl:
  
      // We have to go over all of the relocs to repair the damage
      // that we have done to the image when we did our 'relocation'
      section = file->fSections;
      for (i = 0, last = file->fNSects; i < last; i++, section++) {
          unsigned char *sectionBase;
          struct relocRecord *rec;
          unsigned long j, nreloc;
  
          if (section->fRelocCache) {
              sectionBase = file->fMachO + section->fSection->offset;
              nreloc = section->fSection->nreloc;
              rec = (struct relocRecord *) DataGetPtr(section->fRelocCache);
      
              // We will need to repair the reloc list 
              for (j = 0; j < nreloc; j++, rec++) {
                  void **entry;
                  struct nlist *repairSym;
      
                  return_if(!rec->fRInfo, false,
                           ("Bad Mach-O file; cannot link\n"));
  
                  // Repair Damage to object image
                  entry = (void **) (sectionBase + rec->fRInfo->r_address);
                  *entry = rec->fValue;
  
                  // Check if the symbol that this relocation entry points
                  // to is marked as erasable 
                  repairSym = (struct nlist *) rec->fSymbol;
                  if (repairSym && repairSym->n_type == (N_EXT | N_UNDF)
                  &&  repairSym->n_sect == (unsigned char) -1) {
                      // It is in use so we better clear the mark
                      repairSym->n_un.n_strx = -repairSym->n_un.n_strx;
                      repairSym->n_sect = NO_SECT;
                  }
              }
  
              // Clean up the fRelocCache we don't need it any more.
              DataRelease(section->fRelocCache);
              section->fRelocCache = 0;
          }
      }
      file->fImageDirty = false;  // Image is clean
  
      // If we didn't dirty the symbol table then just return
      if (!file->fSymbolsDirty) {
  #if !KERNEL
          if (file->fSwapped) {
              kld_macho_unswap((struct mach_header *) file->fMachO, file->fSwapped, false);
              file->fSwapped = false;
          }
  #endif
          return true;
      }
  
      // calculate total file size increase and check against padding
      if (file->fNewSymbols) {
          numnewsyms = DataGetLength(file->fNewSymbols);
          symp  = (struct nlist **) DataGetPtr(file->fNewSymbols);
      }
      else {
          numnewsyms = 0;
          symp = 0;
      }
      numnewsyms /= sizeof(struct nlist *);
      file->fSymtab->nsyms  += numnewsyms;
  
      // old sting size + 30% rounded up to nearest page
      newstrsize = file->fSymtab->strsize * 21 / 16;
      newstrsize = (newstrsize + PAGE_MASK) & ~PAGE_MASK;
      newStrings = DataCreate(newstrsize);
      return_if(!newStrings, false,
               ("Unable to allocate a copy aside buffer, no memory\n"));
  
      newsymsize  = numnewsyms * sizeof(struct nlist);
      file->fStringBase     += newsymsize;
      file->fSymtab->stroff += newsymsize;
  
      last = file->fSymtab->nsyms - numnewsyms;
      newstrsize = 0;
      DataAppendBytes(newStrings, &newstrsize, 4);        // Leading nuls
      sym = file->fSymbolBase;
  
      // Pre-compute an already offset new symbol pointer.  The offset is the
      // orignal symbol table.
      symp -= last;
      for (i = 0; i < file->fSymtab->nsyms; i++, sym++) {
          const char *str = symNameByIndex(file, i);
          int len = strlen(str) + 1;
          unsigned int strx;
  
          // Rebase sym in the new symbol region
          if (i >= last)
              sym = symp[i];
  
          if (sym->n_un.n_strx < 0 && sym->n_type == (N_EXT | N_UNDF)
          && (unsigned char) -1 == sym->n_sect) {
              // after patching we find that this symbol is no longer in
              // use.  So invalidate it by converting it into an N_ABS
              // symbol, remove the external bit and null out the name.
              bzero(sym, sizeof(*sym));
              sym->n_type = N_ABS;
          }
          else {
              // Repair the symbol for the getNewSymbol case.
              if (-1 == sym->n_un.n_strx)
                  sym->n_value = 0;
  
              // Record the offset of the string in the new table
              strx = DataGetLength(newStrings);
              return_if(!DataAppendBytes(newStrings, str, len), false,
                  ("Unable to append string, no memory\n"));
  
              sym->n_un.n_strx = strx;
              file->fSymbToStringTable[i] = file->fStringBase + strx;
          }
      }
  
      // Don't need the new strings any more
      
      if (file->fNewStringBlocks){
          last = DataGetLength(file->fNewStringBlocks) / sizeof(DataRef);
          stringBlocks = (DataRef *) DataGetPtr(file->fNewStringBlocks);
      }
      else{
          last =0;
          stringBlocks=0;
      }
      
      for (i = 0; i < last; i++)
          DataRelease(stringBlocks[i]);
  
      DataRelease(file->fNewStringBlocks);
      file->fNewStringBlocks = 0;
  
      newstrsize  = DataGetLength(newStrings);
      newstrsize  = (newstrsize + 3) & ~3;        // Round to nearest word
      return_if(
          !growImage(file, newsymsize + newstrsize - file->fSymtab->strsize),
          false, ("Unable to patch the extension, no memory\n", file->fPath));
  
      // Push out the new symbol table if necessary
      if (numnewsyms) {
          caddr_t base;
  
          // Append the new symbols to the original symbol table.
          base = (caddr_t) file->fSymbolBase
               + (file->fSymtab->nsyms - numnewsyms) * sizeof(struct nlist);
          symp = (struct nlist **) DataGetPtr(file->fNewSymbols);
          for (i = 0; i < numnewsyms; i++, base += sizeof(struct nlist), symp++)
              bcopy(*symp, base, sizeof(struct nlist));
  
          DataRelease(file->fNewSymbols);
          file->fNewSymbols = 0;
      }
  
      // Push out the new string table if necessary
      if (newStrings) {
          unsigned long *base = (unsigned long *) file->fStringBase;
          unsigned long actuallen = DataGetLength(newStrings);
  
          // Set the last word in string table to zero before copying data
          base[(newstrsize / sizeof(unsigned long)) - 1] = 0;
  
          // Now copy the new strings back to the end of the file
          bcopy((caddr_t) DataGetPtr(newStrings), file->fStringBase, actuallen);
  
          file->fSymtab->strsize = newstrsize;
  
          DataRelease(newStrings);
      }
  
      file->fSymbolsDirty = false;
  #if !KERNEL
      if (file->fSwapped) {
          kld_macho_unswap((struct mach_header *) file->fMachO, file->fSwapped, false);
          file->fSwapped = false;
      }
  #endif
      return true;
  }
  
  // This function can only operate on 32 bit mach-o files
  Boolean
  #if KERNEL
  kld_file_map(const char *pathName,
               unsigned char *map,
               size_t mapSize,
               Boolean isKmem)
  #else
  kld_file_map(const char *pathName)
  #endif /* KERNEL */
  {
      struct fileRecord file, *fp = 0;
  
      // Already done no need to repeat
      fp = getFile(pathName);
      if (fp)
          return true;
  
      bzero(&file, sizeof(file));
  
  #if KERNEL
      file.fMap = map;
      file.fMapSize = mapSize;
      file.fIsKmem = isKmem;
  #else
      if (!mapObjectFile(&file, pathName))
          return false;
  #endif /* KERNEL */
  
      do {
          struct machOMapping {
              struct mach_header h;
              struct load_command c[1];
          } *machO;
          struct load_command *cmd;
          boolean_t lookVMRange;
          unsigned long i;
  
          if (!findBestArch(&file, pathName))
              break;
  
          machO = (struct machOMapping *) file.fMachO;
          if (file.fMachOSize < machO->h.sizeofcmds)
              break;
  
          // If the file type is MH_EXECUTE then this must be a kernel
          // as all Kernel extensions must be of type MH_OBJECT
          file.fIsKernel = (MH_EXECUTE == machO->h.filetype);
  
          for (i = 0, cmd = &machO->c[0], lookVMRange = true; i < machO->h.ncmds; i++) {
              if (cmd->cmd == LC_SYMTAB)
                  file.fSymtab = (struct symtab_command *) cmd;
              else if (cmd->cmd == LC_SEGMENT) {
                  struct segment_command *seg = (struct segment_command *)cmd;
                  int nsects = seg->nsects;
  
                  if (lookVMRange) {
                      if (!strcmp("__PRELINK", seg->segname))
                          // segments following __PRELINK are going to move, so ignore them
                          lookVMRange = false;
                      else if (!file.fVMAddr && !file.fVMEnd) {
                          file.fVMAddr = seg->vmaddr;
                          file.fVMEnd = seg->vmaddr + seg->vmsize;
                      } else {
                          if (seg->vmaddr < file.fVMAddr)
                              file.fVMAddr = seg->vmaddr;
                          if ((seg->vmaddr + seg->vmsize) > file.fVMEnd)
                              file.fVMEnd = seg->vmaddr + seg->vmsize;
                      }
                  }
  
                  if (nsects)
                      return_if(!parseSegments(&file, seg),
                                false, ("%s isn't a valid mach-o, bad segment",
                                pathName));
  
                  if (file.fIsKernel) {
  #if KERNEL
                      // We don't need to look for the LinkEdit segment unless
                      // we are running in the kernel environment.
                      if (!strcmp(kLinkEditSegName, seg->segname))
                          file.fLinkEditSeg = seg;
  #endif
                  }
              }
              cmd = (struct load_command *) ((UInt8 *) cmd + cmd->cmdsize);
          }
          break_if(!file.fSymtab,
              ("%s isn't a valid mach-o, no symbols\n", pathName));
  
          if (machO->h.flags & MH_INCRLINK) {
  
              file.fIsIncrLink = true;
              machO->h.flags &= ~MH_INCRLINK;
  
  #if !KERNEL
              // the symtab fileoffset is the end of seg0's vmsize,
              // which can be (rarely) unaligned.
              unsigned int
              align = file.fSymtab->symoff % sizeof(long);
              if (align != 0) {
                  align = sizeof(long) - align;
                  growImage(&file, align);
                  bcopy(file.fMachO + file.fSymtab->symoff,
                          file.fMachO + file.fSymtab->symoff + align,
                          file.fSymtab->stroff + file.fSymtab->strsize - file.fSymtab->symoff);
                  file.fSymtab->symoff += align;
                  file.fSymtab->stroff += align;
              }
  #endif
          }
  
          if (!parseSymtab(&file, pathName))
              break;
  
          fp = addFile(&file, pathName);
          if (!fp)
              break;
  
          if (file.fFoundOSObject && !getMetaClassGraph(fp))
              break;
  
          if (file.fIsKernel)
              sKernelFile = fp;
  
  #if KERNEL
          // Automatically load the kernel's link edit segment if we are
          // attempting to load a driver.
          if (!sKernelFile) {
              struct segment_command *sg;
              size_t kernelSize;
              Boolean ret;
  
              sg = (struct segment_command *) getsegbyname(kLinkEditSegName); 
              break_if(!sg, ("Can't find kernel link edit segment\n"));
      
              kernelSize = sg->vmaddr + sg->vmsize - (size_t) &_mh_execute_header;
              ret = kld_file_map(kld_basefile_name,
                  (unsigned char *) &_mh_execute_header, kernelSize,
                  /* isKmem */ false);
              break_if(!ret, ("kld can't map kernel file"));
          }
  #endif  /* KERNEL */
  
          return true;
      } while(0);
  
      // Failure path, then clean up
      if (fp)
          // @@@ gvdl: for the time being leak the file ref in the file table
          removeFile(fp);
      else
          unmapFile(&file);
  
      return false;
  }
  
  void *kld_file_getaddr(const char *pathName, unsigned long *size)
  {
      struct fileRecord *file = getFile(pathName);
  
      if (!file)
          return 0;
  
      if (size)
          *size = file->fMachOSize;
  
      return file->fMachO;
  }
  
  void *kld_file_lookupsymbol(const char *pathName, const char *symname)
  {
      struct fileRecord *file = getFile(pathName);
      const struct nlist *sym;
      const struct section *section;
      unsigned char *sectionBase;
      unsigned char sectind;
  
      return_if(!file,
          NULL, ("Unknown file %s\n", pathName));
  
      sym = findSymbolByName(file, symname);
  
      // May be a non-extern symbol so look for it there
      if (!sym) {
          unsigned int i, nsyms;
  
          sym = file->fSymbolBase;
          for (i = 0, nsyms = file->fSymtab->nsyms; i < nsyms; i++, sym++) {
              if ( (sym->n_type & N_EXT) ) {
                  sym = 0;
                  break;  // Terminate search when we hit an extern
              }
              if ( (sym->n_type & N_STAB) )
                  continue;
              if ( !strcmp(symname, symNameByIndex(file, i)) )
                  break;
          }
      }
  
      return_if(!sym,
          NULL, ("Unknown symbol %s in %s\n", symname, pathName));
  
      // Is the vtable in a valid section?
      sectind = sym->n_sect;
      return_if(sectind == NO_SECT || sectind > file->fNSects, NULL,
          ("Malformed object file, invalid section reference for %s in %s\n",
              symname, pathName));
  
      section = file->fSections[sectind - 1].fSection;
      sectionBase = file->fMachO + section->offset - section->addr;
  
      return (void *) (sectionBase + sym->n_value);
  }
  
  Boolean kld_file_merge_OSObjects(const char *pathName)
  {
      struct fileRecord *file = getFile(pathName);
  
      return_if(!file,
          false, ("Internal error - unable to find file %s\n", pathName));
  
      return mergeOSObjectsForFile(file);
  }
  
  Boolean kld_file_patch_OSObjects(const char *pathName)
  {
      struct fileRecord *file = getFile(pathName);
      struct metaClassRecord **classes;
      unsigned long i, last;
  
      return_if(!file,
          false, ("Internal error - unable to find file %s\n", pathName));
  
      DEBUG_LOG(("Patch file %s\n", pathName));   // @@@ gvdl:
  
      // If we don't have any classes we can return now.
      if (!file->fClassList)
          return true;
  
      // If we haven't alread merged the kernel then do it now
      if (!sMergedKernel && sKernelFile)
          mergeOSObjectsForFile(sKernelFile);
      return_if(!sMergedKernel, false, ("Internal error no kernel?\n"));
  
      if (!mergeOSObjectsForFile(file))
          return false;
  
      // Patch all of the classes in this executable
      last = DataGetLength(file->fClassList) / sizeof(void *);
      classes = (struct metaClassRecord **) DataGetPtr(file->fClassList);
      for (i = 0; i < last; i++) {
          if (!patchVTable(classes[i])) {            
              // RY: Set a flag in the file list to invalidate this data.
              // I would remove the file from the list, but that seems to be
              // not worth the effort.            
              file->fIgnoreFile = TRUE;
              
              return false;
          }
      }
  
      return true;
  }
  
  Boolean kld_file_prepare_for_link(void)
  {
      if (sMergedFiles) {
          unsigned long i, nmerged = 0;
          struct fileRecord **files;
      
          // Check to see if we have already merged this file
          nmerged = DataGetLength(sMergedFiles) / sizeof(struct fileRecord *);
          files = (struct fileRecord **) DataGetPtr(sMergedFiles);
          for (i = 0; i < nmerged; i++) {                
              if (!files[i]->fIgnoreFile && !prepareFileForLink(files[i]))
                  return false;
          }
      }
  
      // Clear down the meta class table and merged file lists
      DataRelease(sMergeMetaClasses);
      DataRelease(sMergedFiles);
      sMergedFiles = sMergeMetaClasses = NULL;
      sMergedKernel = false;
  
      return true;
  }
  
  void kld_file_cleanup_all_resources(void)
  {
      unsigned long i, nfiles;
  
  #if KERNEL      // @@@ gvdl:
      // Debugger("kld_file_cleanup_all_resources");
  #endif
  
      if (!sFilesTable || !(nfiles = DataGetLength(sFilesTable)))
          return; // Nothing to do just return now
  
      nfiles /= sizeof(struct fileRecord *);
      for (i = 0; i < nfiles; i++)
          removeFile(((void **) DataGetPtr(sFilesTable))[i]);
  
      DataRelease(sFilesTable);
      sFilesTable = NULL;
  
      // Don't really have to clean up anything more as the whole
      // malloc engine is going to be released and I couldn't be bothered.
  }
  
  
  #if !KERNEL
  #if 0
  static const struct fileRecord *sortFile;
  static int symCompare(const void *vSym1, const void *vSym2)
  {
      const struct nlist *sym1 = vSym1;
      const struct nlist *sym2 = vSym2;
  
      {
          unsigned int ind1, ind2;
      
          ind1 = sym1->n_type & N_TYPE;
          ind2 = sym2->n_type & N_TYPE;
          if (ind1 != ind2) {
              // if sym1 is undefined then sym1 must come later than sym2
              if (ind1 == N_UNDF)
                  return 1;
              // if sym2 is undefined then sym1 must come earlier than sym2
              if (ind2 == N_UNDF)
                  return -1;
              /* drop out if neither are undefined */
          }
      }
  
      {
          const struct fileRecord *file = sortFile;
          const char *name1, *name2;
      
          name1 = file->fStringBase + sym1->n_un.n_strx;
          name2 = file->fStringBase + sym2->n_un.n_strx;
          return strcmp(name1, name2);
      }
  }
  #endif /* 0 */
  
  Boolean kld_file_debug_dump(const char *pathName, const char *outName)
  {
      const struct fileRecord *file = getFile(pathName);
      int fd;
      Boolean ret = false;
  
      return_if(!file, false, ("Unknown file %s for dumping\n", pathName));
  
      fd = open(outName, O_WRONLY|O_CREAT|O_TRUNC, 0666);
      return_if(-1 == fd, false, ("Can't create output file %s - %s(%d)\n",
          outName, strerror(errno), errno));
  
      do {
  #if 0
          // Sorting doesn't work until I fix the relocs too?
  
          // sort the symbol table appropriately
          unsigned int nsyms = file->fSymtab->nsyms
                             - (file->fLocalSyms - file->fSymbolBase);
          sortFile = file;
          heapsort((void *) file->fLocalSyms, nsyms, sizeof(struct nlist),
                  symCompare);
  #endif
  
          break_if(-1 == write(fd, file->fMachO, file->fMachOSize),
              ("Can't dump output file %s - %s(%d)\n", 
                  outName, strerror(errno), errno));
          ret = true;
      } while(0);
  
      close(fd);
  
      return ret;
  }
  
  #endif /* !KERNEL */
  

Cache object: 95c03a14c727e332909bb2d9f6f393e6