Implement basic stack traces on Android and reenable unit tests.

base/third_party/symbolize/symbolize.cc

 // Copyright (c) 2006, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 465 matching lines @@
         (ch >= 'A' && ch <= 'F') || (ch >= 'a' && ch <= 'f')) {
       *hex = (*hex << 4) | (ch < 'A' ? ch - '0' : (ch & 0xF) + 9);
     } else {  // Encountered the first non-hex character.
       break;
     }
   }
   SAFE_ASSERT(p <= end);
   return const_cast<char *>(p);
 }
 
-// Search for the object file (from /proc/self/maps) that contains
-// the specified pc. If found, open this file and return the file handle,
-// and also set start_address to the start address of where this object
-// file is mapped to in memory. Otherwise, return -1.
-static ATTRIBUTE_NOINLINE int
-OpenObjectFileContainingPcAndGetStartAddress(uint64_t pc,
-                                             uint64_t &start_address) {
+bool FindObjectFileNameContainingPcAndGetStartAddress(
+    void* pc, char *out, int out_size, uint64_t *start_address) {
+  uint64_t pc0 = reinterpret_cast<uintptr_t>(pc);

[satorux1, 2013/06/13 01:58:10]

pc0 looks a bit cryptic. maybe:

void *in_pc, ...) {
  uint64_t pc = reinterpret_cast<uintptr_t>(in_pc);

[scherkus (not reviewing), 2013/06/13 02:20:46]

I was following SymbolizeAndDemangle() but agree it's a bit cryptic.

This file is also a bit inconsistent with respect to using void*, uintptr_t, and
uint64_t for addresses but I wanted to keep the diff small.

Let me know if want to see any other changes :)

   int object_fd;
 
   // Open /proc/self/maps.
   int maps_fd;
   NO_INTR(maps_fd = open("/proc/self/maps", O_RDONLY));
   FileDescriptor wrapped_maps_fd(maps_fd);
   if (wrapped_maps_fd.get() < 0) {
-    return -1;
+    return false;
   }
 
   // Iterate over maps and look for the map containing the pc.  Then
   // look into the symbol tables inside.
   char buf[1024];  // Big enough for line of sane /proc/self/maps
   LineReader reader(wrapped_maps_fd.get(), buf, sizeof(buf));
   while (true) {
     const char *cursor;
     const char *eol;
     if (!reader.ReadLine(&cursor, &eol)) {  // EOF or malformed line.
-      return -1;
+      return false;
     }
 
     // Start parsing line in /proc/self/maps.  Here is an example:
     //
     // 08048000-0804c000 r-xp 00000000 08:01 2142121    /bin/cat
     //
     // We want start address (08048000), end address (0804c000), flags
     // (r-xp) and file name (/bin/cat).
 
     // Read start address.
-    cursor = GetHex(cursor, eol, &start_address);
+    cursor = GetHex(cursor, eol, start_address);
     if (cursor == eol || *cursor != '-') {
-      return -1;  // Malformed line.
+      return false;  // Malformed line.
     }
     ++cursor;  // Skip '-'.
 
     // Read end address.
     uint64_t end_address;
     cursor = GetHex(cursor, eol, &end_address);
     if (cursor == eol || *cursor != ' ') {
-      return -1;  // Malformed line.
+      return false;  // Malformed line.
     }
     ++cursor;  // Skip ' '.
 
     // Check start and end addresses.
-    if (!(start_address <= pc && pc < end_address)) {
+    if (!(*start_address <= pc0 && pc0 < end_address)) {
       continue;  // We skip this map.  PC isn't in this map.
     }
 
     // Read flags.  Skip flags until we encounter a space or eol.
     const char * const flags_start = cursor;
     while (cursor < eol && *cursor != ' ') {
       ++cursor;
     }
     // We expect at least four letters for flags (ex. "r-xp").
     if (cursor == eol || cursor < flags_start + 4) {
-      return -1;  // Malformed line.
+      return false;  // Malformed line.
     }
 
     // Check flags.  We are only interested in "r-x" maps.
     if (memcmp(flags_start, "r-x", 3) != 0) {  // Not a "r-x" map.
       continue;  // We skip this map.
     }
     ++cursor;  // Skip ' '.
 
     // Skip to file name.  "cursor" now points to file offset.  We need to
     // skip at least three spaces for file offset, dev, and inode.
     int num_spaces = 0;
     while (cursor < eol) {
       if (*cursor == ' ') {
         ++num_spaces;
       } else if (num_spaces >= 3) {
         // The first non-space character after  skipping three spaces
         // is the beginning of the file name.
         break;
       }
       ++cursor;
     }
     if (cursor == eol) {
-      return -1;  // Malformed line.
+      return false;  // Malformed line.
     }
 
     // Finally, "cursor" now points to file name of our interest.
-    NO_INTR(object_fd = open(cursor, O_RDONLY));
-    if (object_fd < 0) {
-      return -1;
+    if (strlen(cursor) >= out_size) {

[satorux1, 2013/06/13 01:58:10]

maybe slightly easier to read:

if (stlren(cursor) + 1 > out_size) {  // +1 for '\0'

[scherkus (not reviewing), 2013/06/13 02:20:46]

Done + beefed up comment on next line

+      return false;  // Not enough room to write file name.
     }
-    return object_fd;
+
+    strcpy(out, cursor);
+    return true;
   }
 }
 
 // The implementation of our symbolization routine.  If it
 // successfully finds the symbol containing "pc" and obtains the
 // symbol name, returns true and write the symbol name to "out".
 // Otherwise, returns false. If Callback function is installed via
 // InstallSymbolizeCallback(), the function is also called in this function,
 // and "out" is used as its output.
 // To keep stack consumption low, we would like this function to not
 // get inlined.
 static ATTRIBUTE_NOINLINE bool SymbolizeAndDemangle(void *pc, char *out,
                                                     int out_size) {
   uint64_t pc0 = reinterpret_cast<uintptr_t>(pc);
   uint64_t start_address = 0;
 
-  int object_fd = OpenObjectFileContainingPcAndGetStartAddress(pc0,
-                                                               start_address);
-  if (object_fd == -1) {
+  char buf[256];

[scherkus (not reviewing), 2013/06/13 01:27:44]

this additional buffer allocation is a bit crummy

I was thinking we _could_ use |out| and |out_size| as a temporary buffer... but
that would place some hidden requirements on the size of the buffer the caller
provides

[satorux1, 2013/06/13 01:58:10]

sounds reasonable. buf -> file_name?

+  if (!FindObjectFileNameContainingPcAndGetStartAddress(
+          pc, buf, sizeof(buf), &start_address)) {
+    return false;
+  }
+
+  int object_fd;

[satorux1, 2013/06/13 01:58:10]

object_fd = - 1;

to be extra defensive.

[scherkus (not reviewing), 2013/06/13 02:20:46]

Done.

+  NO_INTR(object_fd = open(buf, O_RDONLY));
+  if (object_fd < 0) {
     return false;
   }
   FileDescriptor wrapped_object_fd(object_fd);
   int elf_type = FileGetElfType(wrapped_object_fd.get());
   if (elf_type == -1) {
     return false;
   }
   if (g_symbolize_callback) {
     // Run the call back if it's installed.
     // Note: relocation (and much of the rest of this code) will be
@@ skipping 65 matching lines @@
 
 // TODO: Support other environments.
 bool Symbolize(void *pc, char *out, int out_size) {
   assert(0);
   return false;
 }
 
 _END_GOOGLE_NAMESPACE_
 
 #endif