Initial support for dumping DWARF corresponding to Swift code

src/common/dwarf_cu_to_module.cc

 // Copyright (c) 2010 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 21 matching lines @@
 // Implement the DwarfCUToModule class; see dwarf_cu_to_module.h.
 
 // For <inttypes.h> PRI* macros, before anything else might #include it.
 #ifndef __STDC_FORMAT_MACROS
 #define __STDC_FORMAT_MACROS
 #endif  /* __STDC_FORMAT_MACROS */
 
 #include "common/dwarf_cu_to_module.h"
 
 #include <assert.h>
-#if !defined(__ANDROID__)
-#include <cxxabi.h>
-#endif
 #include <inttypes.h>
 #include <stdint.h>
 #include <stdio.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "common/dwarf_line_to_module.h"
 #include "common/unordered.h"
 
@@ skipping 288 matching lines @@
 }
 
 void DwarfCUToModule::GenericDIEHandler::ProcessAttributeString(
     enum DwarfAttribute attr,
     enum DwarfForm form,
     const string &data) {
   switch (attr) {
     case dwarf2reader::DW_AT_name:
       name_attribute_ = AddStringToPool(data);
       break;
-    case dwarf2reader::DW_AT_MIPS_linkage_name: {
-      char* demangled = NULL;
-      int status = -1;
-#if !defined(__ANDROID__)  // Android NDK doesn't provide abi::__cxa_demangle.
-      demangled = abi::__cxa_demangle(data.c_str(), NULL, NULL, &status);
-#endif
+    case dwarf2reader::DW_AT_MIPS_linkage_name:
+    case dwarf2reader::DW_AT_linkage_name: {
+      string demangled;
+      int status = cu_context_->language->DemangleName(data,
+                                                       &demangled);
       if (status != 0) {
-        cu_context_->reporter->DemangleError(data, status);
-        demangled_name_ = "";
-        break;
-      }
-      if (demangled) {
+        if (status != Language::kDontDemangle) {

[Ted Mielczarek, 2016/09/14 10:20:10]

It's unfortunate that we lose the language context here when we translate to
.sym format. It would be nice to be able to demangle reliably instead of having
to guess. (I suppose it's not that hard to guess, though, given the mangled
symbol prefix.)

[Mark Mentovai, 2016/09/21 17:56:55]

Ted Mielczarek wrote:
In the future, maybe we can spin up a pipe to swift-demangle to get these in
dump_syms instead of relying on post-processing. That’d still only work if
swift-demangle was available, but it’s something…

+          cu_context_->reporter->DemangleError(data, status);
+        }
+        demangled_name_.clear();
+      } else {
         demangled_name_ = AddStringToPool(demangled);
-        free(reinterpret_cast<void*>(demangled));
       }
       break;
     }
     default: break;
   }
 }
 
 string DwarfCUToModule::GenericDIEHandler::ComputeQualifiedName() {
   // Use the demangled name, if one is available. Demangled names are
   // preferable to those inferred from the DWARF structure because they
@@ skipping 377 matching lines @@
 dwarf2reader::DIEHandler *DwarfCUToModule::FindChildHandler(
     uint64 offset,
     enum DwarfTag tag) {
   switch (tag) {
     case dwarf2reader::DW_TAG_subprogram:
       return new FuncHandler(cu_context_.get(), child_context_.get(), offset);
     case dwarf2reader::DW_TAG_namespace:
     case dwarf2reader::DW_TAG_class_type:
     case dwarf2reader::DW_TAG_structure_type:
     case dwarf2reader::DW_TAG_union_type:
+    case dwarf2reader::DW_TAG_module:
       return new NamedScopeHandler(cu_context_.get(), child_context_.get(),
                                    offset);
     default:
       return NULL;
   }
 }
 
 void DwarfCUToModule::SetLanguage(DwarfLanguage language) {
   switch (language) {
     case dwarf2reader::DW_LANG_Java:
       cu_context_->language = Language::Java;
       break;
 
+    case dwarf2reader::DW_LANG_Swift:
+      cu_context_->language = Language::Swift;
+      break;
+
     // DWARF has no generic language code for assembly language; this is
     // what the GNU toolchain uses.
     case dwarf2reader::DW_LANG_Mips_Assembler:
       cu_context_->language = Language::Assembler;
       break;
 
     // C++ covers so many cases that it probably has some way to cope
     // with whatever the other languages throw at us. So make it the
     // default.
     //
@@ skipping 279 matching lines @@
   return dwarf_version >= 2;
 }
 
 bool DwarfCUToModule::StartRootDIE(uint64 offset, enum DwarfTag tag) {
   // We don't deal with partial compilation units (the only other tag
   // likely to be used for root DIE).
   return tag == dwarf2reader::DW_TAG_compile_unit;
 }
 
 } // namespace google_breakpad