Changeset 20773

Timestamp:

09/06/07 14:01:06 (1 year ago)

Author:

patrick

Message:

Implemented stack trace printing on Mac OS X.

Files:

• juggler/trunk/modules/vapor/ChangeLog (modified) (1 diff)
• juggler/trunk/modules/vapor/vpr/SystemBase.cpp (modified) (6 diffs)

juggler/trunk/modules/vapor/ChangeLog

@@ -1 +1 @@
-DATE       AUTHOR   CHANGE
----------- -------- -----------------------------------------------------------
+2007-09-06 patrick  Implemented stack trace printing on Mac OS X.
-2007-09-04 patrick  Set VPR_BASE_DIR automatically on all platforms.
-2007-08-21 patrick  Removed support for SPROC.

juggler/trunk/modules/vapor/vpr/SystemBase.cpp

@@ -41 +41 @@
-#  include <execinfo.h>
-#  include <sstream>
+#elif defined(VPR_OS_Darwin)
+#  include <iomanip>
+#  include <sstream>
+#  include <vector>
+
+extern "C"
+{
+
+#  include <mach-o/dyld.h>
+#  include <mach-o/loader.h>
+#  include <mach-o/nlist.h>
+#  include <mach-o/stab.h>
+
+}
+
-#elif defined(VPR_OS_Windows)
-#  if _MSC_VER >= 1400
@@ -80 +95 @@
-namespace
-{
+
-#if defined(VPR_OS_Windows) && defined(VPR_DEBUG)
-#if _MSC_VER >= 1400
@@ -230 +246 @@
-      {
-//         std::cerr << "vpr::SystemBase::demangleTraceString: mangled_name "
-'
+"
-//                   << "rules.\n";
-      }
@@ -248 +264 @@
-#endif
-}
+
+#if defined(VPR_OS_Darwin)
+struct CrawlFrame
+{
+   unsigned int pc;
+   size_t frame;
+   std::string name;
+   unsigned int offset;
+};
+
+const mach_header* findOwnerOfPC(const unsigned int pc)
+{
+   const unsigned int count = _dyld_image_count();
+   for ( unsigned int index = 0; index < count; ++index )
+   {
+      const mach_header* header = _dyld_get_image_header(index);
+      const unsigned int offset = _dyld_get_image_vmaddr_slide(index);
+      const load_command* cmd =
+         reinterpret_cast<const load_command*>(
+            reinterpret_cast<const char*>(header) + sizeof(mach_header)
+         );
+
+      for ( unsigned int cmdex = 0;
+            cmdex < header->ncmds;
+            ++cmdex, cmd = reinterpret_cast<const load_command*>(reinterpret_cast<const char*>(cmd) + cmd->cmdsize))
+      {
+         switch (cmd->cmd)
+         {
+            case LC_SEGMENT:
+               {
+                  const segment_command* seg =
+                     reinterpret_cast<const segment_command*>(cmd);
+                  if ( pc >= (seg->vmaddr + offset) &&
+                       pc < (seg->vmaddr + offset + seg->vmsize) )
+                  {
+                     return header;
+                  }
+               }
+               break;
+         }
+      }
+   }
+
+   return NULL;
+}
+
+std::string getFunctionName(const unsigned int pc, unsigned int* offset)
+{
+   const mach_header* header = findOwnerOfPC(pc);
+   if ( header != NULL )
+   {
+      const segment_command* seg_linkedit(NULL);
+      const segment_command* seg_text(NULL);
+      const symtab_command* symtab(NULL);
+
+      const load_command* cmd =
+         reinterpret_cast<const load_command*>(
+            reinterpret_cast<const char*>(header) + sizeof(mach_header)
+         );
+
+      for ( unsigned int index = 0;
+            index < header->ncmds;
+            ++index, cmd = reinterpret_cast<const load_command*>(reinterpret_cast<const char*>(cmd) + cmd->cmdsize) )
+      {
+         switch (cmd->cmd)
+         {
+            case LC_SEGMENT:
+               if ( ! strncmp(reinterpret_cast<const segment_command*>(cmd)->segname, SEG_TEXT, 16) )
+               {
+                  seg_text = reinterpret_cast<const segment_command*>(cmd);
+               }
+               else if ( ! strncmp(reinterpret_cast<const segment_command*>(cmd)->segname, SEG_LINKEDIT, 16) )
+               {
+                  seg_linkedit = reinterpret_cast<const segment_command*>(cmd);
+               }
+               break;
+            
+            case LC_SYMTAB:
+               symtab = reinterpret_cast<const symtab_command*>(cmd);
+               break;
+         }
+      }
+      
+      if ( seg_text == NULL || seg_linkedit == NULL || symtab == NULL )
+      {
+         *offset = 0;
+         return NULL;
+      }
+
+      size_t vm_slide = reinterpret_cast<size_t>(header) - seg_text->vmaddr;
+      const size_t file_slide = (seg_linkedit->vmaddr - seg_text->vmaddr) -
+                                   seg_linkedit->fileoff;
+      struct nlist* symbase =
+         reinterpret_cast<struct nlist*>(
+            reinterpret_cast<size_t>(header) + symtab->symoff + file_slide
+         );
+      char* strings =
+         reinterpret_cast<char*>(
+            reinterpret_cast<size_t>(header) + symtab->stroff + file_slide
+         );
+      
+      // Look for a global symbol.
+      unsigned int index;
+      struct nlist* sym(NULL);
+      for ( index = 0, sym = symbase; index < symtab->nsyms; ++index, ++sym )
+      {
+         if ( sym->n_type != N_FUN )
+         {
+            continue;
+         }
+
+         char* name = sym->n_un.n_strx ? (strings + sym->n_un.n_strx) : NULL;
+         const unsigned int base = sym->n_value + vm_slide;
+
+         for ( index += 1, sym += 1; index < symtab->nsyms; ++index, ++sym )
+         {
+            if ( sym->n_type == N_FUN )
+            {
+               break;
+            }
+         }
+
+         if ( pc >= base  &&  pc <= (base + sym->n_value) && name != NULL &&
+              std::strlen(name) > 0 )
+         {
+            *offset = pc - base;
+            return std::string(name);
+         }
+      }
+
+      // Look for a reasonably close private symbol.
+      char* name;
+      unsigned int base;
+      for ( name = NULL, base = 0xFFFFFFFF, index = 0, sym = symbase;
+            index < symtab->nsyms;
+            ++index, ++sym )
+      {
+         if ( (sym->n_type & 0x0E) != 0x0E )
+         {
+            continue;
+         }
+
+         if ( (sym->n_value + vm_slide) > pc )
+         {
+            continue;
+         }
+
+         if ( base != 0xFFFFFFFF &&
+              (pc - (sym->n_value + vm_slide)) >= (pc - base) )
+         {
+            continue;
+         }
+
+         name = sym->n_un.n_strx ? (strings + sym->n_un.n_strx) : NULL;
+         base = sym->n_value + vm_slide;
+      }
+
+      *offset = pc - base;
+      return (name != NULL) ? std::string(name) : std::string();
+   }
+   
+   *offset = 0;
+   return std::string();
+}
+#endif  /* VPR_OS_Darwin */
-
-}
@@ -263 +444 @@
-   char** strings;
-
-   pid_t cur_pid = getpid();
-   size = backtrace(trace_syms, 100);
-   strings = backtrace_symbols(trace_syms, size);
-
-   std::ostringstream trace_stream;
-: thread: " << cur_pid
+ for process: " << getpid()
-
-   for (size_t i = 0; i < size; ++i)
@@ -277 +457 @@
-
-   free(strings);
+
+   ret_stack = trace_stream.str();
+#elif defined(VPR_OS_Darwin)
+#if defined(__ppc__) || defined(__ppc64__)
+   struct StackFrame
+   {
+      unsigned int savedSP;
+      unsigned int savedCR;
+      unsigned int savedLR;
+      unsigned int reserved[2];
+      unsigned int savedRTOC;
+   };
+#elif defined(__i386__)
+   struct StackFrame
+   {
+      unsigned int savedSP;
+      unsigned int savedLR;
+   };
+#else
+#error Unknown platform
+#endif
+
+   std::ostringstream trace_stream;
+   trace_stream << "Stack trace for process: " << getpid() << std::endl;
+
+   std::vector<CrawlFrame> stack;
+   StackFrame* frame(NULL);
+
+#if defined(__ppc__) || defined(__ppc64__)
+   frame = *(StackFrame**) __builtin_frame_address(0);
+#elif defined(__i386__)
+   frame = (StackFrame*) __builtin_frame_address(0);
+#endif
+
+   for ( ; frame != NULL; frame = (StackFrame*) frame->savedSP)
+   {
+      if ( (frame->savedLR & ~3) == 0 || (~(frame->savedLR) & ~3) == 0 )
+      {
+         break;
+      }
+
+      CrawlFrame cur_frame;
+      cur_frame.pc    = frame->savedLR;
+      cur_frame.frame = reinterpret_cast<size_t>(frame);
+      cur_frame.name  = getFunctionName(frame->savedLR, &cur_frame.offset);
+
+      if ( cur_frame.pc != 0 )
+      {
+         cur_frame.pc -= 4;
+      }
+
+      stack.push_back(cur_frame);
+   }
+
+   typedef std::vector<CrawlFrame>::reverse_iterator iter_type;
+   for ( iter_type i = stack.rbegin(); i != stack.rend(); ++i )
+   {
+      std::string func_name("(unknown)");
+
+      if ( ! (*i).name.empty() )
+      {
+         typedef std::string::size_type size_type;
+         const size_type name_len((*i).name.size());
+         for ( size_type j = 0; j < name_len; ++j )
+         {
+            bool objc(false);
+            if ( j == 1  &&  (*i).name[j] == '[' )
+            {
+               objc = true;
+            }
+
+            if ( objc && (*i).name[j] == ']' )
+            {
+               objc = false;
+            }
+
+            if ( ! objc && (*i).name[j] == ':' )
+            {
+               break;
+            }
+         }
+
+         std::ostringstream func_stream;
+         func_stream << (*i).name << "+" << std::hex << (*i).offset;
+         func_name = func_stream.str();
+      }
+
+      const char fill_char(trace_stream.fill());
+      const std::ios::fmtflags fmt_flags(trace_stream.flags());
+      trace_stream.fill('0');
+      trace_stream.setf(std::ios::uppercase);
+      trace_stream.setf(std::ios::hex | std::ios::right,
+                        std::ios::adjustfield | std::ios::basefield);
+      trace_stream << "  " << std::setw(sizeof(void*) * 2) << (*i).frame
+                   << "  " << std::setw(sizeof(void*) * 2) << (*i).pc;
+      trace_stream.flags(fmt_flags);
+      trace_stream.fill(fill_char);
+      trace_stream << "  " << func_name << std::endl;
+   }
-
-   ret_stack = trace_stream.str();