aboutsummaryrefslogtreecommitdiff
path: root/src/client/mac/handler
diff options
context:
space:
mode:
Diffstat (limited to 'src/client/mac/handler')
-rw-r--r--src/client/mac/handler/breakpad_nlist_64.cc411
-rw-r--r--src/client/mac/handler/breakpad_nlist_64.h14
-rw-r--r--src/client/mac/handler/dynamic_images.cc502
-rw-r--r--src/client/mac/handler/dynamic_images.h196
-rw-r--r--src/client/mac/handler/minidump_generator.cc346
-rw-r--r--src/client/mac/handler/minidump_generator.h50
6 files changed, 899 insertions, 620 deletions
diff --git a/src/client/mac/handler/breakpad_nlist_64.cc b/src/client/mac/handler/breakpad_nlist_64.cc
index 4b655c79..709e8546 100644
--- a/src/client/mac/handler/breakpad_nlist_64.cc
+++ b/src/client/mac/handler/breakpad_nlist_64.cc
@@ -54,7 +54,7 @@
*/
-/* nealsid:
+/*
* This file was copied from libc/gen/nlist.c from Darwin's source code
* The version of nlist used as a base is from 10.5.2, libc-498
* http://www.opensource.apple.com/darwinsource/10.5.2/Libc-498/gen/nlist.c
@@ -62,24 +62,22 @@
* The full tarball is at:
* http://www.opensource.apple.com/darwinsource/tarballs/apsl/Libc-498.tar.gz
*
- * I've modified it to be compatible with 64-bit images. However,
- * 32-bit compatibility has not been retained.
+ * I've modified it to be compatible with 64-bit images.
*/
-#ifdef __LP64__
+#include "breakpad_nlist_64.h"
+#include <fcntl.h>
#include <mach-o/nlist.h>
#include <mach-o/loader.h>
#include <mach-o/fat.h>
+#include <mach/mach.h>
+#include <stdio.h>
#include <stdlib.h>
-#include <fcntl.h>
#include <sys/types.h>
#include <sys/uio.h>
-#include <unistd.h>
-#include "breakpad_nlist_64.h"
#include <TargetConditionals.h>
-#include <stdio.h>
-#include <mach/mach.h>
+#include <unistd.h>
/* Stuff lifted from <a.out.h> and <sys/exec.h> since they are gone */
/*
@@ -108,44 +106,77 @@ struct exec {
#define N_SYMOFF(x) \
(N_TXTOFF(x) + (x).a_text+(x).a_data + (x).a_trsize+(x).a_drsize)
+// Traits structs for specializing function templates to handle
+// 32-bit/64-bit Mach-O files.
+template<typename T>
+struct MachBits {};
+
+typedef struct nlist nlist32;
+typedef struct nlist_64 nlist64;
+
+template<>
+struct MachBits<nlist32> {
+ typedef mach_header mach_header_type;
+ typedef uint32_t word_type;
+ static const uint32_t magic = MH_MAGIC;
+};
+
+template<>
+struct MachBits<nlist64> {
+ typedef mach_header_64 mach_header_type;
+ typedef uint64_t word_type;
+ static const uint32_t magic = MH_MAGIC_64;
+};
+
+template<typename nlist_type>
int
-__breakpad_fdnlist_64(int fd, breakpad_nlist *list, const char **symbolNames);
+__breakpad_fdnlist(int fd, nlist_type *list, const char **symbolNames,
+ cpu_type_t cpu_type);
/*
* nlist - retreive attributes from name list (string table version)
*/
-int
-breakpad_nlist_64(const char *name,
- breakpad_nlist *list,
- const char **symbolNames) {
- int fd, n;
-
- fd = open(name, O_RDONLY, 0);
+template <typename nlist_type>
+int breakpad_nlist_common(const char *name,
+ nlist_type *list,
+ const char **symbolNames,
+ cpu_type_t cpu_type) {
+ int fd = open(name, O_RDONLY, 0);
if (fd < 0)
- return (-1);
- n = __breakpad_fdnlist_64(fd, list, symbolNames);
- (void)close(fd);
- return (n);
+ return -1;
+ int n = __breakpad_fdnlist(fd, list, symbolNames, cpu_type);
+ close(fd);
+ return n;
+}
+
+int breakpad_nlist(const char *name,
+ struct nlist *list,
+ const char **symbolNames,
+ cpu_type_t cpu_type) {
+ return breakpad_nlist_common(name, list, symbolNames, cpu_type);
+}
+
+int breakpad_nlist(const char *name,
+ struct nlist_64 *list,
+ const char **symbolNames,
+ cpu_type_t cpu_type) {
+ return breakpad_nlist_common(name, list, symbolNames, cpu_type);
}
/* Note: __fdnlist() is called from kvm_nlist in libkvm's kvm.c */
-int
-__breakpad_fdnlist_64(int fd, breakpad_nlist *list, const char **symbolNames) {
- register breakpad_nlist *p, *q;
- breakpad_nlist space[BUFSIZ/sizeof (breakpad_nlist)];
-
- const register char *s1, *s2;
- register register_t n, m;
- int maxlen, nreq;
- off_t sa; /* symbol address */
- off_t ss; /* start of strings */
- struct exec buf;
- unsigned arch_offset = 0;
+template<typename nlist_type>
+int __breakpad_fdnlist(int fd, nlist_type *list, const char **symbolNames,
+ cpu_type_t cpu_type) {
+ typedef typename MachBits<nlist_type>::mach_header_type mach_header_type;
+ typedef typename MachBits<nlist_type>::word_type word_type;
- maxlen = 500;
- for (q = list, nreq = 0;
+ const uint32_t magic = MachBits<nlist_type>::magic;
+
+ int maxlen = 500;
+ int nreq = 0;
+ for (nlist_type* q = list;
symbolNames[q-list] && symbolNames[q-list][0];
q++, nreq++) {
@@ -156,61 +187,61 @@ __breakpad_fdnlist_64(int fd, breakpad_nlist *list, const char **symbolNames) {
q->n_un.n_strx = 0;
}
+ struct exec buf;
if (read(fd, (char *)&buf, sizeof(buf)) != sizeof(buf) ||
- (N_BADMAG(buf) && *((long *)&buf) != MH_MAGIC &&
+ (N_BADMAG(buf) && *((long *)&buf) != magic &&
NXSwapBigLongToHost(*((long *)&buf)) != FAT_MAGIC) &&
- /* nealsid: The following is the big-endian ppc64 check */
+ /* The following is the big-endian ppc64 check */
(*((long*)&buf)) != FAT_MAGIC) {
- return (-1);
+ return -1;
}
/* Deal with fat file if necessary */
+ unsigned arch_offset = 0;
if (NXSwapBigLongToHost(*((long *)&buf)) == FAT_MAGIC ||
- /* nealsid: The following is the big-endian ppc64 check */
+ /* The following is the big-endian ppc64 check */
*((unsigned int *)&buf) == FAT_MAGIC) {
+ /* Get host info */
+ host_t host = mach_host_self();
+ unsigned i = HOST_BASIC_INFO_COUNT;
struct host_basic_info hbi;
- struct fat_header fh;
- struct fat_arch *fat_archs, *fap;
- unsigned i;
- host_t host;
-
- /* Get our host info */
- host = mach_host_self();
- i = HOST_BASIC_INFO_COUNT;
kern_return_t kr;
- if ((kr=host_info(host, HOST_BASIC_INFO,
- (host_info_t)(&hbi), &i)) != KERN_SUCCESS) {
- return (-1);
+ if ((kr = host_info(host, HOST_BASIC_INFO,
+ (host_info_t)(&hbi), &i)) != KERN_SUCCESS) {
+ return -1;
}
mach_port_deallocate(mach_task_self(), host);
/* Read in the fat header */
- lseek(fd, 0, SEEK_SET);
+ struct fat_header fh;
+ if (lseek(fd, 0, SEEK_SET) == -1) {
+ return -1;
+ }
if (read(fd, (char *)&fh, sizeof(fh)) != sizeof(fh)) {
- return (-1);
+ return -1;
}
/* Convert fat_narchs to host byte order */
fh.nfat_arch = NXSwapBigIntToHost(fh.nfat_arch);
/* Read in the fat archs */
- fat_archs = (struct fat_arch *)malloc(fh.nfat_arch *
- sizeof(struct fat_arch));
+ struct fat_arch *fat_archs =
+ (struct fat_arch *)malloc(fh.nfat_arch * sizeof(struct fat_arch));
if (fat_archs == NULL) {
- return (-1);
+ return -1;
}
if (read(fd, (char *)fat_archs,
sizeof(struct fat_arch) * fh.nfat_arch) !=
(ssize_t)sizeof(struct fat_arch) * fh.nfat_arch) {
free(fat_archs);
- return (-1);
+ return -1;
}
/*
* Convert archs to host byte ordering (a constraint of
* cpusubtype_getbestarch()
*/
- for (i = 0; i < fh.nfat_arch; i++) {
+ for (unsigned i = 0; i < fh.nfat_arch; i++) {
fat_archs[i].cputype =
NXSwapBigIntToHost(fat_archs[i].cputype);
fat_archs[i].cpusubtype =
@@ -223,159 +254,159 @@ __breakpad_fdnlist_64(int fd, breakpad_nlist *list, const char **symbolNames) {
NXSwapBigIntToHost(fat_archs[i].align);
}
- fap = NULL;
- for (i = 0; i < fh.nfat_arch; i++) {
- /* nealsid: Although the original Apple code uses host_info */
- /* to retrieve the CPU type, the host_info will still return */
- /* CPU_TYPE_X86 even if running as an x86_64 binary. Given that */
- /* this code isn't necessary on i386, I've decided to hardcode */
- /* looking for a 64-bit binary */
-#if TARGET_CPU_X86_64
- if (fat_archs[i].cputype == CPU_TYPE_X86_64) {
-#elif TARGET_CPU_PPC64
- if (fat_archs[i].cputype == CPU_TYPE_POWERPC64) {
-#else
-#error undefined cpu!
- {
-#endif
- fap = &fat_archs[i];
- break;
- }
+ struct fat_arch *fap = NULL;
+ for (unsigned i = 0; i < fh.nfat_arch; i++) {
+ if (fat_archs[i].cputype == cpu_type) {
+ fap = &fat_archs[i];
+ break;
}
+ }
- if (!fap) {
- free(fat_archs);
- return (-1);
- }
- arch_offset = fap->offset;
+ if (!fap) {
free(fat_archs);
+ return -1;
+ }
+ arch_offset = fap->offset;
+ free(fat_archs);
- /* Read in the beginning of the architecture-specific file */
- lseek(fd, arch_offset, SEEK_SET);
- if (read(fd, (char *)&buf, sizeof(buf)) != sizeof(buf)) {
- return (-1);
- }
+ /* Read in the beginning of the architecture-specific file */
+ if (lseek(fd, arch_offset, SEEK_SET) == -1) {
+ return -1;
}
+ if (read(fd, (char *)&buf, sizeof(buf)) != sizeof(buf)) {
+ return -1;
+ }
+ }
- if (*((unsigned int *)&buf) == MH_MAGIC_64) {
- struct mach_header_64 mh;
- struct load_command *load_commands, *lcp;
- struct symtab_command *stp;
- long i;
+ off_t sa; /* symbol address */
+ off_t ss; /* start of strings */
+ register register_t n;
+ if (*((unsigned int *)&buf) == magic) {
+ if (lseek(fd, arch_offset, SEEK_SET) == -1) {
+ return -1;
+ }
+ mach_header_type mh;
+ if (read(fd, (char *)&mh, sizeof(mh)) != sizeof(mh)) {
+ return -1;
+ }
- lseek(fd, arch_offset, SEEK_SET);
- if (read(fd, (char *)&mh, sizeof(mh)) != sizeof(mh)) {
- return (-1);
- }
- load_commands = (struct load_command *)malloc(mh.sizeofcmds);
- if (load_commands == NULL) {
- return (-1);
- }
- if (read(fd, (char *)load_commands, mh.sizeofcmds) !=
- mh.sizeofcmds) {
+ struct load_command *load_commands =
+ (struct load_command *)malloc(mh.sizeofcmds);
+ if (load_commands == NULL) {
+ return -1;
+ }
+ if (read(fd, (char *)load_commands, mh.sizeofcmds) !=
+ mh.sizeofcmds) {
+ free(load_commands);
+ return -1;
+ }
+ struct symtab_command *stp = NULL;
+ struct load_command *lcp = load_commands;
+ // iterate through all load commands, looking for
+ // LC_SYMTAB load command
+ for (long i = 0; i < mh.ncmds; i++) {
+ if (lcp->cmdsize % sizeof(word_type) != 0 ||
+ lcp->cmdsize <= 0 ||
+ (char *)lcp + lcp->cmdsize >
+ (char *)load_commands + mh.sizeofcmds) {
free(load_commands);
- return (-1);
+ return -1;
}
- stp = NULL;
- lcp = load_commands;
- // nealsid:iterate through all load commands, looking for
- // LC_SYMTAB load command
- for (i = 0; i < mh.ncmds; i++) {
- if (lcp->cmdsize % sizeof(long) != 0 ||
- lcp->cmdsize <= 0 ||
- (char *)lcp + lcp->cmdsize >
- (char *)load_commands + mh.sizeofcmds) {
+ if (lcp->cmd == LC_SYMTAB) {
+ if (lcp->cmdsize !=
+ sizeof(struct symtab_command)) {
free(load_commands);
- return (-1);
- }
- if (lcp->cmd == LC_SYMTAB) {
- if (lcp->cmdsize !=
- sizeof(struct symtab_command)) {
- free(load_commands);
- return (-1);
- }
- stp = (struct symtab_command *)lcp;
- break;
+ return -1;
}
- lcp = (struct load_command *)
- ((char *)lcp + lcp->cmdsize);
- }
- if (stp == NULL) {
- free(load_commands);
- return (-1);
+ stp = (struct symtab_command *)lcp;
+ break;
}
- // sa points to the beginning of the symbol table
- sa = stp->symoff + arch_offset;
- // ss points to the beginning of the string table
- ss = stp->stroff + arch_offset;
- // n is the number of bytes in the symbol table
- // each symbol table entry is an nlist structure
- n = stp->nsyms * sizeof(breakpad_nlist);
- free(load_commands);
+ lcp = (struct load_command *)
+ ((char *)lcp + lcp->cmdsize);
}
- else {
- sa = N_SYMOFF(buf) + arch_offset;
- ss = sa + buf.a_syms + arch_offset;
- n = buf.a_syms;
+ if (stp == NULL) {
+ free(load_commands);
+ return -1;
}
+ // sa points to the beginning of the symbol table
+ sa = stp->symoff + arch_offset;
+ // ss points to the beginning of the string table
+ ss = stp->stroff + arch_offset;
+ // n is the number of bytes in the symbol table
+ // each symbol table entry is an nlist structure
+ n = stp->nsyms * sizeof(nlist_type);
+ free(load_commands);
+ } else {
+ sa = N_SYMOFF(buf) + arch_offset;
+ ss = sa + buf.a_syms + arch_offset;
+ n = buf.a_syms;
+ }
- lseek(fd, sa, SEEK_SET);
+ if (lseek(fd, sa, SEEK_SET) == -1) {
+ return -1;
+ }
+
+ // the algorithm here is to read the nlist entries in m-sized
+ // chunks into q. q is then iterated over. for each entry in q,
+ // use the string table index(q->n_un.n_strx) to read the symbol
+ // name, then scan the nlist entries passed in by the user(via p),
+ // and look for a match
+ while (n) {
+ nlist_type space[BUFSIZ/sizeof (nlist_type)];
+ register register_t m = sizeof (space);
+
+ if (n < m)
+ m = n;
+ if (read(fd, (char *)space, m) != m)
+ break;
+ n -= m;
+ long savpos = lseek(fd, 0, SEEK_CUR);
+ if (savpos == -1) {
+ return -1;
+ }
+ for (nlist_type* q = space; (m -= sizeof(nlist_type)) >= 0; q++) {
+ char nambuf[BUFSIZ];
- // the algorithm here is to read the nlist entries in m-sized
- // chunks into q. q is then iterated over. for each entry in q,
- // use the string table index(q->n_un.n_strx) to read the symbol
- // name, then scan the nlist entries passed in by the user(via p),
- // and look for a match
- while (n) {
- long savpos;
+ if (q->n_un.n_strx == 0 || q->n_type & N_STAB)
+ continue;
- m = sizeof (space);
- if (n < m)
- m = n;
- if (read(fd, (char *)space, m) != m)
- break;
- n -= m;
- savpos = lseek(fd, 0, SEEK_CUR);
- for (q = space; (m -= sizeof(breakpad_nlist)) >= 0; q++) {
- char nambuf[BUFSIZ];
-
- if (q->n_un.n_strx == 0 || q->n_type & N_STAB)
- continue;
-
- // seek to the location in the binary where the symbol
- // name is stored & read it into memory
- lseek(fd, ss+q->n_un.n_strx, SEEK_SET);
- read(fd, nambuf, maxlen+1);
- s2 = nambuf;
- for (p = list;
- symbolNames[p-list] &&
- symbolNames[p-list][0];
- p++) {
- // get the symbol name the user has passed in that
- // corresponds to the nlist entry that we're looking at
- s1 = symbolNames[p - list];
- while (*s1) {
- if (*s1++ != *s2++)
- goto cont;
- }
- if (*s2)
+ // seek to the location in the binary where the symbol
+ // name is stored & read it into memory
+ if (lseek(fd, ss+q->n_un.n_strx, SEEK_SET) == -1) {
+ return -1;
+ }
+ if (read(fd, nambuf, maxlen+1) == -1) {
+ return -1;
+ }
+ const char *s2 = nambuf;
+ for (nlist_type *p = list;
+ symbolNames[p-list] && symbolNames[p-list][0];
+ p++) {
+ // get the symbol name the user has passed in that
+ // corresponds to the nlist entry that we're looking at
+ const char *s1 = symbolNames[p - list];
+ while (*s1) {
+ if (*s1++ != *s2++)
goto cont;
+ }
+ if (*s2)
+ goto cont;
- p->n_value = q->n_value;
- p->n_type = q->n_type;
- p->n_desc = q->n_desc;
- p->n_sect = q->n_sect;
- p->n_un.n_strx = q->n_un.n_strx;
- if (--nreq == 0)
- return (nreq);
+ p->n_value = q->n_value;
+ p->n_type = q->n_type;
+ p->n_desc = q->n_desc;
+ p->n_sect = q->n_sect;
+ p->n_un.n_strx = q->n_un.n_strx;
+ if (--nreq == 0)
+ return nreq;
- break;
- cont: ;
- }
+ break;
+ cont: ;
}
- lseek(fd, savpos, SEEK_SET);
}
- return (nreq);
+ if (lseek(fd, savpos, SEEK_SET) == -1) {
+ return -1;
+ }
}
-
-#endif /* __LP64__ */
+ return nreq;
+}
diff --git a/src/client/mac/handler/breakpad_nlist_64.h b/src/client/mac/handler/breakpad_nlist_64.h
index ee10afb9..1d2c6391 100644
--- a/src/client/mac/handler/breakpad_nlist_64.h
+++ b/src/client/mac/handler/breakpad_nlist_64.h
@@ -33,11 +33,15 @@
#ifndef CLIENT_MAC_HANDLER_BREAKPAD_NLIST_H__
-typedef struct nlist_64 breakpad_nlist;
+#include <mach/machine.h>
-int
-breakpad_nlist_64(const char *name,
- breakpad_nlist *list,
- const char **symbolNames);
+int breakpad_nlist(const char *name,
+ struct nlist *list,
+ const char **symbolNames,
+ cpu_type_t cpu_type);
+int breakpad_nlist(const char *name,
+ struct nlist_64 *list,
+ const char **symbolNames,
+ cpu_type_t cpu_type);
#endif /* CLIENT_MAC_HANDLER_BREAKPAD_NLIST_H__ */
diff --git a/src/client/mac/handler/dynamic_images.cc b/src/client/mac/handler/dynamic_images.cc
index 1d5f1f9b..035afe7e 100644
--- a/src/client/mac/handler/dynamic_images.cc
+++ b/src/client/mac/handler/dynamic_images.cc
@@ -27,6 +27,8 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include "client/mac/handler/dynamic_images.h"
+
extern "C" { // needed to compile on Leopard
#include <mach-o/nlist.h>
#include <stdlib.h>
@@ -37,11 +39,17 @@ extern "C" { // needed to compile on Leopard
#include <assert.h>
#include <dlfcn.h>
#include <mach/mach_vm.h>
+#include <sys/sysctl.h>
+
#include <algorithm>
-#include "client/mac/handler/dynamic_images.h"
+#include <string>
+#include <vector>
namespace google_breakpad {
+using std::string;
+using std::vector;
+
//==============================================================================
// Returns the size of the memory region containing |address| and the
// number of bytes from |address| to the end of the region.
@@ -51,7 +59,7 @@ namespace google_breakpad {
// straddle two vm regions.
//
static mach_vm_size_t GetMemoryRegionSize(task_port_t target_task,
- const void* address,
+ const uint64_t address,
mach_vm_size_t *size_to_end) {
mach_vm_address_t region_base = (mach_vm_address_t)address;
mach_vm_size_t region_size;
@@ -116,8 +124,8 @@ static mach_vm_size_t GetMemoryRegionSize(task_port_t target_task,
//
// Warning! This will not read any strings longer than kMaxStringLength-1
//
-static void* ReadTaskString(task_port_t target_task,
- const void* address) {
+static string ReadTaskString(task_port_t target_task,
+ const uint64_t address) {
// The problem is we don't know how much to read until we know how long
// the string is. And we don't know how long the string is, until we've read
// the memory! So, we'll try to read kMaxStringLength bytes
@@ -129,147 +137,170 @@ static void* ReadTaskString(task_port_t target_task,
mach_vm_size_t size_to_read =
size_to_end > kMaxStringLength ? kMaxStringLength : size_to_end;
- kern_return_t kr;
- return ReadTaskMemory(target_task, address, (size_t)size_to_read, &kr);
+ vector<uint8_t> bytes;
+ if (ReadTaskMemory(target_task, address, (size_t)size_to_read, bytes) !=
+ KERN_SUCCESS)
+ return string();
+
+ return string(reinterpret_cast<const char*>(&bytes[0]));
}
- return NULL;
+ return string();
}
//==============================================================================
-// Reads an address range from another task. A block of memory is malloced
-// and should be freed by the caller.
-void* ReadTaskMemory(task_port_t target_task,
- const void* address,
- size_t length,
- kern_return_t *kr) {
- void* result = NULL;
+// Reads an address range from another task. The bytes read will be returned
+// in bytes, which will be resized as necessary.
+kern_return_t ReadTaskMemory(task_port_t target_task,
+ const uint64_t address,
+ size_t length,
+ vector<uint8_t> &bytes) {
int systemPageSize = getpagesize();
// use the negative of the page size for the mask to find the page address
- mach_vm_address_t page_address =
- reinterpret_cast<mach_vm_address_t>(address) & (-systemPageSize);
+ mach_vm_address_t page_address = address & (-systemPageSize);
mach_vm_address_t last_page_address =
- (reinterpret_cast<mach_vm_address_t>(address) + length +
- (systemPageSize - 1)) & (-systemPageSize);
+ (address + length + (systemPageSize - 1)) & (-systemPageSize);
mach_vm_size_t page_size = last_page_address - page_address;
uint8_t* local_start;
uint32_t local_length;
- kern_return_t r;
-
- r = mach_vm_read(target_task,
- page_address,
- page_size,
- reinterpret_cast<vm_offset_t*>(&local_start),
- &local_length);
-
-
- if (kr != NULL) {
- *kr = r;
- }
-
- if (r == KERN_SUCCESS) {
- result = malloc(length);
- if (result != NULL) {
- memcpy(result,
- &local_start[(mach_vm_address_t)address - page_address],
- length);
- }
- mach_vm_deallocate(mach_task_self(), (uintptr_t)local_start, local_length);
- }
-
- return result;
+ kern_return_t r = mach_vm_read(target_task,
+ page_address,
+ page_size,
+ reinterpret_cast<vm_offset_t*>(&local_start),
+ &local_length);
+
+ if (r != KERN_SUCCESS)
+ return r;
+
+ bytes.resize(length);
+ memcpy(&bytes[0],
+ &local_start[(mach_vm_address_t)address - page_address],
+ length);
+ mach_vm_deallocate(mach_task_self(), (uintptr_t)local_start, local_length);
+ return KERN_SUCCESS;
}
#pragma mark -
//==============================================================================
-// Initializes vmaddr_, vmsize_, and slide_
-void DynamicImage::CalculateMemoryAndVersionInfo() {
- breakpad_mach_header *header = GetMachHeader();
-
- // unless we can process the header, ensure that calls to
- // IsValid() will return false
- vmaddr_ = 0;
- vmsize_ = 0;
- slide_ = 0;
- version_ = 0;
-
- bool foundTextSection = false;
- bool foundDylibIDCommand = false;
+// Traits structs for specializing function templates to handle
+// 32-bit/64-bit Mach-O files.
+struct MachO32 {
+ typedef mach_header mach_header_type;
+ typedef segment_command mach_segment_command_type;
+ typedef dyld_image_info32 dyld_image_info;
+ typedef dyld_all_image_infos32 dyld_all_image_infos;
+ typedef struct nlist nlist_type;
+ static const uint32_t magic = MH_MAGIC;
+ static const uint32_t segment_load_command = LC_SEGMENT;
+};
+
+struct MachO64 {
+ typedef mach_header_64 mach_header_type;
+ typedef segment_command_64 mach_segment_command_type;
+ typedef dyld_image_info64 dyld_image_info;
+ typedef dyld_all_image_infos64 dyld_all_image_infos;
+ typedef struct nlist_64 nlist_type;
+ static const uint32_t magic = MH_MAGIC_64;
+ static const uint32_t segment_load_command = LC_SEGMENT_64;
+};
+
+template<typename MachBits>
+bool FindTextSection(DynamicImage& image) {
+ typedef typename MachBits::mach_header_type mach_header_type;
+ typedef typename MachBits::mach_segment_command_type
+ mach_segment_command_type;
-#if __LP64__
- if(header->magic != MH_MAGIC_64) {
- return;
- }
-#else
- if(header->magic != MH_MAGIC) {
- return;
- }
-#endif
+ const mach_header_type* header =
+ reinterpret_cast<const mach_header_type*>(&image.header_[0]);
-#ifdef __LP64__
- const uint32_t segmentLoadCommand = LC_SEGMENT_64;
-#else
- const uint32_t segmentLoadCommand = LC_SEGMENT;
-#endif
+ if(header->magic != MachBits::magic) {
+ return false;
+ }
const struct load_command *cmd =
- reinterpret_cast<const struct load_command *>(header + 1);
+ reinterpret_cast<const struct load_command *>(header + 1);
+ bool found_text_section = false;
+ bool found_dylib_id_command = false;
for (unsigned int i = 0; cmd && (i < header->ncmds); ++i) {
- if (!foundTextSection) {
- if (cmd->cmd == segmentLoadCommand) {
- const breakpad_mach_segment_command *seg =
- reinterpret_cast<const breakpad_mach_segment_command *>(cmd);
+ if (!found_text_section) {
+ if (cmd->cmd == MachBits::segment_load_command) {
+ const mach_segment_command_type *seg =
+ reinterpret_cast<const mach_segment_command_type *>(cmd);
if (!strcmp(seg->segname, "__TEXT")) {
- vmaddr_ = seg->vmaddr;
- vmsize_ = seg->vmsize;
- slide_ = 0;
+ image.vmaddr_ = seg->vmaddr;
+ image.vmsize_ = seg->vmsize;
+ image.slide_ = 0;
- if (seg->fileoff == 0 && seg->filesize != 0) {
- slide_ = (uintptr_t)GetLoadAddress() - (uintptr_t)seg->vmaddr;
+ if (seg->fileoff == 0 && seg->filesize != 0) {
+ image.slide_ =
+ (uintptr_t)image.GetLoadAddress() - (uintptr_t)seg->vmaddr;
}
- foundTextSection = true;
+ found_text_section = true;
}
}
}
- if (!foundDylibIDCommand) {
+ if (!found_dylib_id_command) {
if (cmd->cmd == LC_ID_DYLIB) {
const struct dylib_command *dc =
reinterpret_cast<const struct dylib_command *>(cmd);
- version_ = dc->dylib.current_version;
- foundDylibIDCommand = true;
+ image.version_ = dc->dylib.current_version;
+ found_dylib_id_command = true;
}
}
- if (foundDylibIDCommand && foundTextSection) {
- return;
+ if (found_dylib_id_command && found_text_section) {
+ return true;
}
cmd = reinterpret_cast<const struct load_command *>
- (reinterpret_cast<const char *>(cmd) + cmd->cmdsize);
+ (reinterpret_cast<const char *>(cmd) + cmd->cmdsize);
}
+ return false;
}
-void DynamicImage::Print() {
- const char *path = GetFilePath();
- if (!path) {
- path = "(unknown)";
- }
- printf("%p: %s\n", GetLoadAddress(), path);
- breakpad_mach_header *header = GetMachHeader();
- MachHeader(*header).Print();
- printf("vmaddr\t\t: %p\n", reinterpret_cast<void*>(GetVMAddr()));
- printf("vmsize\t\t: %llu\n", GetVMSize());
- printf("slide\t\t: %td\n", GetVMAddrSlide());
+//==============================================================================
+// Initializes vmaddr_, vmsize_, and slide_
+void DynamicImage::CalculateMemoryAndVersionInfo() {
+ // unless we can process the header, ensure that calls to
+ // IsValid() will return false
+ vmaddr_ = 0;
+ vmsize_ = 0;
+ slide_ = 0;
+ version_ = 0;
+
+ // The function template above does all the real work.
+ if (Is64Bit())
+ FindTextSection<MachO64>(*this);
+ else
+ FindTextSection<MachO32>(*this);
+}
+
+//==============================================================================
+// The helper function template abstracts the 32/64-bit differences.
+template<typename MachBits>
+uint32_t GetFileTypeFromHeader(DynamicImage& image) {
+ typedef typename MachBits::mach_header_type mach_header_type;
+
+ const mach_header_type* header =
+ reinterpret_cast<const mach_header_type*>(&image.header_[0]);
+ return header->filetype;
+}
+
+uint32_t DynamicImage::GetFileType() {
+ if (Is64Bit())
+ return GetFileTypeFromHeader<MachO64>(*this);
+
+ return GetFileTypeFromHeader<MachO32>(*this);
}
#pragma mark -
@@ -277,144 +308,158 @@ void DynamicImage::Print() {
//==============================================================================
// Loads information about dynamically loaded code in the given task.
DynamicImages::DynamicImages(mach_port_t task)
- : task_(task), image_list_() {
+ : task_(task),
+ cpu_type_(DetermineTaskCPUType(task)),
+ image_list_() {
ReadImageInfoForTask();
}
-void* DynamicImages::GetDyldAllImageInfosPointer() {
- const char *imageSymbolName = "_dyld_all_image_infos";
- const char *dyldPath = "/usr/lib/dyld";
-#ifndef __LP64__
- struct nlist l[8];
- memset(l, 0, sizeof(l) );
-
- // First we lookup the address of the "_dyld_all_image_infos" struct
- // which lives in "dyld". This structure contains information about all
- // of the loaded dynamic images.
- struct nlist &list = l[0];
- list.n_un.n_name = const_cast<char *>(imageSymbolName);
- nlist(dyldPath,&list);
- if(list.n_value) {
- return reinterpret_cast<void*>(list.n_value);
- }
-
- return NULL;
-#else
- struct nlist_64 l[8];
- struct nlist_64 &list = l[0];
+template<typename MachBits>
+static uint64_t LookupSymbol(const char* symbol_name,
+ const char* filename,
+ cpu_type_t cpu_type) {
+ typedef typename MachBits::nlist_type nlist_type;
- memset(l, 0, sizeof(l) );
-
- const char *symbolNames[2] = { imageSymbolName, "\0" };
-
- int invalidEntriesCount = breakpad_nlist_64(dyldPath,&list,symbolNames);
+ nlist_type symbol_info[8] = {};
+ const char *symbolNames[2] = { symbol_name, "\0" };
+ nlist_type &list = symbol_info[0];
+ int invalidEntriesCount = breakpad_nlist(filename,
+ &list,
+ symbolNames,
+ cpu_type);
if(invalidEntriesCount != 0) {
- return NULL;
+ return 0;
}
+
assert(list.n_value);
- return reinterpret_cast<void*>(list.n_value);
-#endif
+ return list.n_value;
+}
+
+uint64_t DynamicImages::GetDyldAllImageInfosPointer() {
+ const char *imageSymbolName = "_dyld_all_image_infos";
+ const char *dyldPath = "/usr/lib/dyld";
+ if (Is64Bit())
+ return LookupSymbol<MachO64>(imageSymbolName, dyldPath, cpu_type_);
+ return LookupSymbol<MachO32>(imageSymbolName, dyldPath, cpu_type_);
}
+
//==============================================================================
// This code was written using dyld_debug.c (from Darwin) as a guide.
-void DynamicImages::ReadImageInfoForTask() {
- void *imageList = GetDyldAllImageInfosPointer();
- if (imageList) {
- kern_return_t kr;
- // Read the structure inside of dyld that contains information about
- // loaded images. We're reading from the desired task's address space.
-
- // Here we make the assumption that dyld loaded at the same address in
- // the crashed process vs. this one. This is an assumption made in
- // "dyld_debug.c" and is said to be nearly always valid.
- dyld_all_image_infos *dyldInfo = reinterpret_cast<dyld_all_image_infos*>
- (ReadTaskMemory(task_,
- reinterpret_cast<void*>(imageList),
- sizeof(dyld_all_image_infos), &kr));
-
- if (dyldInfo) {
- // number of loaded images
- int count = dyldInfo->infoArrayCount;
-
- // Read an array of dyld_image_info structures each containing
- // information about a loaded image.
- dyld_image_info *infoArray = reinterpret_cast<dyld_image_info*>
- (ReadTaskMemory(task_,
- dyldInfo->infoArray,
- count*sizeof(dyld_image_info), &kr));
-
- image_list_.reserve(count);
-
- for (int i = 0; i < count; ++i) {
- dyld_image_info &info = infoArray[i];
-
- // First read just the mach_header from the image in the task.
- breakpad_mach_header *header = reinterpret_cast<breakpad_mach_header*>
- (ReadTaskMemory(task_,
- info.load_address_,
- sizeof(breakpad_mach_header), &kr));
-
- if (!header)
- break; // bail on this dynamic image
-
- // Now determine the total amount we really want to read based on the
- // size of the load commands. We need the header plus all of the
- // load commands.
- size_t header_size =
- sizeof(breakpad_mach_header) + header->sizeofcmds;
-
- free(header);
-
- header = reinterpret_cast<breakpad_mach_header*>
- (ReadTaskMemory(task_, info.load_address_, header_size, &kr));
-
- // Read the file name from the task's memory space.
- char *file_path = NULL;
- if (info.file_path_) {
- // Although we're reading kMaxStringLength bytes, it's copied in the
- // the DynamicImage constructor below with the correct string length,
- // so it's not really wasting memory.
- file_path = reinterpret_cast<char*>
- (ReadTaskString(task_, info.file_path_));
- }
+template<typename MachBits>
+void ReadImageInfo(DynamicImages& images,
+ uint64_t image_list_address) {
+ typedef typename MachBits::dyld_image_info dyld_image_info;
+ typedef typename MachBits::dyld_all_image_infos dyld_all_image_infos;
+ typedef typename MachBits::mach_header_type mach_header_type;
+
+ // Read the structure inside of dyld that contains information about
+ // loaded images. We're reading from the desired task's address space.
+
+ // Here we make the assumption that dyld loaded at the same address in
+ // the crashed process vs. this one. This is an assumption made in
+ // "dyld_debug.c" and is said to be nearly always valid.
+ vector<uint8_t> dyld_all_info_bytes;
+ if (ReadTaskMemory(images.task_,
+ image_list_address,
+ sizeof(dyld_all_image_infos),
+ dyld_all_info_bytes) != KERN_SUCCESS)
+ return;
- // Create an object representing this image and add it to our list.
- DynamicImage *new_image;
- new_image = new DynamicImage(header,
- header_size,
- (breakpad_mach_header*)info.load_address_,
- file_path,
- info.file_mod_date_,
- task_);
-
- if (new_image->IsValid()) {
- image_list_.push_back(DynamicImageRef(new_image));
- } else {
- delete new_image;
- }
+ dyld_all_image_infos *dyldInfo =
+ reinterpret_cast<dyld_all_image_infos*>(&dyld_all_info_bytes[0]);
- if (file_path) {
- free(file_path);
- }
- }
+ // number of loaded images
+ int count = dyldInfo->infoArrayCount;
- free(dyldInfo);
- free(infoArray);
+ // Read an array of dyld_image_info structures each containing
+ // information about a loaded image.
+ vector<uint8_t> dyld_info_array_bytes;
+ if (ReadTaskMemory(images.task_,
+ dyldInfo->infoArray,
+ count * sizeof(dyld_image_info),
+ dyld_info_array_bytes) != KERN_SUCCESS)
+ return;
- // sorts based on loading address
- sort(image_list_.begin(), image_list_.end() );
- // remove duplicates - this happens in certain strange cases
- // You can see it in DashboardClient when Google Gadgets plugin
- // is installed. Apple's crash reporter log and gdb "info shared"
- // both show the same library multiple times at the same address
+ dyld_image_info *infoArray =
+ reinterpret_cast<dyld_image_info*>(&dyld_info_array_bytes[0]);
+ images.image_list_.reserve(count);
+
+ for (int i = 0; i < count; ++i) {
+ dyld_image_info &info = infoArray[i];
+
+ // First read just the mach_header from the image in the task.
+ vector<uint8_t> mach_header_bytes;
+ if (ReadTaskMemory(images.task_,
+ info.load_address_,
+ sizeof(mach_header_type),
+ mach_header_bytes) != KERN_SUCCESS)
+ continue; // bail on this dynamic image
+
+ mach_header_type *header =
+ reinterpret_cast<mach_header_type*>(&mach_header_bytes[0]);
+
+ // Now determine the total amount necessary to read the header
+ // plus all of the load commands.
+ size_t header_size =
+ sizeof(mach_header_type) + header->sizeofcmds;
+
+ if (ReadTaskMemory(images.task_,
+ info.load_address_,
+ header_size,
+ mach_header_bytes) != KERN_SUCCESS)
+ continue;
+
+ header = reinterpret_cast<mach_header_type*>(&mach_header_bytes[0]);
+
+ // Read the file name from the task's memory space.
+ string file_path;
+ if (info.file_path_) {
+ // Although we're reading kMaxStringLength bytes, it's copied in the
+ // the DynamicImage constructor below with the correct string length,
+ // so it's not really wasting memory.
+ file_path = ReadTaskString(images.task_, info.file_path_);
+ }
- vector<DynamicImageRef>::iterator it = unique(image_list_.begin(),
- image_list_.end() );
- image_list_.erase(it, image_list_.end());
+ // Create an object representing this image and add it to our list.
+ DynamicImage *new_image;
+ new_image = new DynamicImage(&mach_header_bytes[0],
+ header_size,
+ info.load_address_,
+ file_path,
+ info.file_mod_date_,
+ images.task_,
+ images.cpu_type_);
+
+ if (new_image->IsValid()) {
+ images.image_list_.push_back(DynamicImageRef(new_image));
+ } else {
+ delete new_image;
+ }
}
+
+ // sorts based on loading address
+ sort(images.image_list_.begin(), images.image_list_.end());
+ // remove duplicates - this happens in certain strange cases
+ // You can see it in DashboardClient when Google Gadgets plugin
+ // is installed. Apple's crash reporter log and gdb "info shared"
+ // both show the same library multiple times at the same address
+
+ vector<DynamicImageRef>::iterator it = unique(images.image_list_.begin(),
+ images.image_list_.end());
+ images.image_list_.erase(it, images.image_list_.end());
+}
+
+void DynamicImages::ReadImageInfoForTask() {
+ uint64_t imageList = GetDyldAllImageInfosPointer();
+
+ if (imageList) {
+ if (Is64Bit())
+ ReadImageInfo<MachO64>(*this, imageList);
+ else
+ ReadImageInfo<MachO32>(*this, imageList);
}
}
@@ -436,7 +481,7 @@ int DynamicImages::GetExecutableImageIndex() {
for (int i = 0; i < image_count; ++i) {
DynamicImage *image = GetImage(i);
- if (image->GetMachHeader()->filetype == MH_EXECUTE) {
+ if (image->GetFileType() == MH_EXECUTE) {
return i;
}
}
@@ -444,4 +489,27 @@ int DynamicImages::GetExecutableImageIndex() {
return -1;
}
+//==============================================================================
+// static
+cpu_type_t DynamicImages::DetermineTaskCPUType(task_t task) {
+ if (task == mach_task_self())
+ return GetNativeCPUType();
+
+ int mib[CTL_MAXNAME];
+ size_t mibLen = CTL_MAXNAME;
+ int err = sysctlnametomib("sysctl.proc_cputype", mib, &mibLen);
+ if (err == 0) {
+ assert(mibLen < CTL_MAXNAME);
+ pid_for_task(task, &mib[mibLen]);
+ mibLen += 1;
+
+ cpu_type_t cpu_type;
+ size_t cpuTypeSize = sizeof(cpu_type);
+ sysctl(mib, mibLen, &cpu_type, &cpuTypeSize, 0, 0);
+ return cpu_type;
+ }
+
+ return GetNativeCPUType();
+}
+
} // namespace google_breakpad
diff --git a/src/client/mac/handler/dynamic_images.h b/src/client/mac/handler/dynamic_images.h
index 72eb221b..63816bf3 100644
--- a/src/client/mac/handler/dynamic_images.h
+++ b/src/client/mac/handler/dynamic_images.h
@@ -41,32 +41,49 @@
#include <mach-o/dyld.h>
#include <mach-o/loader.h>
#include <sys/types.h>
+
+#include <string>
#include <vector>
namespace google_breakpad {
+using std::string;
using std::vector;
//==============================================================================
// The memory layout of this struct matches the dyld_image_info struct
// defined in "dyld_gdb.h" in the darwin source.
-typedef struct dyld_image_info {
- struct mach_header *load_address_;
- char *file_path_;
- uintptr_t file_mod_date_;
-} dyld_image_info;
+typedef struct dyld_image_info32 {
+ uint32_t load_address_; // struct mach_header*
+ uint32_t file_path_; // char*
+ uint32_t file_mod_date_;
+} dyld_image_info32;
+
+typedef struct dyld_image_info64 {
+ uint64_t load_address_; // struct mach_header*
+ uint64_t file_path_; // char*
+ uint64_t file_mod_date_;
+} dyld_image_info64;
//==============================================================================
// This is as defined in "dyld_gdb.h" in the darwin source.
// _dyld_all_image_infos (in dyld) is a structure of this type
// which will be used to determine which dynamic code has been loaded.
-typedef struct dyld_all_image_infos {
+typedef struct dyld_all_image_infos32 {
+ uint32_t version; // == 1 in Mac OS X 10.4
+ uint32_t infoArrayCount;
+ uint32_t infoArray; // const struct dyld_image_info*
+ uint32_t notification;
+ bool processDetachedFromSharedRegion;
+} dyld_all_image_infos32;
+
+typedef struct dyld_all_image_infos64 {
uint32_t version; // == 1 in Mac OS X 10.4
uint32_t infoArrayCount;
- const struct dyld_image_info *infoArray;
- void* notification;
+ uint64_t infoArray; // const struct dyld_image_info*
+ uint64_t notification;
bool processDetachedFromSharedRegion;
-} dyld_all_image_infos;
+} dyld_all_image_infos64;
// some typedefs to isolate 64/32 bit differences
#ifdef __LP64__
@@ -77,71 +94,49 @@ typedef mach_header breakpad_mach_header;
typedef segment_command breakpad_mach_segment_command;
#endif
-//==============================================================================
-// A simple wrapper for a mach_header
-//
-// This could be fleshed out with some more interesting methods.
-class MachHeader {
- public:
- explicit MachHeader(const breakpad_mach_header &header) : header_(header) {}
-
- void Print() {
- printf("magic\t\t: %4x\n", header_.magic);
- printf("cputype\t\t: %d\n", header_.cputype);
- printf("cpusubtype\t: %d\n", header_.cpusubtype);
- printf("filetype\t: %d\n", header_.filetype);
- printf("ncmds\t\t: %d\n", header_.ncmds);
- printf("sizeofcmds\t: %d\n", header_.sizeofcmds);
- printf("flags\t\t: %d\n", header_.flags);
- }
+// Helper functions to deal with 32-bit/64-bit Mach-O differences.
+class DynamicImage;
+template<typename MachBits>
+bool FindTextSection(DynamicImage& image);
- breakpad_mach_header header_;
-};
+template<typename MachBits>
+uint32_t GetFileTypeFromHeader(DynamicImage& image);
//==============================================================================
// Represents a single dynamically loaded mach-o image
class DynamicImage {
public:
- DynamicImage(breakpad_mach_header *header, // we take ownership
- size_t header_size, // includes load commands
- breakpad_mach_header *load_address,
- char *inFilePath,
+ DynamicImage(uint8_t *header, // data is copied
+ size_t header_size, // includes load commands
+ uint64_t load_address,
+ string file_path,
uintptr_t image_mod_date,
- mach_port_t task)
- : header_(header),
+ mach_port_t task,
+ cpu_type_t cpu_type)
+ : header_(header, header + header_size),
header_size_(header_size),
load_address_(load_address),
vmaddr_(0),
vmsize_(0),
slide_(0),
version_(0),
- file_path_(NULL),
+ file_path_(file_path),
file_mod_date_(image_mod_date),
- task_(task) {
- InitializeFilePath(inFilePath);
+ task_(task),
+ cpu_type_(cpu_type) {
CalculateMemoryAndVersionInfo();
}
- ~DynamicImage() {
- if (file_path_) {
- free(file_path_);
- }
- free(header_);
- }
-
- // Returns pointer to a local copy of the mach_header plus load commands
- breakpad_mach_header *GetMachHeader() {return header_;}
-
// Size of mach_header plus load commands
- size_t GetHeaderSize() const {return header_size_;}
+ size_t GetHeaderSize() const {return header_.size();}
// Full path to mach-o binary
- char *GetFilePath() {return file_path_;}
+ string GetFilePath() {return file_path_;}
- uintptr_t GetModDate() const {return file_mod_date_;}
+ uint64_t GetModDate() const {return file_mod_date_;}
// Actual address where the image was loaded
- breakpad_mach_header *GetLoadAddress() const {return load_address_;}
+ uint64_t GetLoadAddress() const {return load_address_;}
// Address where the image should be loaded
mach_vm_address_t GetVMAddr() const {return vmaddr_;}
@@ -155,49 +150,49 @@ class DynamicImage {
// Task owning this loaded image
mach_port_t GetTask() {return task_;}
+ // CPU type of the task
+ cpu_type_t GetCPUType() {return cpu_type_;}
+
+ // filetype from the Mach-O header.
+ uint32_t GetFileType();
+
+ // Return true if the task is a 64-bit architecture.
+ bool Is64Bit() { return (GetCPUType() & CPU_ARCH_ABI64) == CPU_ARCH_ABI64; }
+
uint32_t GetVersion() {return version_;}
// For sorting
bool operator<(const DynamicImage &inInfo) {
return GetLoadAddress() < inInfo.GetLoadAddress();
}
- // Debugging
- void Print();
+ // Sanity checking
+ bool IsValid() {return GetVMSize() != 0;}
private:
DynamicImage(const DynamicImage &);
DynamicImage &operator=(const DynamicImage &);
friend class DynamicImages;
-
- // Sanity checking
- bool IsValid() {return GetVMSize() != 0;}
-
- // Makes local copy of file path to mach-o binary
- void InitializeFilePath(char *inFilePath) {
- if (inFilePath) {
- size_t path_size = 1 + strlen(inFilePath);
- file_path_ = reinterpret_cast<char*>(malloc(path_size));
- strlcpy(file_path_, inFilePath, path_size);
- } else {
- file_path_ = NULL;
- }
- }
+ template<typename MachBits>
+ friend bool FindTextSection(DynamicImage& image);
+ template<typename MachBits>
+ friend uint32_t GetFileTypeFromHeader(DynamicImage& image);
// Initializes vmaddr_, vmsize_, and slide_
void CalculateMemoryAndVersionInfo();
- breakpad_mach_header *header_; // our local copy of the header
+ const vector<uint8_t> header_; // our local copy of the header
size_t header_size_; // mach_header plus load commands
- breakpad_mach_header *load_address_; // base address image is mapped into
+ uint64_t load_address_; // base address image is mapped into
mach_vm_address_t vmaddr_;
mach_vm_size_t vmsize_;
ptrdiff_t slide_;
uint32_t version_; // Dylib version
- char *file_path_; // path dyld used to load the image
+ string file_path_; // path dyld used to load the image
uintptr_t file_mod_date_; // time_t of image file
mach_port_t task_;
+ cpu_type_t cpu_type_; // CPU type of task_
};
//==============================================================================
@@ -230,6 +225,11 @@ class DynamicImageRef {
DynamicImage *p;
};
+// Helper function to deal with 32-bit/64-bit Mach-O differences.
+class DynamicImages;
+template<typename MachBits>
+void ReadImageInfo(DynamicImages& images, uint64_t image_list_address);
+
//==============================================================================
// An object of type DynamicImages may be created to allow introspection of
// an arbitrary task's dynamically loaded mach-o binaries. This makes the
@@ -262,43 +262,51 @@ class DynamicImages {
// Returns the task which we're looking at.
mach_port_t GetTask() const {return task_;}
- // Debugging
- void Print() {
- for (int i = 0; i < GetImageCount(); ++i) {
- image_list_[i]->Print();
- }
- }
-
- void TestPrint() {
- const breakpad_mach_header *header;
- for (int i = 0; i < GetImageCount(); ++i) {
- printf("dyld: %p: name = %s\n", _dyld_get_image_header(i),
- _dyld_get_image_name(i) );
-
- const void *imageHeader = _dyld_get_image_header(i);
- header = reinterpret_cast<const breakpad_mach_header*>(imageHeader);
-
- MachHeader(*header).Print();
- }
+ // CPU type of the task
+ cpu_type_t GetCPUType() {return cpu_type_;}
+
+ // Return true if the task is a 64-bit architecture.
+ bool Is64Bit() { return (GetCPUType() & CPU_ARCH_ABI64) == CPU_ARCH_ABI64; }
+
+ // Determine the CPU type of the task being dumped.
+ static cpu_type_t DetermineTaskCPUType(task_t task);
+
+ // Get the native CPU type of this task.
+ static cpu_type_t GetNativeCPUType() {
+#if defined(__i386__)
+ return CPU_TYPE_I386;
+#elif defined(__x86_64__)
+ return CPU_TYPE_X86_64;
+#elif defined(__ppc__)
+ return CPU_TYPE_POWERPC;
+#elif defined(__ppc64__)
+ return CPU_TYPE_POWERPC64;
+#else
+#error "GetNativeCPUType not implemented for this architecture"
+#endif
}
private:
+ template<typename MachBits>
+ friend void ReadImageInfo(DynamicImages& images, uint64_t image_list_address);
+
bool IsOurTask() {return task_ == mach_task_self();}
// Initialization
void ReadImageInfoForTask();
- void* GetDyldAllImageInfosPointer();
+ uint64_t GetDyldAllImageInfosPointer();
mach_port_t task_;
+ cpu_type_t cpu_type_; // CPU type of task_
vector<DynamicImageRef> image_list_;
};
-// Returns a malloced block containing the contents of memory at a particular
+// Fill bytes with the contents of memory at a particular
// location in another task.
-void* ReadTaskMemory(task_port_t target_task,
- const void* address,
- size_t len,
- kern_return_t *kr);
+kern_return_t ReadTaskMemory(task_port_t target_task,
+ const uint64_t address,
+ size_t length,
+ vector<uint8_t> &bytes);
} // namespace google_breakpad
diff --git a/src/client/mac/handler/minidump_generator.cc b/src/client/mac/handler/minidump_generator.cc
index 8e3faf27..2e9765ad 100644
--- a/src/client/mac/handler/minidump_generator.cc
+++ b/src/client/mac/handler/minidump_generator.cc
@@ -31,7 +31,9 @@
#include <cstdio>
#include <mach/host_info.h>
+#include <mach/i386/thread_status.h>
#include <mach/mach_vm.h>
+#include <mach/ppc/thread_status.h>
#include <mach/vm_statistics.h>
#include <mach-o/dyld.h>
#include <mach-o/loader.h>
@@ -65,6 +67,7 @@ MinidumpGenerator::MinidumpGenerator()
exception_thread_(0),
crashing_task_(mach_task_self()),
handler_thread_(mach_thread_self()),
+ cpu_type_(DynamicImages::GetNativeCPUType()),
dynamic_images_(NULL),
memory_blocks_(&allocator_) {
GatherSystemInformation();
@@ -81,12 +84,15 @@ MinidumpGenerator::MinidumpGenerator(mach_port_t crashing_task,
exception_thread_(0),
crashing_task_(crashing_task),
handler_thread_(handler_thread),
+ cpu_type_(DynamicImages::GetNativeCPUType()),
dynamic_images_(NULL),
memory_blocks_(&allocator_) {
if (crashing_task != mach_task_self()) {
dynamic_images_ = new DynamicImages(crashing_task_);
+ cpu_type_ = dynamic_images_->GetCPUType();
} else {
dynamic_images_ = NULL;
+ cpu_type_ = DynamicImages::GetNativeCPUType();
}
GatherSystemInformation();
@@ -254,8 +260,10 @@ size_t MinidumpGenerator::CalculateStackSize(mach_vm_address_t start_addr) {
return 0;
}
-
- if ((stack_region_base + stack_region_size) == TOP_OF_THREAD0_STACK) {
+ if (((cpu_type_ & CPU_ARCH_ABI64) &&
+ (stack_region_base + stack_region_size) == TOP_OF_THREAD0_STACK_64BIT) ||
+ (!(cpu_type_ & CPU_ARCH_ABI64) &&
+ (stack_region_base + stack_region_size) == TOP_OF_THREAD0_STACK_32BIT)) {
// The stack for thread 0 needs to extend all the way to
// 0xc0000000 on 32 bit and 00007fff5fc00000 on 64bit. HOWEVER,
// for many processes, the stack is first created in one page
@@ -305,20 +313,15 @@ bool MinidumpGenerator::WriteStackFromStartAddress(
return false;
if (dynamic_images_) {
-
- kern_return_t kr;
-
- void *stack_memory = ReadTaskMemory(crashing_task_,
- (void*)start_addr,
- size,
- &kr);
-
- if (stack_memory == NULL) {
+ vector<uint8_t> stack_memory;
+ if (ReadTaskMemory(crashing_task_,
+ start_addr,
+ size,
+ stack_memory) != KERN_SUCCESS) {
return false;
}
- result = memory.Copy(stack_memory, size);
- free(stack_memory);
+ result = memory.Copy(&stack_memory[0], size);
} else {
result = memory.Copy(reinterpret_cast<const void *>(start_addr), size);
}
@@ -330,34 +333,99 @@ bool MinidumpGenerator::WriteStackFromStartAddress(
return result;
}
-#if TARGET_CPU_PPC || TARGET_CPU_PPC64
bool MinidumpGenerator::WriteStack(breakpad_thread_state_data_t state,
MDMemoryDescriptor *stack_location) {
- breakpad_thread_state_t *machine_state =
- reinterpret_cast<breakpad_thread_state_t *>(state);
+ switch (cpu_type_) {
+ case CPU_TYPE_POWERPC:
+ return WriteStackPPC(state, stack_location);
+ case CPU_TYPE_POWERPC64:
+ return WriteStackPPC64(state, stack_location);
+ case CPU_TYPE_I386:
+ return WriteStackX86(state, stack_location);
+ case CPU_TYPE_X86_64:
+ return WriteStackX86_64(state, stack_location);
+ default:
+ return false;
+ }
+}
+
+bool MinidumpGenerator::WriteContext(breakpad_thread_state_data_t state,
+ MDLocationDescriptor *register_location) {
+ switch (cpu_type_) {
+ case CPU_TYPE_POWERPC:
+ return WriteContextPPC(state, register_location);
+ case CPU_TYPE_POWERPC64:
+ return WriteContextPPC64(state, register_location);
+ case CPU_TYPE_I386:
+ return WriteContextX86(state, register_location);
+ case CPU_TYPE_X86_64:
+ return WriteContextX86_64(state, register_location);
+ default:
+ return false;
+ }
+}
+
+u_int64_t MinidumpGenerator::CurrentPCForStack(
+ breakpad_thread_state_data_t state) {
+ switch (cpu_type_) {
+ case CPU_TYPE_POWERPC:
+ return CurrentPCForStackPPC(state);
+ case CPU_TYPE_POWERPC64:
+ return CurrentPCForStackPPC64(state);
+ case CPU_TYPE_I386:
+ return CurrentPCForStackX86(state);
+ case CPU_TYPE_X86_64:
+ return CurrentPCForStackX86_64(state);
+ default:
+ assert("Unknown CPU type!");
+ return 0;
+ }
+}
+
+bool MinidumpGenerator::WriteStackPPC(breakpad_thread_state_data_t state,
+ MDMemoryDescriptor *stack_location) {
+ ppc_thread_state_t *machine_state =
+ reinterpret_cast<ppc_thread_state_t *>(state);
+ mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, r1);
+ return WriteStackFromStartAddress(start_addr, stack_location);
+}
+
+bool MinidumpGenerator::WriteStackPPC64(breakpad_thread_state_data_t state,
+ MDMemoryDescriptor *stack_location) {
+ ppc_thread_state64_t *machine_state =
+ reinterpret_cast<ppc_thread_state64_t *>(state);
mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, r1);
return WriteStackFromStartAddress(start_addr, stack_location);
}
u_int64_t
-MinidumpGenerator::CurrentPCForStack(breakpad_thread_state_data_t state) {
- breakpad_thread_state_t *machine_state =
- reinterpret_cast<breakpad_thread_state_t *>(state);
+MinidumpGenerator::CurrentPCForStackPPC(breakpad_thread_state_data_t state) {
+ ppc_thread_state_t *machine_state =
+ reinterpret_cast<ppc_thread_state_t *>(state);
return REGISTER_FROM_THREADSTATE(machine_state, srr0);
}
-bool MinidumpGenerator::WriteContext(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location) {
- TypedMDRVA<MinidumpContext> context(&writer_);
- breakpad_thread_state_t *machine_state =
- reinterpret_cast<breakpad_thread_state_t *>(state);
+u_int64_t
+MinidumpGenerator::CurrentPCForStackPPC64(breakpad_thread_state_data_t state) {
+ ppc_thread_state64_t *machine_state =
+ reinterpret_cast<ppc_thread_state64_t *>(state);
+
+ return REGISTER_FROM_THREADSTATE(machine_state, srr0);
+}
+
+bool MinidumpGenerator::WriteContextPPC(breakpad_thread_state_data_t state,
+ MDLocationDescriptor *register_location)
+{
+ TypedMDRVA<MDRawContextPPC> context(&writer_);
+ ppc_thread_state_t *machine_state =
+ reinterpret_cast<ppc_thread_state_t *>(state);
if (!context.Allocate())
return false;
*register_location = context.location();
- MinidumpContext *context_ptr = context.get();
+ MDRawContextPPC *context_ptr = context.get();
context_ptr->context_flags = MD_CONTEXT_PPC_BASE;
#define AddReg(a) context_ptr->a = REGISTER_FROM_THREADSTATE(machine_state, a)
@@ -402,57 +470,124 @@ bool MinidumpGenerator::WriteContext(breakpad_thread_state_data_t state,
AddGPR(29);
AddGPR(30);
AddGPR(31);
-
-#if TARGET_CPU_PPC
- /* The mq register is only for PPC */
AddReg(mq);
-#endif
-
+#undef AddReg
+#undef AddGPR
return true;
}
-#elif TARGET_CPU_X86 || TARGET_CPU_X86_64
+bool MinidumpGenerator::WriteContextPPC64(
+ breakpad_thread_state_data_t state,
+ MDLocationDescriptor *register_location) {
+ TypedMDRVA<MDRawContextPPC64> context(&writer_);
+ ppc_thread_state64_t *machine_state =
+ reinterpret_cast<ppc_thread_state64_t *>(state);
-bool MinidumpGenerator::WriteStack(breakpad_thread_state_data_t state,
+ if (!context.Allocate())
+ return false;
+
+ *register_location = context.location();
+ MDRawContextPPC64 *context_ptr = context.get();
+ context_ptr->context_flags = MD_CONTEXT_PPC_BASE;
+
+#define AddReg(a) context_ptr->a = REGISTER_FROM_THREADSTATE(machine_state, a)
+#define AddGPR(a) context_ptr->gpr[a] = REGISTER_FROM_THREADSTATE(machine_state, r ## a)
+
+ AddReg(srr0);
+ AddReg(cr);
+ AddReg(xer);
+ AddReg(ctr);
+ AddReg(lr);
+ AddReg(vrsave);
+
+ AddGPR(0);
+ AddGPR(1);
+ AddGPR(2);
+ AddGPR(3);
+ AddGPR(4);
+ AddGPR(5);
+ AddGPR(6);
+ AddGPR(7);
+ AddGPR(8);
+ AddGPR(9);
+ AddGPR(10);
+ AddGPR(11);
+ AddGPR(12);
+ AddGPR(13);
+ AddGPR(14);
+ AddGPR(15);
+ AddGPR(16);
+ AddGPR(17);
+ AddGPR(18);
+ AddGPR(19);
+ AddGPR(20);
+ AddGPR(21);
+ AddGPR(22);
+ AddGPR(23);
+ AddGPR(24);
+ AddGPR(25);
+ AddGPR(26);
+ AddGPR(27);
+ AddGPR(28);
+ AddGPR(29);
+ AddGPR(30);
+ AddGPR(31);
+#undef AddReg
+#undef AddGPR
+
+ return true;
+}
+
+bool MinidumpGenerator::WriteStackX86(breakpad_thread_state_data_t state,
MDMemoryDescriptor *stack_location) {
- breakpad_thread_state_t *machine_state =
- reinterpret_cast<breakpad_thread_state_t *>(state);
+ i386_thread_state_t *machine_state =
+ reinterpret_cast<i386_thread_state_t *>(state);
-#if TARGET_CPU_X86_64
- mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, rsp);
-#else
mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, esp);
-#endif
+ return WriteStackFromStartAddress(start_addr, stack_location);
+}
+
+bool MinidumpGenerator::WriteStackX86_64(breakpad_thread_state_data_t state,
+ MDMemoryDescriptor *stack_location) {
+ x86_thread_state64_t *machine_state =
+ reinterpret_cast<x86_thread_state64_t *>(state);
+
+ mach_vm_address_t start_addr = REGISTER_FROM_THREADSTATE(machine_state, rsp);
return WriteStackFromStartAddress(start_addr, stack_location);
}
u_int64_t
-MinidumpGenerator::CurrentPCForStack(breakpad_thread_state_data_t state) {
- breakpad_thread_state_t *machine_state =
- reinterpret_cast<breakpad_thread_state_t *>(state);
+MinidumpGenerator::CurrentPCForStackX86(breakpad_thread_state_data_t state) {
+ i386_thread_state_t *machine_state =
+ reinterpret_cast<i386_thread_state_t *>(state);
-#if TARGET_CPU_X86_64
- return REGISTER_FROM_THREADSTATE(machine_state, rip);
-#else
return REGISTER_FROM_THREADSTATE(machine_state, eip);
-#endif
}
-bool MinidumpGenerator::WriteContext(breakpad_thread_state_data_t state,
- MDLocationDescriptor *register_location) {
- TypedMDRVA<MinidumpContext> context(&writer_);
- breakpad_thread_state_t *machine_state =
- reinterpret_cast<breakpad_thread_state_t *>(state);
+u_int64_t
+MinidumpGenerator::CurrentPCForStackX86_64(breakpad_thread_state_data_t state) {
+ x86_thread_state64_t *machine_state =
+ reinterpret_cast<x86_thread_state64_t *>(state);
+
+ return REGISTER_FROM_THREADSTATE(machine_state, rip);
+}
+
+bool MinidumpGenerator::WriteContextX86(breakpad_thread_state_data_t state,
+ MDLocationDescriptor *register_location)
+{
+ TypedMDRVA<MDRawContextX86> context(&writer_);
+ i386_thread_state_t *machine_state =
+ reinterpret_cast<i386_thread_state_t *>(state);
if (!context.Allocate())
return false;
*register_location = context.location();
- MinidumpContext *context_ptr = context.get();
+ MDRawContextX86 *context_ptr = context.get();
#define AddReg(a) context_ptr->a = REGISTER_FROM_THREADSTATE(machine_state, a)
-#if TARGET_CPU_X86
+
context_ptr->context_flags = MD_CONTEXT_X86;
AddReg(eax);
AddReg(ebx);
@@ -472,7 +607,26 @@ bool MinidumpGenerator::WriteContext(breakpad_thread_state_data_t state,
AddReg(eflags);
AddReg(eip);
-#else
+#undef AddReg(a)
+
+ return true;
+}
+
+bool MinidumpGenerator::WriteContextX86_64(
+ breakpad_thread_state_data_t state,
+ MDLocationDescriptor *register_location) {
+ TypedMDRVA<MDRawContextAMD64> context(&writer_);
+ x86_thread_state64_t *machine_state =
+ reinterpret_cast<x86_thread_state64_t *>(state);
+
+ if (!context.Allocate())
+ return false;
+
+ *register_location = context.location();
+ MDRawContextAMD64 *context_ptr = context.get();
+
+#define AddReg(a) context_ptr->a = REGISTER_FROM_THREADSTATE(machine_state, a)
+
context_ptr->context_flags = MD_CONTEXT_AMD64;
AddReg(rax);
AddReg(rbx);
@@ -495,16 +649,38 @@ bool MinidumpGenerator::WriteContext(breakpad_thread_state_data_t state,
// not used in the flags register. Since the minidump format
// specifies 32 bits for the flags register, we can truncate safely
// with no loss.
- context_ptr->eflags = static_cast<u_int32_t>(machine_state->__rflags);
+ context_ptr->eflags = static_cast<u_int32_t>(REGISTER_FROM_THREADSTATE(machine_state, rflags));
AddReg(cs);
AddReg(fs);
AddReg(gs);
-#endif
#undef AddReg(a)
return true;
}
-#endif
+
+bool MinidumpGenerator::GetThreadState(thread_act_t target_thread,
+ thread_state_t state,
+ mach_msg_type_number_t *count) {
+ thread_state_flavor_t flavor;
+ switch (cpu_type_) {
+ case CPU_TYPE_POWERPC:
+ flavor = PPC_THREAD_STATE;
+ break;
+ case CPU_TYPE_POWERPC64:
+ flavor = PPC_THREAD_STATE64;
+ break;
+ case CPU_TYPE_I386:
+ flavor = i386_THREAD_STATE;
+ break;
+ case CPU_TYPE_X86_64:
+ flavor = x86_THREAD_STATE64;
+ break;
+ default:
+ return false;
+ }
+ return thread_get_state(target_thread, flavor,
+ state, count) == KERN_SUCCESS;
+}
bool MinidumpGenerator::WriteThreadStream(mach_port_t thread_id,
MDRawThread *thread) {
@@ -512,9 +688,7 @@ bool MinidumpGenerator::WriteThreadStream(mach_port_t thread_id,
mach_msg_type_number_t state_count
= static_cast<mach_msg_type_number_t>(sizeof(state));
- if (thread_get_state(thread_id, BREAKPAD_MACHINE_THREAD_STATE,
- state, &state_count) ==
- KERN_SUCCESS) {
+ if (GetThreadState(thread_id, state, &state_count)) {
if (!WriteStack(state, &thread->stack))
return false;
@@ -653,21 +827,15 @@ bool MinidumpGenerator::WriteMemoryListStream(
if (dynamic_images_) {
// Out-of-process.
- kern_return_t kr;
-
- void *memory =
- ReadTaskMemory(
- crashing_task_,
- reinterpret_cast<const void *>(ip_memory_d.start_of_memory_range),
- ip_memory_d.memory.data_size,
- &kr);
-
- if (memory == NULL) {
+ vector<uint8_t> memory;
+ if (ReadTaskMemory(crashing_task_,
+ ip_memory_d.start_of_memory_range,
+ ip_memory_d.memory.data_size,
+ memory) != KERN_SUCCESS) {
return false;
}
- ip_memory.Copy(memory, ip_memory_d.memory.data_size);
- free(memory);
+ ip_memory.Copy(&memory[0], ip_memory_d.memory.data_size);
} else {
// In-process, just copy from local memory.
ip_memory.Copy(
@@ -733,23 +901,23 @@ bool MinidumpGenerator::WriteSystemInfoStream(
system_info_stream->location = info.location();
// CPU Information
- uint32_t cpu_type;
- size_t len = sizeof(cpu_type);
- sysctlbyname("hw.cputype", &cpu_type, &len, NULL, 0);
uint32_t number_of_processors;
- len = sizeof(number_of_processors);
+ size_t len = sizeof(number_of_processors);
sysctlbyname("hw.ncpu", &number_of_processors, &len, NULL, 0);
MDRawSystemInfo *info_ptr = info.get();
- switch (cpu_type) {
+ switch (cpu_type_) {
case CPU_TYPE_POWERPC:
+ case CPU_TYPE_POWERPC64:
info_ptr->processor_architecture = MD_CPU_ARCHITECTURE_PPC;
break;
case CPU_TYPE_I386:
case CPU_TYPE_X86_64:
- // hw.cputype is currently always I386 even on an x86-64 system
+ if (cpu_type_ == CPU_TYPE_I386)
+ info_ptr->processor_architecture = MD_CPU_ARCHITECTURE_X86;
+ else
+ info_ptr->processor_architecture = MD_CPU_ARCHITECTURE_AMD64;
#ifdef __i386__
- info_ptr->processor_architecture = MD_CPU_ARCHITECTURE_X86;
// ebx is used for PIC code, so we need
// to preserve it.
#define cpuid(op,eax,ebx,ecx,edx) \
@@ -763,7 +931,7 @@ bool MinidumpGenerator::WriteSystemInfoStream(
"=d" (edx) \
: "0" (op))
#elif defined(__x86_64__)
- info_ptr->processor_architecture = MD_CPU_ARCHITECTURE_AMD64;
+
#define cpuid(op,eax,ebx,ecx,edx) \
asm ("cpuid \n\t" \
: "=a" (eax), \
@@ -837,19 +1005,12 @@ bool MinidumpGenerator::WriteModuleStream(unsigned int index,
if (!image)
return false;
- const breakpad_mach_header *header = image->GetMachHeader();
-
- if (!header)
- return false;
-
- int cpu_type = header->cputype;
-
memset(module, 0, sizeof(MDRawModule));
MDLocationDescriptor string_location;
- const char* name = image->GetFilePath();
- if (!writer_.WriteString(name, 0, &string_location))
+ string name = image->GetFilePath();
+ if (!writer_.WriteString(name.c_str(), 0, &string_location))
return false;
module->base_of_image = image->GetVMAddr() + image->GetVMAddrSlide();
@@ -876,12 +1037,11 @@ bool MinidumpGenerator::WriteModuleStream(unsigned int index,
module->version_info.file_version_lo |= (modVersion & 0xff);
}
- if (!WriteCVRecord(module, cpu_type, name)) {
+ if (!WriteCVRecord(module, image->GetCPUType(), name.c_str())) {
return false;
}
} else {
- // we're getting module info in the crashed process
-
+ // Getting module info in the crashed process
const breakpad_mach_header *header;
header = (breakpad_mach_header*)_dyld_get_image_header(index);
if (!header)
@@ -903,7 +1063,7 @@ bool MinidumpGenerator::WriteModuleStream(unsigned int index,
unsigned long slide = _dyld_get_image_vmaddr_slide(index);
const char* name = _dyld_get_image_name(index);
const struct load_command *cmd =
- reinterpret_cast<const struct load_command *>(header + 1);
+ reinterpret_cast<const struct load_command *>(header + 1);
memset(module, 0, sizeof(MDRawModule));
@@ -911,7 +1071,7 @@ bool MinidumpGenerator::WriteModuleStream(unsigned int index,
if (cmd->cmd == LC_SEGMENT_ARCH) {
const breakpad_mach_segment_command *seg =
- reinterpret_cast<const breakpad_mach_segment_command *>(cmd);
+ reinterpret_cast<const breakpad_mach_segment_command *>(cmd);
if (!strcmp(seg->segname, "__TEXT")) {
MDLocationDescriptor string_location;
diff --git a/src/client/mac/handler/minidump_generator.h b/src/client/mac/handler/minidump_generator.h
index 39f28402..224ad1c2 100644
--- a/src/client/mac/handler/minidump_generator.h
+++ b/src/client/mac/handler/minidump_generator.h
@@ -47,25 +47,8 @@ namespace google_breakpad {
using std::string;
-#if TARGET_CPU_X86_64 || TARGET_CPU_PPC64
-#define TOP_OF_THREAD0_STACK 0x00007fff5fbff000
-#else
-#define TOP_OF_THREAD0_STACK 0xbffff000
-#endif
-
-#if TARGET_CPU_X86_64
-typedef x86_thread_state64_t breakpad_thread_state_t;
-typedef MDRawContextAMD64 MinidumpContext;
-#elif TARGET_CPU_X86
-typedef i386_thread_state_t breakpad_thread_state_t;
-typedef MDRawContextX86 MinidumpContext;
-#elif TARGET_CPU_PPC64
-typedef ppc_thread_state64_t breakpad_thread_state_t;
-typedef MDRawContextPPC64 MinidumpContext;
-#elif TARGET_CPU_PPC
-typedef ppc_thread_state_t breakpad_thread_state_t;
-typedef MDRawContextPPC MinidumpContext;
-#endif
+const u_int64_t TOP_OF_THREAD0_STACK_64BIT = 0x00007fff5fbff000LL;
+const u_int32_t TOP_OF_THREAD0_STACK_32BIT = 0xbffff000;
// Use the REGISTER_FROM_THREADSTATE to access a register name from the
// breakpad_thread_state_t structure.
@@ -129,6 +112,8 @@ class MinidumpGenerator {
// Helpers
u_int64_t CurrentPCForStack(breakpad_thread_state_data_t state);
+ bool GetThreadState(thread_act_t target_thread, thread_state_t state,
+ mach_msg_type_number_t *count);
bool WriteStackFromStartAddress(mach_vm_address_t start_addr,
MDMemoryDescriptor *stack_location);
bool WriteStack(breakpad_thread_state_data_t state,
@@ -139,11 +124,31 @@ class MinidumpGenerator {
bool WriteCVRecord(MDRawModule *module, int cpu_type,
const char *module_path);
bool WriteModuleStream(unsigned int index, MDRawModule *module);
-
size_t CalculateStackSize(mach_vm_address_t start_addr);
-
int FindExecutableModule();
+ // Per-CPU implementations of these methods
+ bool WriteStackPPC(breakpad_thread_state_data_t state,
+ MDMemoryDescriptor *stack_location);
+ bool WriteContextPPC(breakpad_thread_state_data_t state,
+ MDLocationDescriptor *register_location);
+ u_int64_t CurrentPCForStackPPC(breakpad_thread_state_data_t state);
+ bool WriteStackPPC64(breakpad_thread_state_data_t state,
+ MDMemoryDescriptor *stack_location);
+ bool WriteContextPPC64(breakpad_thread_state_data_t state,
+ MDLocationDescriptor *register_location);
+ u_int64_t CurrentPCForStackPPC64(breakpad_thread_state_data_t state);
+ bool WriteStackX86(breakpad_thread_state_data_t state,
+ MDMemoryDescriptor *stack_location);
+ bool WriteContextX86(breakpad_thread_state_data_t state,
+ MDLocationDescriptor *register_location);
+ u_int64_t CurrentPCForStackX86(breakpad_thread_state_data_t state);
+ bool WriteStackX86_64(breakpad_thread_state_data_t state,
+ MDMemoryDescriptor *stack_location);
+ bool WriteContextX86_64(breakpad_thread_state_data_t state,
+ MDLocationDescriptor *register_location);
+ u_int64_t CurrentPCForStackX86_64(breakpad_thread_state_data_t state);
+
// disallow copy ctor and operator=
explicit MinidumpGenerator(const MinidumpGenerator &);
void operator=(const MinidumpGenerator &);
@@ -158,6 +163,9 @@ class MinidumpGenerator {
mach_port_t exception_thread_;
mach_port_t crashing_task_;
mach_port_t handler_thread_;
+
+ // CPU type of the task being dumped.
+ cpu_type_t cpu_type_;
// System information
static char build_string_[16];
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-05 16:06:53 +0000