Bool ML_(read_macho_debug_info)( struct _DebugInfo* di )
{
struct symtab_command *symcmd = NULL;
struct dysymtab_command *dysymcmd = NULL;
HChar* dsymfilename = NULL;
Bool have_uuid = False;
UChar uuid[16];
ImageInfo ii; /* main file */
ImageInfo iid; /* auxiliary .dSYM file */
Bool ok;
/* mmap the object file to look for di->soname and di->text_bias
and uuid and nlist and STABS */
if (VG_(clo_verbosity) > 1)
VG_(message)(Vg_DebugMsg,
"%s (%#lx)\n", di->filename, di->rx_map_avma );
/* This should be ensured by our caller. */
vg_assert(di->have_rx_map);
vg_assert(di->have_rw_map);
VG_(memset)(&ii, 0, sizeof(ii));
VG_(memset)(&iid, 0, sizeof(iid));
VG_(memset)(&uuid, 0, sizeof(uuid));
ok = map_image_aboard( di, &ii, di->filename );
if (!ok) goto fail;
vg_assert(ii.macho_img != NULL && ii.macho_img_szB > 0);
/* Poke around in the Mach-O header, to find some important
stuff. */
// Find LC_SYMTAB and LC_DYSYMTAB, if present.
// Read di->soname from LC_ID_DYLIB if present,
// or from LC_ID_DYLINKER if present,
// or use "NONE".
// Get di->text_bias (aka slide) based on the corresponding LC_SEGMENT
// Get uuid for later dsym search
di->text_bias = 0;
{ struct MACH_HEADER *mh = (struct MACH_HEADER *)ii.macho_img;
struct load_command *cmd;
Int c;
for (c = 0, cmd = (struct load_command *)(mh+1);
c < mh->ncmds;
c++, cmd = (struct load_command *)(cmd->cmdsize
+ (unsigned long)cmd)) {
if (cmd->cmd == LC_SYMTAB) {
symcmd = (struct symtab_command *)cmd;
}
else if (cmd->cmd == LC_DYSYMTAB) {
dysymcmd = (struct dysymtab_command *)cmd;
}
else if (cmd->cmd == LC_ID_DYLIB && mh->filetype == MH_DYLIB) {
// GrP fixme bundle?
struct dylib_command *dcmd = (struct dylib_command *)cmd;
UChar *dylibname = dcmd->dylib.name.offset + (UChar *)dcmd;
UChar *soname = VG_(strrchr)(dylibname, '/');
if (!soname) soname = dylibname;
else soname++;
di->soname = ML_(dinfo_strdup)("di.readmacho.dylibname",
soname);
}
else if (cmd->cmd==LC_ID_DYLINKER && mh->filetype==MH_DYLINKER) {
struct dylinker_command *dcmd = (struct dylinker_command *)cmd;
UChar *dylinkername = dcmd->name.offset + (UChar *)dcmd;
UChar *soname = VG_(strrchr)(dylinkername, '/');
if (!soname) soname = dylinkername;
else soname++;
di->soname = ML_(dinfo_strdup)("di.readmacho.dylinkername",
soname);
}
// A comment from Julian about why varinfo[35] fail:
//
// My impression is, from comparing the output of otool -l for these
// executables with the logic in ML_(read_macho_debug_info),
// specifically the part that begins "else if (cmd->cmd ==
// LC_SEGMENT_CMD) {", that it's a complete hack which just happens
// to work ok for text symbols. In particular, it appears to assume
// that in a "struct load_command" of type LC_SEGMENT_CMD, the first
// "struct SEGMENT_COMMAND" inside it is going to contain the info we
// need. However, otool -l shows, and also the Apple docs state,
// that a struct load_command may contain an arbitrary number of
// struct SEGMENT_COMMANDs, so I'm not sure why it's OK to merely
// snarf the first. But I'm not sure about this.
//
// The "Try for __DATA" block below simply adds acquisition of data
// svma/bias values using the same assumption. It also needs
// (probably) to deal with bss sections, but I don't understand how
// this all ties together really, so it requires further study.
//
// If you can get your head around the relationship between MachO
// segments, sections and load commands, this might be relatively
// easy to fix properly.
//
// Basically we need to come up with plausible numbers for di->
// {text,data,bss}_{avma,svma}, from which the _bias numbers are
// then trivially derived. Then I think the debuginfo reader should
// work pretty well.
else if (cmd->cmd == LC_SEGMENT_CMD) {
struct SEGMENT_COMMAND *seg = (struct SEGMENT_COMMAND *)cmd;
/* Try for __TEXT */
if (!di->text_present
&& 0 == VG_(strcmp)(seg->segname, "__TEXT")
/* DDD: is the next line a kludge? -- JRS */
&& seg->fileoff == 0 && seg->filesize != 0) {
di->text_present = True;
di->text_svma = (Addr)seg->vmaddr;
di->text_avma = di->rx_map_avma;
di->text_size = seg->vmsize;
di->text_bias = di->text_avma - di->text_svma;
/* Make the _debug_ values be the same as the
svma/bias for the primary object, since there is
no secondary (debuginfo) object, but nevertheless
downstream biasing of Dwarf3 relies on the
_debug_ values. */
di->text_debug_svma = di->text_svma;
di->text_debug_bias = di->text_bias;
}
/* Try for __DATA */
if (!di->data_present
&& 0 == VG_(strcmp)(seg->segname, "__DATA")
/* && DDD:seg->fileoff == 0 */ && seg->filesize != 0) {
di->data_present = True;
di->data_svma = (Addr)seg->vmaddr;
di->data_avma = di->rw_map_avma;
di->data_size = seg->vmsize;
di->data_bias = di->data_avma - di->data_svma;
di->data_debug_svma = di->data_svma;
di->data_debug_bias = di->data_bias;
}
}
else if (cmd->cmd == LC_UUID) {
struct uuid_command *uuid_cmd = (struct uuid_command *)cmd;
VG_(memcpy)(uuid, uuid_cmd->uuid, sizeof(uuid));
have_uuid = True;
}
}
}
if (!di->soname) {
di->soname = ML_(dinfo_strdup)("di.readmacho.noname", "NONE");
}
/* Now we have the base object to hand. Read symbols from it. */
if (ii.macho_img && ii.macho_img_szB > 0 && symcmd && dysymcmd) {
/* Read nlist symbol table */
struct NLIST *syms;
UChar *strs;
XArray* /* DiSym */ candSyms = NULL;
Word i, nCandSyms;
if (ii.macho_img_szB < symcmd->stroff + symcmd->strsize
|| ii.macho_img_szB < symcmd->symoff + symcmd->nsyms
* sizeof(struct NLIST)) {
ML_(symerr)(di, False, "Invalid Mach-O file (5 too small).");
goto fail;
}
if (dysymcmd->ilocalsym + dysymcmd->nlocalsym > symcmd->nsyms
|| dysymcmd->iextdefsym + dysymcmd->nextdefsym > symcmd->nsyms) {
ML_(symerr)(di, False, "Invalid Mach-O file (bad symbol table).");
goto fail;
}
syms = (struct NLIST *)(ii.macho_img + symcmd->symoff);
strs = (UChar *)(ii.macho_img + symcmd->stroff);
if (VG_(clo_verbosity) > 1)
VG_(message)(Vg_DebugMsg,
" reading syms from primary file (%d %d)\n",
dysymcmd->nextdefsym, dysymcmd->nlocalsym );
/* Read candidate symbols into 'candSyms', so we can truncate
overlapping ends and generally tidy up, before presenting
them to ML_(addSym). */
candSyms = VG_(newXA)(
ML_(dinfo_zalloc), "di.readmacho.candsyms.1",
ML_(dinfo_free), sizeof(DiSym)
);
vg_assert(candSyms);
// extern symbols
read_symtab(candSyms,
di,
syms + dysymcmd->iextdefsym, dysymcmd->nextdefsym,
strs, symcmd->strsize);
// static and private_extern symbols
read_symtab(candSyms,
di,
syms + dysymcmd->ilocalsym, dysymcmd->nlocalsym,
strs, symcmd->strsize);
/* tidy up the cand syms -- trim overlapping ends. May resize
candSyms. */
tidy_up_cand_syms( candSyms, di->trace_symtab );
/* and finally present them to ML_(addSym) */
nCandSyms = VG_(sizeXA)( candSyms );
for (i = 0; i < nCandSyms; i++) {
DiSym* cand = (DiSym*) VG_(indexXA)( candSyms, i );
if (di->trace_symtab)
VG_(printf)("nlist final: acquire avma %010lx-%010lx %s\n",
cand->addr, cand->addr + cand->size - 1, cand->name );
ML_(addSym)( di, cand );
}
VG_(deleteXA)( candSyms );
}
/* If there's no UUID in the primary, don't even bother to try and
read any DWARF, since we won't be able to verify it matches.
Our policy is not to load debug info unless we can verify that
it matches the primary. Just declare success at this point.
And don't complain to the user, since that would cause us to
complain on objects compiled without -g. (Some versions of
XCode are observed to omit a UUID entry for object linked(?)
without -g. Others don't appear to omit it.) */
if (!have_uuid)
goto success;
/* mmap the dSYM file to look for DWARF debug info. If successful,
use the .macho_img and .macho_img_szB in iid. */
dsymfilename = find_separate_debug_file( di->filename );
/* Try to load it. */
if (dsymfilename) {
Bool valid;
if (VG_(clo_verbosity) > 1)
VG_(message)(Vg_DebugMsg, " dSYM= %s\n", dsymfilename);
ok = map_image_aboard( di, &iid, dsymfilename );
if (!ok) goto fail;
/* check it has the right uuid. */
vg_assert(have_uuid);
valid = iid.macho_img && iid.macho_img_szB > 0
&& check_uuid_matches( (Addr)iid.macho_img,
iid.macho_img_szB, uuid );
if (valid)
goto read_the_dwarf;
if (VG_(clo_verbosity) > 1)
VG_(message)(Vg_DebugMsg, " dSYM does not have "
"correct UUID (out of date?)\n");
}
/* There was no dsym file, or it doesn't match. We'll have to try
regenerating it, unless --dsymutil=no, in which case just complain
instead. */
/* If this looks like a lib that we shouldn't run dsymutil on, just
give up. (possible reasons: is system lib, or in /usr etc, or
the dsym dir would not be writable by the user, or we're running
as root) */
vg_assert(di->filename);
if (is_systemish_library_name(di->filename))
goto success;
if (!VG_(clo_dsymutil)) {
if (VG_(clo_verbosity) == 1) {
VG_(message)(Vg_DebugMsg, "%s:\n", di->filename);
}
if (VG_(clo_verbosity) > 0)
VG_(message)(Vg_DebugMsg, "%sdSYM directory %s; consider using "
"--dsymutil=yes\n",
VG_(clo_verbosity) > 1 ? " " : "",
dsymfilename ? "has wrong UUID" : "is missing");
goto success;
}
/* Run dsymutil */
{ Int r;
HChar* dsymutil = "/usr/bin/dsymutil ";
HChar* cmd = ML_(dinfo_zalloc)( "di.readmacho.tmp1",
VG_(strlen)(dsymutil)
+ VG_(strlen)(di->filename)
+ 30 /* misc */ );
VG_(strcpy)(cmd, dsymutil);
if (0) VG_(strcat)(cmd, "--verbose ");
VG_(strcat)(cmd, di->filename);
VG_(message)(Vg_DebugMsg, "run: %s\n", cmd);
r = VG_(system)( cmd );
if (r)
VG_(message)(Vg_DebugMsg, "run: %s FAILED\n", dsymutil);
ML_(dinfo_free)(cmd);
dsymfilename = find_separate_debug_file(di->filename);
}
/* Try again to load it. */
if (dsymfilename) {
Bool valid;
if (VG_(clo_verbosity) > 1)
VG_(message)(Vg_DebugMsg, " dsyms= %s\n", dsymfilename);
ok = map_image_aboard( di, &iid, dsymfilename );
if (!ok) goto fail;
/* check it has the right uuid. */
vg_assert(have_uuid);
valid = iid.macho_img && iid.macho_img_szB > 0
&& check_uuid_matches( (Addr)iid.macho_img,
iid.macho_img_szB, uuid );
if (!valid) {
if (VG_(clo_verbosity) > 0) {
VG_(message)(Vg_DebugMsg,
"WARNING: did not find expected UUID %02X%02X%02X%02X"
"-%02X%02X-%02X%02X-%02X%02X-%02X%02X%02X%02X%02X%02X"
" in dSYM dir\n",
(UInt)uuid[0], (UInt)uuid[1], (UInt)uuid[2], (UInt)uuid[3],
(UInt)uuid[4], (UInt)uuid[5], (UInt)uuid[6], (UInt)uuid[7],
(UInt)uuid[8], (UInt)uuid[9], (UInt)uuid[10],
(UInt)uuid[11], (UInt)uuid[12], (UInt)uuid[13],
(UInt)uuid[14], (UInt)uuid[15] );
VG_(message)(Vg_DebugMsg,
"WARNING: for %s\n", di->filename);
}
unmap_image( &iid );
/* unmap_image zeroes the fields, so the following test makes
sense. */
goto fail;
}
}
/* Right. Finally we have our best try at the dwarf image, so go
on to reading stuff out of it. */
read_the_dwarf:
if (iid.macho_img && iid.macho_img_szB > 0) {
UChar* debug_info_img = NULL;
Word debug_info_sz;
UChar* debug_abbv_img;
Word debug_abbv_sz;
UChar* debug_line_img;
Word debug_line_sz;
UChar* debug_str_img;
Word debug_str_sz;
UChar* debug_ranges_img;
Word debug_ranges_sz;
UChar* debug_loc_img;
Word debug_loc_sz;
UChar* debug_name_img;
Word debug_name_sz;
debug_info_img =
getsectdata(iid.macho_img, iid.macho_img_szB,
"__DWARF", "__debug_info", &debug_info_sz);
debug_abbv_img =
getsectdata(iid.macho_img, iid.macho_img_szB,
"__DWARF", "__debug_abbrev", &debug_abbv_sz);
debug_line_img =
getsectdata(iid.macho_img, iid.macho_img_szB,
"__DWARF", "__debug_line", &debug_line_sz);
debug_str_img =
getsectdata(iid.macho_img, iid.macho_img_szB,
"__DWARF", "__debug_str", &debug_str_sz);
debug_ranges_img =
getsectdata(iid.macho_img, iid.macho_img_szB,
"__DWARF", "__debug_ranges", &debug_ranges_sz);
debug_loc_img =
getsectdata(iid.macho_img, iid.macho_img_szB,
"__DWARF", "__debug_loc", &debug_loc_sz);
debug_name_img =
getsectdata(iid.macho_img, iid.macho_img_szB,
"__DWARF", "__debug_pubnames", &debug_name_sz);
if (debug_info_img) {
if (VG_(clo_verbosity) > 1) {
if (0)
VG_(message)(Vg_DebugMsg,
"Reading dwarf3 for %s (%#lx) from %s"
" (%ld %ld %ld %ld %ld %ld)\n",
di->filename, di->text_avma, dsymfilename,
debug_info_sz, debug_abbv_sz, debug_line_sz,
debug_str_sz, debug_ranges_sz, debug_loc_sz
);
VG_(message)(Vg_DebugMsg,
" reading dwarf3 from dsyms file\n");
}
/* The old reader: line numbers and unwind info only */
ML_(read_debuginfo_dwarf3) ( di,
debug_info_img, debug_info_sz,
debug_abbv_img, debug_abbv_sz,
debug_line_img, debug_line_sz,
debug_str_img, debug_str_sz );
/* The new reader: read the DIEs in .debug_info to acquire
information on variable types and locations. But only if
the tool asks for it, or the user requests it on the
command line. */
if (VG_(needs).var_info /* the tool requires it */
|| VG_(clo_read_var_info) /* the user asked for it */) {
ML_(new_dwarf3_reader)(
di, debug_info_img, debug_info_sz,
debug_abbv_img, debug_abbv_sz,
debug_line_img, debug_line_sz,
debug_str_img, debug_str_sz,
debug_ranges_img, debug_ranges_sz,
debug_loc_img, debug_loc_sz
);
}
}
}
if (dsymfilename) ML_(dinfo_free)(dsymfilename);
success:
if (ii.img)
unmap_image(&ii);
if (iid.img)
unmap_image(&iid);
return True;
/* NOTREACHED */
fail:
ML_(symerr)(di, True, "Error reading Mach-O object.");
if (ii.img)
unmap_image(&ii);
if (iid.img)
unmap_image(&iid);
return False;
}
status_t
load_image(char const* name, image_type type, const char* rpath,
const char* requestingObjectPath, image_t** _image)
{
int32 pheaderSize, sheaderSize;
char path[PATH_MAX];
ssize_t length;
char pheaderBuffer[4096];
int32 numRegions;
image_t* found;
image_t* image;
status_t status;
int fd;
elf_ehdr eheader;
// Have we already loaded that image? Don't check for add-ons -- we always
// reload them.
if (type != B_ADD_ON_IMAGE) {
found = find_loaded_image_by_name(name, APP_OR_LIBRARY_TYPE);
if (found == NULL && type != B_APP_IMAGE && gProgramImage != NULL) {
// Special case for add-ons that link against the application
// executable, with the executable not having a soname set.
if (const char* lastSlash = strrchr(name, '/')) {
if (strcmp(gProgramImage->name, lastSlash + 1) == 0)
found = gProgramImage;
}
}
if (found) {
atomic_add(&found->ref_count, 1);
*_image = found;
KTRACE("rld: load_container(\"%s\", type: %d, rpath: \"%s\") "
"already loaded", name, type, rpath);
return B_OK;
}
}
KTRACE("rld: load_container(\"%s\", type: %d, rpath: \"%s\")", name, type,
rpath);
strlcpy(path, name, sizeof(path));
// find and open the file
fd = open_executable(path, type, rpath, get_program_path(),
requestingObjectPath, sSearchPathSubDir);
if (fd < 0) {
FATAL("Cannot open file %s: %s\n", name, strerror(fd));
KTRACE("rld: load_container(\"%s\"): failed to open file", name);
return fd;
}
// normalize the image path
status = _kern_normalize_path(path, true, path);
if (status != B_OK)
goto err1;
// Test again if this image has been registered already - this time,
// we can check the full path, not just its name as noted.
// You could end up loading an image twice with symbolic links, else.
if (type != B_ADD_ON_IMAGE) {
found = find_loaded_image_by_name(path, APP_OR_LIBRARY_TYPE);
if (found) {
atomic_add(&found->ref_count, 1);
*_image = found;
_kern_close(fd);
KTRACE("rld: load_container(\"%s\"): already loaded after all",
name);
return B_OK;
}
}
length = _kern_read(fd, 0, &eheader, sizeof(eheader));
if (length != sizeof(eheader)) {
status = B_NOT_AN_EXECUTABLE;
FATAL("%s: Troubles reading ELF header\n", path);
goto err1;
}
status = parse_elf_header(&eheader, &pheaderSize, &sheaderSize);
if (status < B_OK) {
FATAL("%s: Incorrect ELF header\n", path);
goto err1;
}
// ToDo: what to do about this restriction??
if (pheaderSize > (int)sizeof(pheaderBuffer)) {
FATAL("%s: Cannot handle program headers bigger than %lu\n",
path, sizeof(pheaderBuffer));
status = B_UNSUPPORTED;
goto err1;
}
length = _kern_read(fd, eheader.e_phoff, pheaderBuffer, pheaderSize);
if (length != pheaderSize) {
FATAL("%s: Could not read program headers: %s\n", path,
strerror(length));
status = B_BAD_DATA;
goto err1;
}
numRegions = count_regions(path, pheaderBuffer, eheader.e_phnum,
eheader.e_phentsize);
if (numRegions <= 0) {
FATAL("%s: Troubles parsing Program headers, numRegions = %" B_PRId32
"\n", path, numRegions);
status = B_BAD_DATA;
goto err1;
}
image = create_image(name, path, numRegions);
if (image == NULL) {
FATAL("%s: Failed to allocate image_t object\n", path);
status = B_NO_MEMORY;
goto err1;
}
status = parse_program_headers(image, pheaderBuffer, eheader.e_phnum,
eheader.e_phentsize);
if (status < B_OK)
goto err2;
if (!assert_dynamic_loadable(image)) {
FATAL("%s: Dynamic segment must be loadable (implementation "
"restriction)\n", image->path);
status = B_UNSUPPORTED;
goto err2;
}
status = map_image(fd, path, image, eheader.e_type == ET_EXEC);
if (status < B_OK) {
FATAL("%s: Could not map image: %s\n", image->path, strerror(status));
status = B_ERROR;
goto err2;
}
if (!parse_dynamic_segment(image)) {
FATAL("%s: Troubles handling dynamic section\n", image->path);
status = B_BAD_DATA;
goto err3;
}
if (eheader.e_entry != 0)
image->entry_point = eheader.e_entry + image->regions[0].delta;
analyze_image_haiku_version_and_abi(fd, image, eheader, sheaderSize,
pheaderBuffer, sizeof(pheaderBuffer));
// If this is the executable image, we init the search path
// subdir, if the compiler version doesn't match ours.
if (type == B_APP_IMAGE) {
#if __GNUC__ == 2
if ((image->abi & B_HAIKU_ABI_MAJOR) == B_HAIKU_ABI_GCC_4)
sSearchPathSubDir = "x86";
#elif __GNUC__ >= 4
if ((image->abi & B_HAIKU_ABI_MAJOR) == B_HAIKU_ABI_GCC_2)
sSearchPathSubDir = "x86_gcc2";
#endif
}
set_abi_version(image->abi);
// init gcc version dependent image flags
// symbol resolution strategy
if (image->abi == B_HAIKU_ABI_GCC_2_ANCIENT)
image->find_undefined_symbol = find_undefined_symbol_beos;
// init version infos
status = init_image_version_infos(image);
image->type = type;
register_image(image, fd, path);
image_event(image, IMAGE_EVENT_LOADED);
_kern_close(fd);
enqueue_loaded_image(image);
*_image = image;
KTRACE("rld: load_container(\"%s\"): done: id: %" B_PRId32 " (ABI: %#"
B_PRIx32 ")", name, image->id, image->abi);
return B_OK;
err3:
unmap_image(image);
err2:
delete_image_struct(image);
err1:
_kern_close(fd);
KTRACE("rld: load_container(\"%s\"): failed: %s", name,
strerror(status));
return status;
}
/* Map a given fat or thin object aboard, find the thin part if
necessary, do some checks, and write details of both the fat and
thin parts into *ii. Returns False (and leaves the file unmapped)
on failure. Guarantees to return pointers to a valid(ish) Mach-O
image if it succeeds. */
static Bool map_image_aboard ( DebugInfo* di, /* only for err msgs */
/*OUT*/ImageInfo* ii, UChar* filename )
{
VG_(memset)(ii, 0, sizeof(*ii));
/* First off, try to map the thing in. */
{ SizeT size;
SysRes fd, sres;
struct vg_stat stat_buf;
fd = VG_(stat)(filename, &stat_buf);
if (sr_isError(fd)) {
ML_(symerr)(di, True, "Can't stat image (to determine its size)?!");
return False;
}
size = stat_buf.size;
fd = VG_(open)(filename, VKI_O_RDONLY, 0);
if (sr_isError(fd)) {
ML_(symerr)(di, True, "Can't open image to read symbols?!");
return False;
}
sres = VG_(am_mmap_file_float_valgrind)
( size, VKI_PROT_READ, sr_Res(fd), 0 );
if (sr_isError(sres)) {
ML_(symerr)(di, True, "Can't mmap image to read symbols?!");
return False;
}
VG_(close)(sr_Res(fd));
ii->img = (UChar*)sr_Res(sres);
ii->img_szB = size;
}
/* Now it's mapped in and we have .img and .img_szB set. Look for
the embedded Mach-O object. If not findable, unmap and fail. */
{ struct fat_header* fh_be;
struct fat_header fh;
struct MACH_HEADER* mh;
// Assume initially that we have a thin image, and update
// these if it turns out to be fat.
ii->macho_img = ii->img;
ii->macho_img_szB = ii->img_szB;
// Check for fat header.
if (ii->img_szB < sizeof(struct fat_header)) {
ML_(symerr)(di, True, "Invalid Mach-O file (0 too small).");
goto unmap_and_fail;
}
// Fat header is always BIG-ENDIAN
fh_be = (struct fat_header *)ii->img;
fh.magic = VG_(ntohl)(fh_be->magic);
fh.nfat_arch = VG_(ntohl)(fh_be->nfat_arch);
if (fh.magic == FAT_MAGIC) {
// Look for a good architecture.
struct fat_arch *arch_be;
struct fat_arch arch;
Int f;
if (ii->img_szB < sizeof(struct fat_header)
+ fh.nfat_arch * sizeof(struct fat_arch)) {
ML_(symerr)(di, True, "Invalid Mach-O file (1 too small).");
goto unmap_and_fail;
}
for (f = 0, arch_be = (struct fat_arch *)(fh_be+1);
f < fh.nfat_arch;
f++, arch_be++) {
Int cputype;
# if defined(VGA_ppc)
cputype = CPU_TYPE_POWERPC;
# elif defined(VGA_ppc64)
cputype = CPU_TYPE_POWERPC64;
# elif defined(VGA_x86)
cputype = CPU_TYPE_X86;
# elif defined(VGA_amd64)
cputype = CPU_TYPE_X86_64;
# else
# error "unknown architecture"
# endif
arch.cputype = VG_(ntohl)(arch_be->cputype);
arch.cpusubtype = VG_(ntohl)(arch_be->cpusubtype);
arch.offset = VG_(ntohl)(arch_be->offset);
arch.size = VG_(ntohl)(arch_be->size);
if (arch.cputype == cputype) {
if (ii->img_szB < arch.offset + arch.size) {
ML_(symerr)(di, True, "Invalid Mach-O file (2 too small).");
goto unmap_and_fail;
}
ii->macho_img = ii->img + arch.offset;
ii->macho_img_szB = arch.size;
break;
}
}
if (f == fh.nfat_arch) {
ML_(symerr)(di, True,
"No acceptable architecture found in fat file.");
goto unmap_and_fail;
}
}
/* Sanity check what we found. */
/* assured by logic above */
vg_assert(ii->img_szB >= sizeof(struct fat_header));
if (ii->macho_img_szB < sizeof(struct MACH_HEADER)) {
ML_(symerr)(di, True, "Invalid Mach-O file (3 too small).");
goto unmap_and_fail;
}
if (ii->macho_img_szB > ii->img_szB) {
ML_(symerr)(di, True, "Invalid Mach-O file (thin bigger than fat).");
goto unmap_and_fail;
}
if (ii->macho_img >= ii->img
&& ii->macho_img + ii->macho_img_szB <= ii->img + ii->img_szB) {
/* thin entirely within fat, as expected */
} else {
ML_(symerr)(di, True, "Invalid Mach-O file (thin not inside fat).");
goto unmap_and_fail;
}
mh = (struct MACH_HEADER *)ii->macho_img;
if (mh->magic != MAGIC) {
ML_(symerr)(di, True, "Invalid Mach-O file (bad magic).");
goto unmap_and_fail;
}
if (ii->macho_img_szB < sizeof(struct MACH_HEADER) + mh->sizeofcmds) {
ML_(symerr)(di, True, "Invalid Mach-O file (4 too small).");
goto unmap_and_fail;
}
}
vg_assert(ii->img);
vg_assert(ii->macho_img);
vg_assert(ii->img_szB > 0);
vg_assert(ii->macho_img_szB > 0);
vg_assert(ii->macho_img >= ii->img);
vg_assert(ii->macho_img + ii->macho_img_szB <= ii->img + ii->img_szB);
return True; /* success */
/*NOTREACHED*/
unmap_and_fail:
unmap_image(ii);
return False; /* bah! */
}
status_t
unload_library(void* handle, image_id imageID, bool addOn)
{
image_t *image;
image_type type = addOn ? B_ADD_ON_IMAGE : B_LIBRARY_IMAGE;
if (handle == NULL && imageID < 0)
return B_BAD_IMAGE_ID;
if (handle == RLD_GLOBAL_SCOPE)
return B_OK;
rld_lock();
// for now, just do stupid simple global locking
if (gInvalidImageIDs) {
// After fork, we lazily rebuild the image IDs of all loaded images
update_image_ids();
}
// we only check images that have been already initialized
status_t status = B_BAD_IMAGE_ID;
if (handle != NULL) {
image = (image_t*)handle;
put_image(image);
status = B_OK;
} else {
image = find_loaded_image_by_id(imageID, true);
if (image != NULL) {
// unload image
if (type == image->type) {
put_image(image);
status = B_OK;
} else
status = B_BAD_VALUE;
}
}
if (status == B_OK) {
while ((image = get_disposable_images().head) != NULL) {
// Call the exit hooks that live in this image.
// Note: With the Itanium ABI this shouldn't really be done this
// way anymore, since global destructors are registered via
// __cxa_atexit() (the ones that are registered dynamically) and the
// termination routine should call __cxa_finalize() for the image.
// The reason why we still do it is that hooks registered with
// atexit() aren't associated with the image. We could find out
// there which image the hooks lives in and register it
// respectively, but since that would be done always, that's
// probably more expensive than calling
// call_atexit_hooks_for_range() only here, which happens only when
// libraries are unloaded dynamically.
if (gRuntimeLoader.call_atexit_hooks_for_range) {
gRuntimeLoader.call_atexit_hooks_for_range(
image->regions[0].vmstart, image->regions[0].vmsize);
}
image_event(image, IMAGE_EVENT_UNINITIALIZING);
if (image->term_routine)
((init_term_function)image->term_routine)(image->id);
dequeue_disposable_image(image);
unmap_image(image);
image_event(image, IMAGE_EVENT_UNLOADING);
delete_image(image);
}
}
rld_unlock();
return status;
}
