/* Determines whether an executable's header matches the current architecture, ppc, and/or i386.
* Returns true if the header corresponds to a Mach-O, 64-bit Mach-O, or universal binary executable, false otherwise.
* Returns by reference the result of matching against a given architecture (matches_current, matches_ppc, matches_i386).
* Checks for a given architecture only if the corresponding return-by-reference argument is non-NULL.
*/
static Boolean examine_header(uint8_t *bytes, ssize_t length, Boolean *matches_current, Boolean *matches_ppc, Boolean *matches_i386) {
Boolean retval = false;
uint32_t magic = 0, num_fat = 0, max_fat = 0;
struct fat_arch one_fat = {0}, *fat = NULL;
const NXArchInfo *current_arch, *ppc_arch, *i386_arch;
// Look for any of the six magic numbers relevant to Mach-O executables, and swap the header if necessary.
if (length >= sizeof(struct mach_header_64)) {
magic = *((uint32_t *)bytes);
max_fat = (length - sizeof(struct fat_header)) / sizeof(struct fat_arch);
if (MH_MAGIC == magic || MH_CIGAM == magic) {
struct mach_header *mh = (struct mach_header *)bytes;
if (MH_CIGAM == magic) swap_header(bytes, length);
one_fat.cputype = mh->cputype;
one_fat.cpusubtype = mh->cpusubtype;
fat = &one_fat;
num_fat = 1;
} else if (MH_MAGIC_64 == magic || MH_CIGAM_64 == magic) {
struct mach_header_64 *mh = (struct mach_header_64 *)bytes;
if (MH_CIGAM_64 == magic) swap_header(bytes, length);
one_fat.cputype = mh->cputype;
one_fat.cpusubtype = mh->cpusubtype;
fat = &one_fat;
num_fat = 1;
} else if (FAT_MAGIC == magic || FAT_CIGAM == magic) {
fat = (struct fat_arch *)(bytes + sizeof(struct fat_header));
if (FAT_CIGAM == magic) swap_header(bytes, length);
num_fat = ((struct fat_header *)bytes)->nfat_arch;
if (num_fat > max_fat) num_fat = max_fat;
}
}
// Set the return value depending on whether the header appears valid.
retval = ((fat && num_fat > 0) ? true : false);
// Check for a match against the current architecture specification, if requested.
if (matches_current) {
current_arch = NXGetLocalArchInfo();
*matches_current = ((retval && current_arch && NXFindBestFatArch(current_arch->cputype, current_arch->cpusubtype, fat, num_fat)) ? true : false);
}
// Check for a match against the ppc architecture specification, if requested.
if (matches_ppc) {
ppc_arch = NXGetArchInfoFromName("ppc");
*matches_ppc = ((retval && ppc_arch && NXFindBestFatArch(ppc_arch->cputype, ppc_arch->cpusubtype, fat, num_fat)) ? true : false);
}
// Check for a match against the i386 architecture specification, if requested.
if (matches_i386) {
i386_arch = NXGetArchInfoFromName("i386");
*matches_i386 = ((retval && i386_arch && NXFindBestFatArch(i386_arch->cputype, i386_arch->cpusubtype, fat, num_fat)) ? true : false);
}
return retval;
}
MODULE_SCOPE int
TclpLoadMemory(
Tcl_Interp *interp, /* Used for error reporting. */
void *buffer, /* Buffer containing the desired code
* (allocated with TclpLoadMemoryGetBuffer). */
int size, /* Allocation size of buffer. */
int codeSize, /* Size of code data read into buffer or -1 if
* an error occurred and the buffer should
* just be freed. */
Tcl_LoadHandle *loadHandle, /* Filled with token for dynamically loaded
* file which will be passed back to
* (*unloadProcPtr)() to unload the file. */
Tcl_FSUnloadFileProc **unloadProcPtr)
/* Filled with address of Tcl_FSUnloadFileProc
* function which should be used for this
* file. */
{
Tcl_DyldLoadHandle *dyldLoadHandle;
NSObjectFileImage dyldObjFileImage = NULL;
Tcl_DyldModuleHandle *modulePtr;
NSModule module;
const char *objFileImageErrMsg = NULL;
/*
* Try to create an object file image that we can load from.
*/
if (codeSize >= 0) {
NSObjectFileImageReturnCode err = NSObjectFileImageSuccess;
const struct fat_header *fh = buffer;
uint32_t ms = 0;
#ifndef __LP64__
const struct mach_header *mh = NULL;
#define mh_size sizeof(struct mach_header)
#define mh_magic MH_MAGIC
#define arch_abi 0
#else
const struct mach_header_64 *mh = NULL;
#define mh_size sizeof(struct mach_header_64)
#define mh_magic MH_MAGIC_64
#define arch_abi CPU_ARCH_ABI64
#endif
if ((size_t) codeSize >= sizeof(struct fat_header)
&& fh->magic == OSSwapHostToBigInt32(FAT_MAGIC)) {
uint32_t fh_nfat_arch = OSSwapBigToHostInt32(fh->nfat_arch);
/*
* Fat binary, try to find mach_header for our architecture
*/
TclLoadDbgMsg("Fat binary, %d archs", fh_nfat_arch);
if ((size_t) codeSize >= sizeof(struct fat_header) +
fh_nfat_arch * sizeof(struct fat_arch)) {
void *fatarchs = (char*)buffer + sizeof(struct fat_header);
const NXArchInfo *arch = NXGetLocalArchInfo();
struct fat_arch *fa;
if (fh->magic != FAT_MAGIC) {
swap_fat_arch(fatarchs, fh_nfat_arch, arch->byteorder);
}
fa = NXFindBestFatArch(arch->cputype | arch_abi,
arch->cpusubtype, fatarchs, fh_nfat_arch);
if (fa) {
TclLoadDbgMsg("NXFindBestFatArch() successful: "
"local cputype %d subtype %d, "
"fat cputype %d subtype %d",
arch->cputype | arch_abi, arch->cpusubtype,
fa->cputype, fa->cpusubtype);
mh = (void*)((char*)buffer + fa->offset);
ms = fa->size;
} else {
TclLoadDbgMsg("NXFindBestFatArch() failed");
err = NSObjectFileImageInappropriateFile;
}
if (fh->magic != FAT_MAGIC) {
swap_fat_arch(fatarchs, fh_nfat_arch, arch->byteorder);
}
} else {
TclLoadDbgMsg("Fat binary header failure");
err = NSObjectFileImageInappropriateFile;
}
} else {
/*
* Thin binary
*/
TclLoadDbgMsg("Thin binary");
mh = buffer;
ms = codeSize;
}
if (ms && !(ms >= mh_size && mh->magic == mh_magic &&
mh->filetype == MH_BUNDLE)) {
TclLoadDbgMsg("Inappropriate file: magic %x filetype %d",
mh->magic, mh->filetype);
err = NSObjectFileImageInappropriateFile;
}
if (err == NSObjectFileImageSuccess) {
err = NSCreateObjectFileImageFromMemory(buffer, codeSize,
&dyldObjFileImage);
if (err == NSObjectFileImageSuccess) {
TclLoadDbgMsg("NSCreateObjectFileImageFromMemory() "
"successful");
} else {
objFileImageErrMsg = DyldOFIErrorMsg(err);
TclLoadDbgMsg("NSCreateObjectFileImageFromMemory() failed: %s",
objFileImageErrMsg);
}
} else {
objFileImageErrMsg = DyldOFIErrorMsg(err);
}
}
/*
* If it went wrong (or we were asked to just deallocate), get rid of the
* memory block and create an error message.
*/
if (dyldObjFileImage == NULL) {
vm_deallocate(mach_task_self(), (vm_address_t) buffer, size);
if (objFileImageErrMsg != NULL) {
Tcl_AppendResult(interp, "NSCreateObjectFileImageFromMemory() "
"error: ", objFileImageErrMsg, NULL);
}
return TCL_ERROR;
}
/*
* Extract the module we want from the image of the object file.
*/
module = NSLinkModule(dyldObjFileImage, "[Memory Based Bundle]",
NSLINKMODULE_OPTION_BINDNOW | NSLINKMODULE_OPTION_RETURN_ON_ERROR);
NSDestroyObjectFileImage(dyldObjFileImage);
if (module) {
TclLoadDbgMsg("NSLinkModule() successful");
} else {
NSLinkEditErrors editError;
int errorNumber;
const char *errorName, *errMsg;
NSLinkEditError(&editError, &errorNumber, &errorName, &errMsg);
TclLoadDbgMsg("NSLinkModule() failed: %s", errMsg);
Tcl_AppendResult(interp, errMsg, NULL);
return TCL_ERROR;
}
/*
* Stash the module reference within the load handle we create and return.
*/
modulePtr = (Tcl_DyldModuleHandle *) ckalloc(sizeof(Tcl_DyldModuleHandle));
modulePtr->module = module;
modulePtr->nextPtr = NULL;
dyldLoadHandle = (Tcl_DyldLoadHandle *)
ckalloc(sizeof(Tcl_DyldLoadHandle));
#if TCL_DYLD_USE_DLFCN
dyldLoadHandle->dlHandle = NULL;
#endif
dyldLoadHandle->dyldLibHeader = NULL;
dyldLoadHandle->modulePtr = modulePtr;
*loadHandle = (Tcl_LoadHandle) dyldLoadHandle;
*unloadProcPtr = &TclpUnloadFile;
return TCL_OK;
}
int fat_iterator_find_fat_arch(
fat_iterator iter,
cpu_type_t cputype,
cpu_subtype_t cpusubtype,
struct fat_arch * fat_arch_out)
{
int result = 0;
uint32_t magic;
uint32_t nfat_arch;
struct fat_arch * fat_arches;
struct fat_arch * fat_arches_copy = NULL; // must free
struct fat_arch * found_arch;
magic = MAGIC32(iter->file_start);
if (iter->fat_header) {
uint32_t fat_arches_size;
uint32_t index;
nfat_arch = iter->num_arches;
fat_arches_size = nfat_arch * sizeof(struct fat_arch);
fat_arches_copy = (struct fat_arch *)(malloc(fat_arches_size));
if (!fat_arches_copy) {
goto finish;
}
fat_arches = fat_arches_copy;
memcpy(fat_arches, iter->fat_arches, fat_arches_size);
/* NXFindBestFatArch() requires all the fat info to be in host
* byte order.
*/
for (index = 0; index < nfat_arch; index++) {
fat_arches[index].cputype =
OSSwapBigToHostInt32(fat_arches[index].cputype);
fat_arches[index].cpusubtype =
OSSwapBigToHostInt32(fat_arches[index].cpusubtype);
fat_arches[index].offset =
OSSwapBigToHostInt32(fat_arches[index].offset);
fat_arches[index].size =
OSSwapBigToHostInt32(fat_arches[index].size);
fat_arches[index].align =
OSSwapBigToHostInt32(fat_arches[index].align);
}
} else {
struct fat_arch fake_fat_arches;
uint8_t swap;
struct mach_header * mach_hdr;
nfat_arch = 1;
bzero(&fake_fat_arches, sizeof(fake_fat_arches));
fat_arches = &fake_fat_arches;
swap = ISSWAPPEDMACHO(magic);
mach_hdr = (struct mach_header *)iter->file_start;
fat_arches[0].cputype = CondSwapInt32(swap, mach_hdr->cputype);
fat_arches[0].cpusubtype = CondSwapInt32(swap, mach_hdr->cpusubtype);
fat_arches[0].offset = 0;
fat_arches[0].size = iter->file_end - iter->file_start;
fat_arches[0].align = 1; // not used anyhow
}
found_arch = NXFindBestFatArch(cputype, cpusubtype, fat_arches, nfat_arch);
if (found_arch) {
result = 1;
if (fat_arch_out) {
memcpy(fat_arch_out, found_arch, sizeof(*fat_arch_out));
}
}
finish:
if (fat_arches_copy) {
free(fat_arches_copy);
}
return result;
}
