Bug 1194424 - Part 0: Extend the core dump protobuf message format to accomodate allocation stacks; r=sfink
authorNick Fitzgerald <fitzgen@gmail.com>
Mon, 24 Aug 2015 09:29:44 -0700
changeset 259059 3eaacefb3f2e2efedde1a489fe7500af0459e598
parent 259058 c6d9ac33301f215d51e0605b7e7e1c3e2e36e0f8
child 259060 4a0bbaeb86b2f940ead6388c1cb7256dbda30370
push id29268
push userryanvm@gmail.com
push dateTue, 25 Aug 2015 00:37:23 +0000
treeherdermozilla-central@08015770c9d6 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewerssfink
bugs1194424
milestone43.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1194424 - Part 0: Extend the core dump protobuf message format to accomodate allocation stacks; r=sfink
toolkit/devtools/server/CoreDump.pb.cc
toolkit/devtools/server/CoreDump.pb.h
toolkit/devtools/server/CoreDump.proto
--- a/toolkit/devtools/server/CoreDump.pb.cc
+++ b/toolkit/devtools/server/CoreDump.pb.cc
@@ -20,16 +20,26 @@ namespace mozilla {
 namespace devtools {
 namespace protobuf {
 
 namespace {
 
 const ::google::protobuf::Descriptor* Metadata_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   Metadata_reflection_ = NULL;
+const ::google::protobuf::Descriptor* StackFrame_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StackFrame_reflection_ = NULL;
+struct StackFrameOneofInstance {
+  const ::mozilla::devtools::protobuf::StackFrame_Data* data_;
+  ::google::protobuf::uint64 ref_;
+}* StackFrame_default_oneof_instance_ = NULL;
+const ::google::protobuf::Descriptor* StackFrame_Data_descriptor_ = NULL;
+const ::google::protobuf::internal::GeneratedMessageReflection*
+  StackFrame_Data_reflection_ = NULL;
 const ::google::protobuf::Descriptor* Node_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   Node_reflection_ = NULL;
 const ::google::protobuf::Descriptor* Edge_descriptor_ = NULL;
 const ::google::protobuf::internal::GeneratedMessageReflection*
   Edge_reflection_ = NULL;
 
 }  // namespace
@@ -51,35 +61,77 @@ void protobuf_AssignDesc_CoreDump_2eprot
       Metadata::default_instance_,
       Metadata_offsets_,
       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Metadata, _has_bits_[0]),
       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Metadata, _unknown_fields_),
       -1,
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(Metadata));
-  Node_descriptor_ = file->message_type(1);
-  static const int Node_offsets_[4] = {
+  StackFrame_descriptor_ = file->message_type(1);
+  static const int StackFrame_offsets_[3] = {
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(StackFrame_default_oneof_instance_, data_),
+    PROTO2_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET(StackFrame_default_oneof_instance_, ref_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, StackFrameType_),
+  };
+  StackFrame_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StackFrame_descriptor_,
+      StackFrame::default_instance_,
+      StackFrame_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, _unknown_fields_),
+      -1,
+      StackFrame_default_oneof_instance_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame, _oneof_case_[0]),
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StackFrame));
+  StackFrame_Data_descriptor_ = StackFrame_descriptor_->nested_type(0);
+  static const int StackFrame_Data_offsets_[8] = {
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame_Data, id_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame_Data, parent_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame_Data, line_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame_Data, column_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame_Data, source_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame_Data, functiondisplayname_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame_Data, issystem_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame_Data, isselfhosted_),
+  };
+  StackFrame_Data_reflection_ =
+    new ::google::protobuf::internal::GeneratedMessageReflection(
+      StackFrame_Data_descriptor_,
+      StackFrame_Data::default_instance_,
+      StackFrame_Data_offsets_,
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame_Data, _has_bits_[0]),
+      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(StackFrame_Data, _unknown_fields_),
+      -1,
+      ::google::protobuf::DescriptorPool::generated_pool(),
+      ::google::protobuf::MessageFactory::generated_factory(),
+      sizeof(StackFrame_Data));
+  Node_descriptor_ = file->message_type(2);
+  static const int Node_offsets_[5] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, id_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, typename__),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, size_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, edges_),
+    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, allocationstack_),
   };
   Node_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
       Node_descriptor_,
       Node::default_instance_,
       Node_offsets_,
       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, _has_bits_[0]),
       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Node, _unknown_fields_),
       -1,
       ::google::protobuf::DescriptorPool::generated_pool(),
       ::google::protobuf::MessageFactory::generated_factory(),
       sizeof(Node));
-  Edge_descriptor_ = file->message_type(2);
+  Edge_descriptor_ = file->message_type(3);
   static const int Edge_offsets_[2] = {
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Edge, referent_),
     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Edge, name_),
   };
   Edge_reflection_ =
     new ::google::protobuf::internal::GeneratedMessageReflection(
       Edge_descriptor_,
       Edge::default_instance_,
@@ -100,51 +152,74 @@ inline void protobuf_AssignDescriptorsOn
                  &protobuf_AssignDesc_CoreDump_2eproto);
 }
 
 void protobuf_RegisterTypes(const ::std::string&) {
   protobuf_AssignDescriptorsOnce();
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     Metadata_descriptor_, &Metadata::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StackFrame_descriptor_, &StackFrame::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
+    StackFrame_Data_descriptor_, &StackFrame_Data::default_instance());
+  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     Node_descriptor_, &Node::default_instance());
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
     Edge_descriptor_, &Edge::default_instance());
 }
 
 }  // namespace
 
 void protobuf_ShutdownFile_CoreDump_2eproto() {
   delete Metadata::default_instance_;
   delete Metadata_reflection_;
+  delete StackFrame::default_instance_;
+  delete StackFrame_default_oneof_instance_;
+  delete StackFrame_reflection_;
+  delete StackFrame_Data::default_instance_;
+  delete StackFrame_Data_reflection_;
   delete Node::default_instance_;
   delete Node_reflection_;
   delete Edge::default_instance_;
   delete Edge_reflection_;
 }
 
 void protobuf_AddDesc_CoreDump_2eproto() {
   static bool already_here = false;
   if (already_here) return;
   already_here = true;
   GOOGLE_PROTOBUF_VERIFY_VERSION;
 
   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
     "\n\016CoreDump.proto\022\031mozilla.devtools.proto"
-    "buf\"\035\n\010Metadata\022\021\n\ttimeStamp\030\001 \001(\004\"b\n\004No"
-    "de\022\n\n\002id\030\001 \001(\004\022\020\n\010typeName\030\002 \001(\014\022\014\n\004size"
-    "\030\003 \001(\004\022.\n\005edges\030\004 \003(\0132\037.mozilla.devtools"
-    ".protobuf.Edge\"&\n\004Edge\022\020\n\010referent\030\001 \001(\004"
-    "\022\014\n\004name\030\002 \001(\014", 214);
+    "buf\"\035\n\010Metadata\022\021\n\ttimeStamp\030\001 \001(\004\"\250\002\n\nS"
+    "tackFrame\022:\n\004data\030\001 \001(\0132*.mozilla.devtoo"
+    "ls.protobuf.StackFrame.DataH\000\022\r\n\003ref\030\002 \001"
+    "(\004H\000\032\274\001\n\004Data\022\n\n\002id\030\001 \001(\004\0225\n\006parent\030\002 \001("
+    "\0132%.mozilla.devtools.protobuf.StackFrame"
+    "\022\014\n\004line\030\003 \001(\r\022\016\n\006column\030\004 \001(\r\022\016\n\006source"
+    "\030\005 \001(\014\022\033\n\023functionDisplayName\030\006 \001(\014\022\020\n\010i"
+    "sSystem\030\007 \001(\010\022\024\n\014isSelfHosted\030\010 \001(\010B\020\n\016S"
+    "tackFrameType\"\242\001\n\004Node\022\n\n\002id\030\001 \001(\004\022\020\n\010ty"
+    "peName\030\002 \001(\014\022\014\n\004size\030\003 \001(\004\022.\n\005edges\030\004 \003("
+    "\0132\037.mozilla.devtools.protobuf.Edge\022>\n\017al"
+    "locationStack\030\005 \001(\0132%.mozilla.devtools.p"
+    "rotobuf.StackFrame\"&\n\004Edge\022\020\n\010referent\030\001"
+    " \001(\004\022\014\n\004name\030\002 \001(\014", 578);
   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
     "CoreDump.proto", &protobuf_RegisterTypes);
   Metadata::default_instance_ = new Metadata();
+  StackFrame::default_instance_ = new StackFrame();
+  StackFrame_default_oneof_instance_ = new StackFrameOneofInstance;
+  StackFrame_Data::default_instance_ = new StackFrame_Data();
   Node::default_instance_ = new Node();
   Edge::default_instance_ = new Edge();
   Metadata::default_instance_->InitAsDefaultInstance();
+  StackFrame::default_instance_->InitAsDefaultInstance();
+  StackFrame_Data::default_instance_->InitAsDefaultInstance();
   Node::default_instance_->InitAsDefaultInstance();
   Edge::default_instance_->InitAsDefaultInstance();
   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_CoreDump_2eproto);
 }
 
 // Force AddDescriptors() to be called at static initialization time.
 struct StaticDescriptorInitializer_CoreDump_2eproto {
   StaticDescriptorInitializer_CoreDump_2eproto() {
@@ -372,57 +447,880 @@ void Metadata::Swap(Metadata* other) {
   metadata.reflection = Metadata_reflection_;
   return metadata;
 }
 
 
 // ===================================================================
 
 #ifndef _MSC_VER
+const int StackFrame_Data::kIdFieldNumber;
+const int StackFrame_Data::kParentFieldNumber;
+const int StackFrame_Data::kLineFieldNumber;
+const int StackFrame_Data::kColumnFieldNumber;
+const int StackFrame_Data::kSourceFieldNumber;
+const int StackFrame_Data::kFunctionDisplayNameFieldNumber;
+const int StackFrame_Data::kIsSystemFieldNumber;
+const int StackFrame_Data::kIsSelfHostedFieldNumber;
+#endif  // !_MSC_VER
+
+StackFrame_Data::StackFrame_Data()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.StackFrame.Data)
+}
+
+void StackFrame_Data::InitAsDefaultInstance() {
+  parent_ = const_cast< ::mozilla::devtools::protobuf::StackFrame*>(&::mozilla::devtools::protobuf::StackFrame::default_instance());
+}
+
+StackFrame_Data::StackFrame_Data(const StackFrame_Data& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.StackFrame.Data)
+}
+
+void StackFrame_Data::SharedCtor() {
+  ::google::protobuf::internal::GetEmptyString();
+  _cached_size_ = 0;
+  id_ = GOOGLE_ULONGLONG(0);
+  parent_ = NULL;
+  line_ = 0u;
+  column_ = 0u;
+  source_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  functiondisplayname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  issystem_ = false;
+  isselfhosted_ = false;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+}
+
+StackFrame_Data::~StackFrame_Data() {
+  // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.StackFrame.Data)
+  SharedDtor();
+}
+
+void StackFrame_Data::SharedDtor() {
+  if (source_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete source_;
+  }
+  if (functiondisplayname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete functiondisplayname_;
+  }
+  if (this != default_instance_) {
+    delete parent_;
+  }
+}
+
+void StackFrame_Data::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StackFrame_Data::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StackFrame_Data_descriptor_;
+}
+
+const StackFrame_Data& StackFrame_Data::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_CoreDump_2eproto();
+  return *default_instance_;
+}
+
+StackFrame_Data* StackFrame_Data::default_instance_ = NULL;
+
+StackFrame_Data* StackFrame_Data::New() const {
+  return new StackFrame_Data;
+}
+
+void StackFrame_Data::Clear() {
+#define OFFSET_OF_FIELD_(f) (reinterpret_cast<char*>(      \
+  &reinterpret_cast<StackFrame_Data*>(16)->f) - \
+   reinterpret_cast<char*>(16))
+
+#define ZR_(first, last) do {                              \
+    size_t f = OFFSET_OF_FIELD_(first);                    \
+    size_t n = OFFSET_OF_FIELD_(last) - f + sizeof(last);  \
+    ::memset(&first, 0, n);                                \
+  } while (0)
+
+  if (_has_bits_[0 / 32] & 255) {
+    ZR_(line_, column_);
+    ZR_(issystem_, isselfhosted_);
+    id_ = GOOGLE_ULONGLONG(0);
+    if (has_parent()) {
+      if (parent_ != NULL) parent_->::mozilla::devtools::protobuf::StackFrame::Clear();
+    }
+    if (has_source()) {
+      if (source_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        source_->clear();
+      }
+    }
+    if (has_functiondisplayname()) {
+      if (functiondisplayname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+        functiondisplayname_->clear();
+      }
+    }
+  }
+
+#undef OFFSET_OF_FIELD_
+#undef ZR_
+
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StackFrame_Data::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:mozilla.devtools.protobuf.StackFrame.Data)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional uint64 id = 1;
+      case 1: {
+        if (tag == 8) {
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &id_)));
+          set_has_id();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(18)) goto parse_parent;
+        break;
+      }
+
+      // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
+      case 2: {
+        if (tag == 18) {
+         parse_parent:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_parent()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(24)) goto parse_line;
+        break;
+      }
+
+      // optional uint32 line = 3;
+      case 3: {
+        if (tag == 24) {
+         parse_line:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &line_)));
+          set_has_line();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(32)) goto parse_column;
+        break;
+      }
+
+      // optional uint32 column = 4;
+      case 4: {
+        if (tag == 32) {
+         parse_column:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
+                 input, &column_)));
+          set_has_column();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(42)) goto parse_source;
+        break;
+      }
+
+      // optional bytes source = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_source:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_source()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(50)) goto parse_functionDisplayName;
+        break;
+      }
+
+      // optional bytes functionDisplayName = 6;
+      case 6: {
+        if (tag == 50) {
+         parse_functionDisplayName:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
+                input, this->mutable_functiondisplayname()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(56)) goto parse_isSystem;
+        break;
+      }
+
+      // optional bool isSystem = 7;
+      case 7: {
+        if (tag == 56) {
+         parse_isSystem:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &issystem_)));
+          set_has_issystem();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(64)) goto parse_isSelfHosted;
+        break;
+      }
+
+      // optional bool isSelfHosted = 8;
+      case 8: {
+        if (tag == 64) {
+         parse_isSelfHosted:
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
+                 input, &isselfhosted_)));
+          set_has_isselfhosted();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.devtools.protobuf.StackFrame.Data)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.devtools.protobuf.StackFrame.Data)
+  return false;
+#undef DO_
+}
+
+void StackFrame_Data::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.devtools.protobuf.StackFrame.Data)
+  // optional uint64 id = 1;
+  if (has_id()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(1, this->id(), output);
+  }
+
+  // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
+  if (has_parent()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      2, this->parent(), output);
+  }
+
+  // optional uint32 line = 3;
+  if (has_line()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->line(), output);
+  }
+
+  // optional uint32 column = 4;
+  if (has_column()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->column(), output);
+  }
+
+  // optional bytes source = 5;
+  if (has_source()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      5, this->source(), output);
+  }
+
+  // optional bytes functionDisplayName = 6;
+  if (has_functiondisplayname()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
+      6, this->functiondisplayname(), output);
+  }
+
+  // optional bool isSystem = 7;
+  if (has_issystem()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(7, this->issystem(), output);
+  }
+
+  // optional bool isSelfHosted = 8;
+  if (has_isselfhosted()) {
+    ::google::protobuf::internal::WireFormatLite::WriteBool(8, this->isselfhosted(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:mozilla.devtools.protobuf.StackFrame.Data)
+}
+
+::google::protobuf::uint8* StackFrame_Data::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:mozilla.devtools.protobuf.StackFrame.Data)
+  // optional uint64 id = 1;
+  if (has_id()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(1, this->id(), target);
+  }
+
+  // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
+  if (has_parent()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        2, this->parent(), target);
+  }
+
+  // optional uint32 line = 3;
+  if (has_line()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->line(), target);
+  }
+
+  // optional uint32 column = 4;
+  if (has_column()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->column(), target);
+  }
+
+  // optional bytes source = 5;
+  if (has_source()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        5, this->source(), target);
+  }
+
+  // optional bytes functionDisplayName = 6;
+  if (has_functiondisplayname()) {
+    target =
+      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
+        6, this->functiondisplayname(), target);
+  }
+
+  // optional bool isSystem = 7;
+  if (has_issystem()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(7, this->issystem(), target);
+  }
+
+  // optional bool isSelfHosted = 8;
+  if (has_isselfhosted()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(8, this->isselfhosted(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:mozilla.devtools.protobuf.StackFrame.Data)
+  return target;
+}
+
+int StackFrame_Data::ByteSize() const {
+  int total_size = 0;
+
+  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    // optional uint64 id = 1;
+    if (has_id()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->id());
+    }
+
+    // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
+    if (has_parent()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->parent());
+    }
+
+    // optional uint32 line = 3;
+    if (has_line()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->line());
+    }
+
+    // optional uint32 column = 4;
+    if (has_column()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt32Size(
+          this->column());
+    }
+
+    // optional bytes source = 5;
+    if (has_source()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->source());
+    }
+
+    // optional bytes functionDisplayName = 6;
+    if (has_functiondisplayname()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::BytesSize(
+          this->functiondisplayname());
+    }
+
+    // optional bool isSystem = 7;
+    if (has_issystem()) {
+      total_size += 1 + 1;
+    }
+
+    // optional bool isSelfHosted = 8;
+    if (has_isselfhosted()) {
+      total_size += 1 + 1;
+    }
+
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StackFrame_Data::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StackFrame_Data* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StackFrame_Data*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StackFrame_Data::MergeFrom(const StackFrame_Data& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
+    if (from.has_id()) {
+      set_id(from.id());
+    }
+    if (from.has_parent()) {
+      mutable_parent()->::mozilla::devtools::protobuf::StackFrame::MergeFrom(from.parent());
+    }
+    if (from.has_line()) {
+      set_line(from.line());
+    }
+    if (from.has_column()) {
+      set_column(from.column());
+    }
+    if (from.has_source()) {
+      set_source(from.source());
+    }
+    if (from.has_functiondisplayname()) {
+      set_functiondisplayname(from.functiondisplayname());
+    }
+    if (from.has_issystem()) {
+      set_issystem(from.issystem());
+    }
+    if (from.has_isselfhosted()) {
+      set_isselfhosted(from.isselfhosted());
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StackFrame_Data::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StackFrame_Data::CopyFrom(const StackFrame_Data& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StackFrame_Data::IsInitialized() const {
+
+  return true;
+}
+
+void StackFrame_Data::Swap(StackFrame_Data* other) {
+  if (other != this) {
+    std::swap(id_, other->id_);
+    std::swap(parent_, other->parent_);
+    std::swap(line_, other->line_);
+    std::swap(column_, other->column_);
+    std::swap(source_, other->source_);
+    std::swap(functiondisplayname_, other->functiondisplayname_);
+    std::swap(issystem_, other->issystem_);
+    std::swap(isselfhosted_, other->isselfhosted_);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StackFrame_Data::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StackFrame_Data_descriptor_;
+  metadata.reflection = StackFrame_Data_reflection_;
+  return metadata;
+}
+
+
+// -------------------------------------------------------------------
+
+#ifndef _MSC_VER
+const int StackFrame::kDataFieldNumber;
+const int StackFrame::kRefFieldNumber;
+#endif  // !_MSC_VER
+
+StackFrame::StackFrame()
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.StackFrame)
+}
+
+void StackFrame::InitAsDefaultInstance() {
+  StackFrame_default_oneof_instance_->data_ = const_cast< ::mozilla::devtools::protobuf::StackFrame_Data*>(&::mozilla::devtools::protobuf::StackFrame_Data::default_instance());
+  StackFrame_default_oneof_instance_->ref_ = GOOGLE_ULONGLONG(0);
+}
+
+StackFrame::StackFrame(const StackFrame& from)
+  : ::google::protobuf::Message() {
+  SharedCtor();
+  MergeFrom(from);
+  // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.StackFrame)
+}
+
+void StackFrame::SharedCtor() {
+  _cached_size_ = 0;
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  clear_has_StackFrameType();
+}
+
+StackFrame::~StackFrame() {
+  // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.StackFrame)
+  SharedDtor();
+}
+
+void StackFrame::SharedDtor() {
+  if (has_StackFrameType()) {
+    clear_StackFrameType();
+  }
+  if (this != default_instance_) {
+  }
+}
+
+void StackFrame::SetCachedSize(int size) const {
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+}
+const ::google::protobuf::Descriptor* StackFrame::descriptor() {
+  protobuf_AssignDescriptorsOnce();
+  return StackFrame_descriptor_;
+}
+
+const StackFrame& StackFrame::default_instance() {
+  if (default_instance_ == NULL) protobuf_AddDesc_CoreDump_2eproto();
+  return *default_instance_;
+}
+
+StackFrame* StackFrame::default_instance_ = NULL;
+
+StackFrame* StackFrame::New() const {
+  return new StackFrame;
+}
+
+void StackFrame::clear_StackFrameType() {
+  switch(StackFrameType_case()) {
+    case kData: {
+      delete StackFrameType_.data_;
+      break;
+    }
+    case kRef: {
+      // No need to clear
+      break;
+    }
+    case STACKFRAMETYPE_NOT_SET: {
+      break;
+    }
+  }
+  _oneof_case_[0] = STACKFRAMETYPE_NOT_SET;
+}
+
+
+void StackFrame::Clear() {
+  clear_StackFrameType();
+  ::memset(_has_bits_, 0, sizeof(_has_bits_));
+  mutable_unknown_fields()->Clear();
+}
+
+bool StackFrame::MergePartialFromCodedStream(
+    ::google::protobuf::io::CodedInputStream* input) {
+#define DO_(EXPRESSION) if (!(EXPRESSION)) goto failure
+  ::google::protobuf::uint32 tag;
+  // @@protoc_insertion_point(parse_start:mozilla.devtools.protobuf.StackFrame)
+  for (;;) {
+    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
+    tag = p.first;
+    if (!p.second) goto handle_unusual;
+    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
+      // optional .mozilla.devtools.protobuf.StackFrame.Data data = 1;
+      case 1: {
+        if (tag == 10) {
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_data()));
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectTag(16)) goto parse_ref;
+        break;
+      }
+
+      // optional uint64 ref = 2;
+      case 2: {
+        if (tag == 16) {
+         parse_ref:
+          clear_StackFrameType();
+          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
+                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
+                 input, &StackFrameType_.ref_)));
+          set_has_ref();
+        } else {
+          goto handle_unusual;
+        }
+        if (input->ExpectAtEnd()) goto success;
+        break;
+      }
+
+      default: {
+      handle_unusual:
+        if (tag == 0 ||
+            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
+            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
+          goto success;
+        }
+        DO_(::google::protobuf::internal::WireFormat::SkipField(
+              input, tag, mutable_unknown_fields()));
+        break;
+      }
+    }
+  }
+success:
+  // @@protoc_insertion_point(parse_success:mozilla.devtools.protobuf.StackFrame)
+  return true;
+failure:
+  // @@protoc_insertion_point(parse_failure:mozilla.devtools.protobuf.StackFrame)
+  return false;
+#undef DO_
+}
+
+void StackFrame::SerializeWithCachedSizes(
+    ::google::protobuf::io::CodedOutputStream* output) const {
+  // @@protoc_insertion_point(serialize_start:mozilla.devtools.protobuf.StackFrame)
+  // optional .mozilla.devtools.protobuf.StackFrame.Data data = 1;
+  if (has_data()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      1, this->data(), output);
+  }
+
+  // optional uint64 ref = 2;
+  if (has_ref()) {
+    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->ref(), output);
+  }
+
+  if (!unknown_fields().empty()) {
+    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
+        unknown_fields(), output);
+  }
+  // @@protoc_insertion_point(serialize_end:mozilla.devtools.protobuf.StackFrame)
+}
+
+::google::protobuf::uint8* StackFrame::SerializeWithCachedSizesToArray(
+    ::google::protobuf::uint8* target) const {
+  // @@protoc_insertion_point(serialize_to_array_start:mozilla.devtools.protobuf.StackFrame)
+  // optional .mozilla.devtools.protobuf.StackFrame.Data data = 1;
+  if (has_data()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        1, this->data(), target);
+  }
+
+  // optional uint64 ref = 2;
+  if (has_ref()) {
+    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->ref(), target);
+  }
+
+  if (!unknown_fields().empty()) {
+    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
+        unknown_fields(), target);
+  }
+  // @@protoc_insertion_point(serialize_to_array_end:mozilla.devtools.protobuf.StackFrame)
+  return target;
+}
+
+int StackFrame::ByteSize() const {
+  int total_size = 0;
+
+  switch (StackFrameType_case()) {
+    // optional .mozilla.devtools.protobuf.StackFrame.Data data = 1;
+    case kData: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->data());
+      break;
+    }
+    // optional uint64 ref = 2;
+    case kRef: {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::UInt64Size(
+          this->ref());
+      break;
+    }
+    case STACKFRAMETYPE_NOT_SET: {
+      break;
+    }
+  }
+  if (!unknown_fields().empty()) {
+    total_size +=
+      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
+        unknown_fields());
+  }
+  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
+  _cached_size_ = total_size;
+  GOOGLE_SAFE_CONCURRENT_WRITES_END();
+  return total_size;
+}
+
+void StackFrame::MergeFrom(const ::google::protobuf::Message& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  const StackFrame* source =
+    ::google::protobuf::internal::dynamic_cast_if_available<const StackFrame*>(
+      &from);
+  if (source == NULL) {
+    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
+  } else {
+    MergeFrom(*source);
+  }
+}
+
+void StackFrame::MergeFrom(const StackFrame& from) {
+  GOOGLE_CHECK_NE(&from, this);
+  switch (from.StackFrameType_case()) {
+    case kData: {
+      mutable_data()->::mozilla::devtools::protobuf::StackFrame_Data::MergeFrom(from.data());
+      break;
+    }
+    case kRef: {
+      set_ref(from.ref());
+      break;
+    }
+    case STACKFRAMETYPE_NOT_SET: {
+      break;
+    }
+  }
+  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
+}
+
+void StackFrame::CopyFrom(const ::google::protobuf::Message& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+void StackFrame::CopyFrom(const StackFrame& from) {
+  if (&from == this) return;
+  Clear();
+  MergeFrom(from);
+}
+
+bool StackFrame::IsInitialized() const {
+
+  return true;
+}
+
+void StackFrame::Swap(StackFrame* other) {
+  if (other != this) {
+    std::swap(StackFrameType_, other->StackFrameType_);
+    std::swap(_oneof_case_[0], other->_oneof_case_[0]);
+    std::swap(_has_bits_[0], other->_has_bits_[0]);
+    _unknown_fields_.Swap(&other->_unknown_fields_);
+    std::swap(_cached_size_, other->_cached_size_);
+  }
+}
+
+::google::protobuf::Metadata StackFrame::GetMetadata() const {
+  protobuf_AssignDescriptorsOnce();
+  ::google::protobuf::Metadata metadata;
+  metadata.descriptor = StackFrame_descriptor_;
+  metadata.reflection = StackFrame_reflection_;
+  return metadata;
+}
+
+
+// ===================================================================
+
+#ifndef _MSC_VER
 const int Node::kIdFieldNumber;
 const int Node::kTypeNameFieldNumber;
 const int Node::kSizeFieldNumber;
 const int Node::kEdgesFieldNumber;
+const int Node::kAllocationStackFieldNumber;
 #endif  // !_MSC_VER
 
 Node::Node()
   : ::google::protobuf::Message() {
   SharedCtor();
   // @@protoc_insertion_point(constructor:mozilla.devtools.protobuf.Node)
 }
 
 void Node::InitAsDefaultInstance() {
+  allocationstack_ = const_cast< ::mozilla::devtools::protobuf::StackFrame*>(&::mozilla::devtools::protobuf::StackFrame::default_instance());
 }
 
 Node::Node(const Node& from)
   : ::google::protobuf::Message() {
   SharedCtor();
   MergeFrom(from);
   // @@protoc_insertion_point(copy_constructor:mozilla.devtools.protobuf.Node)
 }
 
 void Node::SharedCtor() {
   ::google::protobuf::internal::GetEmptyString();
   _cached_size_ = 0;
   id_ = GOOGLE_ULONGLONG(0);
   typename__ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
   size_ = GOOGLE_ULONGLONG(0);
+  allocationstack_ = NULL;
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
 }
 
 Node::~Node() {
   // @@protoc_insertion_point(destructor:mozilla.devtools.protobuf.Node)
   SharedDtor();
 }
 
 void Node::SharedDtor() {
   if (typename__ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
     delete typename__;
   }
   if (this != default_instance_) {
+    delete allocationstack_;
   }
 }
 
 void Node::SetCachedSize(int size) const {
   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
   _cached_size_ = size;
   GOOGLE_SAFE_CONCURRENT_WRITES_END();
 }
@@ -438,24 +1336,27 @@ const Node& Node::default_instance() {
 
 Node* Node::default_instance_ = NULL;
 
 Node* Node::New() const {
   return new Node;
 }
 
 void Node::Clear() {
-  if (_has_bits_[0 / 32] & 7) {
+  if (_has_bits_[0 / 32] & 23) {
     id_ = GOOGLE_ULONGLONG(0);
     if (has_typename_()) {
       if (typename__ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
         typename__->clear();
       }
     }
     size_ = GOOGLE_ULONGLONG(0);
+    if (has_allocationstack()) {
+      if (allocationstack_ != NULL) allocationstack_->::mozilla::devtools::protobuf::StackFrame::Clear();
+    }
   }
   edges_.Clear();
   ::memset(_has_bits_, 0, sizeof(_has_bits_));
   mutable_unknown_fields()->Clear();
 }
 
 bool Node::MergePartialFromCodedStream(
     ::google::protobuf::io::CodedInputStream* input) {
@@ -514,16 +1415,29 @@ bool Node::MergePartialFromCodedStream(
         if (tag == 34) {
          parse_edges:
           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
                 input, add_edges()));
         } else {
           goto handle_unusual;
         }
         if (input->ExpectTag(34)) goto parse_edges;
+        if (input->ExpectTag(42)) goto parse_allocationStack;
+        break;
+      }
+
+      // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 5;
+      case 5: {
+        if (tag == 42) {
+         parse_allocationStack:
+          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
+               input, mutable_allocationstack()));
+        } else {
+          goto handle_unusual;
+        }
         if (input->ExpectAtEnd()) goto success;
         break;
       }
 
       default: {
       handle_unusual:
         if (tag == 0 ||
             ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
@@ -565,16 +1479,22 @@ void Node::SerializeWithCachedSizes(
   }
 
   // repeated .mozilla.devtools.protobuf.Edge edges = 4;
   for (int i = 0; i < this->edges_size(); i++) {
     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
       4, this->edges(i), output);
   }
 
+  // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 5;
+  if (has_allocationstack()) {
+    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
+      5, this->allocationstack(), output);
+  }
+
   if (!unknown_fields().empty()) {
     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
         unknown_fields(), output);
   }
   // @@protoc_insertion_point(serialize_end:mozilla.devtools.protobuf.Node)
 }
 
 ::google::protobuf::uint8* Node::SerializeWithCachedSizesToArray(
@@ -599,16 +1519,23 @@ void Node::SerializeWithCachedSizes(
 
   // repeated .mozilla.devtools.protobuf.Edge edges = 4;
   for (int i = 0; i < this->edges_size(); i++) {
     target = ::google::protobuf::internal::WireFormatLite::
       WriteMessageNoVirtualToArray(
         4, this->edges(i), target);
   }
 
+  // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 5;
+  if (has_allocationstack()) {
+    target = ::google::protobuf::internal::WireFormatLite::
+      WriteMessageNoVirtualToArray(
+        5, this->allocationstack(), target);
+  }
+
   if (!unknown_fields().empty()) {
     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
         unknown_fields(), target);
   }
   // @@protoc_insertion_point(serialize_to_array_end:mozilla.devtools.protobuf.Node)
   return target;
 }
 
@@ -632,16 +1559,23 @@ int Node::ByteSize() const {
 
     // optional uint64 size = 3;
     if (has_size()) {
       total_size += 1 +
         ::google::protobuf::internal::WireFormatLite::UInt64Size(
           this->size());
     }
 
+    // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 5;
+    if (has_allocationstack()) {
+      total_size += 1 +
+        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
+          this->allocationstack());
+    }
+
   }
   // repeated .mozilla.devtools.protobuf.Edge edges = 4;
   total_size += 1 * this->edges_size();
   for (int i = 0; i < this->edges_size(); i++) {
     total_size +=
       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
         this->edges(i));
   }
@@ -677,16 +1611,19 @@ void Node::MergeFrom(const Node& from) {
       set_id(from.id());
     }
     if (from.has_typename_()) {
       set_typename_(from.typename_());
     }
     if (from.has_size()) {
       set_size(from.size());
     }
+    if (from.has_allocationstack()) {
+      mutable_allocationstack()->::mozilla::devtools::protobuf::StackFrame::MergeFrom(from.allocationstack());
+    }
   }
   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 }
 
 void Node::CopyFrom(const ::google::protobuf::Message& from) {
   if (&from == this) return;
   Clear();
   MergeFrom(from);
@@ -704,16 +1641,17 @@ bool Node::IsInitialized() const {
 }
 
 void Node::Swap(Node* other) {
   if (other != this) {
     std::swap(id_, other->id_);
     std::swap(typename__, other->typename__);
     std::swap(size_, other->size_);
     edges_.Swap(&other->edges_);
+    std::swap(allocationstack_, other->allocationstack_);
     std::swap(_has_bits_[0], other->_has_bits_[0]);
     _unknown_fields_.Swap(&other->_unknown_fields_);
     std::swap(_cached_size_, other->_cached_size_);
   }
 }
 
 ::google::protobuf::Metadata Node::GetMetadata() const {
   protobuf_AssignDescriptorsOnce();
--- a/toolkit/devtools/server/CoreDump.pb.h
+++ b/toolkit/devtools/server/CoreDump.pb.h
@@ -31,16 +31,18 @@ namespace devtools {
 namespace protobuf {
 
 // Internal implementation detail -- do not call these.
 void  protobuf_AddDesc_CoreDump_2eproto();
 void protobuf_AssignDesc_CoreDump_2eproto();
 void protobuf_ShutdownFile_CoreDump_2eproto();
 
 class Metadata;
+class StackFrame;
+class StackFrame_Data;
 class Node;
 class Edge;
 
 // ===================================================================
 
 class Metadata : public ::google::protobuf::Message {
  public:
   Metadata();
@@ -115,16 +117,283 @@ class Metadata : public ::google::protob
   friend void protobuf_AssignDesc_CoreDump_2eproto();
   friend void protobuf_ShutdownFile_CoreDump_2eproto();
 
   void InitAsDefaultInstance();
   static Metadata* default_instance_;
 };
 // -------------------------------------------------------------------
 
+class StackFrame_Data : public ::google::protobuf::Message {
+ public:
+  StackFrame_Data();
+  virtual ~StackFrame_Data();
+
+  StackFrame_Data(const StackFrame_Data& from);
+
+  inline StackFrame_Data& operator=(const StackFrame_Data& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StackFrame_Data& default_instance();
+
+  void Swap(StackFrame_Data* other);
+
+  // implements Message ----------------------------------------------
+
+  StackFrame_Data* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StackFrame_Data& from);
+  void MergeFrom(const StackFrame_Data& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional uint64 id = 1;
+  inline bool has_id() const;
+  inline void clear_id();
+  static const int kIdFieldNumber = 1;
+  inline ::google::protobuf::uint64 id() const;
+  inline void set_id(::google::protobuf::uint64 value);
+
+  // optional .mozilla.devtools.protobuf.StackFrame parent = 2;
+  inline bool has_parent() const;
+  inline void clear_parent();
+  static const int kParentFieldNumber = 2;
+  inline const ::mozilla::devtools::protobuf::StackFrame& parent() const;
+  inline ::mozilla::devtools::protobuf::StackFrame* mutable_parent();
+  inline ::mozilla::devtools::protobuf::StackFrame* release_parent();
+  inline void set_allocated_parent(::mozilla::devtools::protobuf::StackFrame* parent);
+
+  // optional uint32 line = 3;
+  inline bool has_line() const;
+  inline void clear_line();
+  static const int kLineFieldNumber = 3;
+  inline ::google::protobuf::uint32 line() const;
+  inline void set_line(::google::protobuf::uint32 value);
+
+  // optional uint32 column = 4;
+  inline bool has_column() const;
+  inline void clear_column();
+  static const int kColumnFieldNumber = 4;
+  inline ::google::protobuf::uint32 column() const;
+  inline void set_column(::google::protobuf::uint32 value);
+
+  // optional bytes source = 5;
+  inline bool has_source() const;
+  inline void clear_source();
+  static const int kSourceFieldNumber = 5;
+  inline const ::std::string& source() const;
+  inline void set_source(const ::std::string& value);
+  inline void set_source(const char* value);
+  inline void set_source(const void* value, size_t size);
+  inline ::std::string* mutable_source();
+  inline ::std::string* release_source();
+  inline void set_allocated_source(::std::string* source);
+
+  // optional bytes functionDisplayName = 6;
+  inline bool has_functiondisplayname() const;
+  inline void clear_functiondisplayname();
+  static const int kFunctionDisplayNameFieldNumber = 6;
+  inline const ::std::string& functiondisplayname() const;
+  inline void set_functiondisplayname(const ::std::string& value);
+  inline void set_functiondisplayname(const char* value);
+  inline void set_functiondisplayname(const void* value, size_t size);
+  inline ::std::string* mutable_functiondisplayname();
+  inline ::std::string* release_functiondisplayname();
+  inline void set_allocated_functiondisplayname(::std::string* functiondisplayname);
+
+  // optional bool isSystem = 7;
+  inline bool has_issystem() const;
+  inline void clear_issystem();
+  static const int kIsSystemFieldNumber = 7;
+  inline bool issystem() const;
+  inline void set_issystem(bool value);
+
+  // optional bool isSelfHosted = 8;
+  inline bool has_isselfhosted() const;
+  inline void clear_isselfhosted();
+  static const int kIsSelfHostedFieldNumber = 8;
+  inline bool isselfhosted() const;
+  inline void set_isselfhosted(bool value);
+
+  // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.StackFrame.Data)
+ private:
+  inline void set_has_id();
+  inline void clear_has_id();
+  inline void set_has_parent();
+  inline void clear_has_parent();
+  inline void set_has_line();
+  inline void clear_has_line();
+  inline void set_has_column();
+  inline void clear_has_column();
+  inline void set_has_source();
+  inline void clear_has_source();
+  inline void set_has_functiondisplayname();
+  inline void clear_has_functiondisplayname();
+  inline void set_has_issystem();
+  inline void clear_has_issystem();
+  inline void set_has_isselfhosted();
+  inline void clear_has_isselfhosted();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  ::google::protobuf::uint64 id_;
+  ::mozilla::devtools::protobuf::StackFrame* parent_;
+  ::google::protobuf::uint32 line_;
+  ::google::protobuf::uint32 column_;
+  ::std::string* source_;
+  ::std::string* functiondisplayname_;
+  bool issystem_;
+  bool isselfhosted_;
+  friend void  protobuf_AddDesc_CoreDump_2eproto();
+  friend void protobuf_AssignDesc_CoreDump_2eproto();
+  friend void protobuf_ShutdownFile_CoreDump_2eproto();
+
+  void InitAsDefaultInstance();
+  static StackFrame_Data* default_instance_;
+};
+// -------------------------------------------------------------------
+
+class StackFrame : public ::google::protobuf::Message {
+ public:
+  StackFrame();
+  virtual ~StackFrame();
+
+  StackFrame(const StackFrame& from);
+
+  inline StackFrame& operator=(const StackFrame& from) {
+    CopyFrom(from);
+    return *this;
+  }
+
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _unknown_fields_;
+  }
+
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return &_unknown_fields_;
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StackFrame& default_instance();
+
+  enum StackFrameTypeCase {
+    kData = 1,
+    kRef = 2,
+    STACKFRAMETYPE_NOT_SET = 0,
+  };
+
+  void Swap(StackFrame* other);
+
+  // implements Message ----------------------------------------------
+
+  StackFrame* New() const;
+  void CopyFrom(const ::google::protobuf::Message& from);
+  void MergeFrom(const ::google::protobuf::Message& from);
+  void CopyFrom(const StackFrame& from);
+  void MergeFrom(const StackFrame& from);
+  void Clear();
+  bool IsInitialized() const;
+
+  int ByteSize() const;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input);
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const;
+  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
+  int GetCachedSize() const { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  public:
+  ::google::protobuf::Metadata GetMetadata() const;
+
+  // nested types ----------------------------------------------------
+
+  typedef StackFrame_Data Data;
+
+  // accessors -------------------------------------------------------
+
+  // optional .mozilla.devtools.protobuf.StackFrame.Data data = 1;
+  inline bool has_data() const;
+  inline void clear_data();
+  static const int kDataFieldNumber = 1;
+  inline const ::mozilla::devtools::protobuf::StackFrame_Data& data() const;
+  inline ::mozilla::devtools::protobuf::StackFrame_Data* mutable_data();
+  inline ::mozilla::devtools::protobuf::StackFrame_Data* release_data();
+  inline void set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* data);
+
+  // optional uint64 ref = 2;
+  inline bool has_ref() const;
+  inline void clear_ref();
+  static const int kRefFieldNumber = 2;
+  inline ::google::protobuf::uint64 ref() const;
+  inline void set_ref(::google::protobuf::uint64 value);
+
+  inline StackFrameTypeCase StackFrameType_case() const;
+  // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.StackFrame)
+ private:
+  inline void set_has_data();
+  inline void set_has_ref();
+
+  inline bool has_StackFrameType();
+  void clear_StackFrameType();
+  inline void clear_has_StackFrameType();
+
+  ::google::protobuf::UnknownFieldSet _unknown_fields_;
+
+  ::google::protobuf::uint32 _has_bits_[1];
+  mutable int _cached_size_;
+  union StackFrameTypeUnion {
+    ::mozilla::devtools::protobuf::StackFrame_Data* data_;
+    ::google::protobuf::uint64 ref_;
+  } StackFrameType_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend void  protobuf_AddDesc_CoreDump_2eproto();
+  friend void protobuf_AssignDesc_CoreDump_2eproto();
+  friend void protobuf_ShutdownFile_CoreDump_2eproto();
+
+  void InitAsDefaultInstance();
+  static StackFrame* default_instance_;
+};
+// -------------------------------------------------------------------
+
 class Node : public ::google::protobuf::Message {
  public:
   Node();
   virtual ~Node();
 
   Node(const Node& from);
 
   inline Node& operator=(const Node& from) {
@@ -206,33 +475,45 @@ class Node : public ::google::protobuf::
   inline const ::mozilla::devtools::protobuf::Edge& edges(int index) const;
   inline ::mozilla::devtools::protobuf::Edge* mutable_edges(int index);
   inline ::mozilla::devtools::protobuf::Edge* add_edges();
   inline const ::google::protobuf::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >&
       edges() const;
   inline ::google::protobuf::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >*
       mutable_edges();
 
+  // optional .mozilla.devtools.protobuf.StackFrame allocationStack = 5;
+  inline bool has_allocationstack() const;
+  inline void clear_allocationstack();
+  static const int kAllocationStackFieldNumber = 5;
+  inline const ::mozilla::devtools::protobuf::StackFrame& allocationstack() const;
+  inline ::mozilla::devtools::protobuf::StackFrame* mutable_allocationstack();
+  inline ::mozilla::devtools::protobuf::StackFrame* release_allocationstack();
+  inline void set_allocated_allocationstack(::mozilla::devtools::protobuf::StackFrame* allocationstack);
+
   // @@protoc_insertion_point(class_scope:mozilla.devtools.protobuf.Node)
  private:
   inline void set_has_id();
   inline void clear_has_id();
   inline void set_has_typename_();
   inline void clear_has_typename_();
   inline void set_has_size();
   inline void clear_has_size();
+  inline void set_has_allocationstack();
+  inline void clear_has_allocationstack();
 
   ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
   ::google::protobuf::uint32 _has_bits_[1];
   mutable int _cached_size_;
   ::google::protobuf::uint64 id_;
   ::std::string* typename__;
   ::google::protobuf::uint64 size_;
   ::google::protobuf::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge > edges_;
+  ::mozilla::devtools::protobuf::StackFrame* allocationstack_;
   friend void  protobuf_AddDesc_CoreDump_2eproto();
   friend void protobuf_AssignDesc_CoreDump_2eproto();
   friend void protobuf_ShutdownFile_CoreDump_2eproto();
 
   void InitAsDefaultInstance();
   static Node* default_instance_;
 };
 // -------------------------------------------------------------------
@@ -357,16 +638,416 @@ inline ::google::protobuf::uint64 Metada
 inline void Metadata::set_timestamp(::google::protobuf::uint64 value) {
   set_has_timestamp();
   timestamp_ = value;
   // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.Metadata.timeStamp)
 }
 
 // -------------------------------------------------------------------
 
+// StackFrame_Data
+
+// optional uint64 id = 1;
+inline bool StackFrame_Data::has_id() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void StackFrame_Data::set_has_id() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void StackFrame_Data::clear_has_id() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void StackFrame_Data::clear_id() {
+  id_ = GOOGLE_ULONGLONG(0);
+  clear_has_id();
+}
+inline ::google::protobuf::uint64 StackFrame_Data::id() const {
+  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.id)
+  return id_;
+}
+inline void StackFrame_Data::set_id(::google::protobuf::uint64 value) {
+  set_has_id();
+  id_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.id)
+}
+
+// optional .mozilla.devtools.protobuf.StackFrame parent = 2;
+inline bool StackFrame_Data::has_parent() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void StackFrame_Data::set_has_parent() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void StackFrame_Data::clear_has_parent() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void StackFrame_Data::clear_parent() {
+  if (parent_ != NULL) parent_->::mozilla::devtools::protobuf::StackFrame::Clear();
+  clear_has_parent();
+}
+inline const ::mozilla::devtools::protobuf::StackFrame& StackFrame_Data::parent() const {
+  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.parent)
+  return parent_ != NULL ? *parent_ : *default_instance_->parent_;
+}
+inline ::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::mutable_parent() {
+  set_has_parent();
+  if (parent_ == NULL) parent_ = new ::mozilla::devtools::protobuf::StackFrame;
+  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.parent)
+  return parent_;
+}
+inline ::mozilla::devtools::protobuf::StackFrame* StackFrame_Data::release_parent() {
+  clear_has_parent();
+  ::mozilla::devtools::protobuf::StackFrame* temp = parent_;
+  parent_ = NULL;
+  return temp;
+}
+inline void StackFrame_Data::set_allocated_parent(::mozilla::devtools::protobuf::StackFrame* parent) {
+  delete parent_;
+  parent_ = parent;
+  if (parent) {
+    set_has_parent();
+  } else {
+    clear_has_parent();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.parent)
+}
+
+// optional uint32 line = 3;
+inline bool StackFrame_Data::has_line() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void StackFrame_Data::set_has_line() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void StackFrame_Data::clear_has_line() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void StackFrame_Data::clear_line() {
+  line_ = 0u;
+  clear_has_line();
+}
+inline ::google::protobuf::uint32 StackFrame_Data::line() const {
+  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.line)
+  return line_;
+}
+inline void StackFrame_Data::set_line(::google::protobuf::uint32 value) {
+  set_has_line();
+  line_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.line)
+}
+
+// optional uint32 column = 4;
+inline bool StackFrame_Data::has_column() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void StackFrame_Data::set_has_column() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void StackFrame_Data::clear_has_column() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void StackFrame_Data::clear_column() {
+  column_ = 0u;
+  clear_has_column();
+}
+inline ::google::protobuf::uint32 StackFrame_Data::column() const {
+  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.column)
+  return column_;
+}
+inline void StackFrame_Data::set_column(::google::protobuf::uint32 value) {
+  set_has_column();
+  column_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.column)
+}
+
+// optional bytes source = 5;
+inline bool StackFrame_Data::has_source() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void StackFrame_Data::set_has_source() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void StackFrame_Data::clear_has_source() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void StackFrame_Data::clear_source() {
+  if (source_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    source_->clear();
+  }
+  clear_has_source();
+}
+inline const ::std::string& StackFrame_Data::source() const {
+  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.source)
+  return *source_;
+}
+inline void StackFrame_Data::set_source(const ::std::string& value) {
+  set_has_source();
+  if (source_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    source_ = new ::std::string;
+  }
+  source_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.source)
+}
+inline void StackFrame_Data::set_source(const char* value) {
+  set_has_source();
+  if (source_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    source_ = new ::std::string;
+  }
+  source_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.devtools.protobuf.StackFrame.Data.source)
+}
+inline void StackFrame_Data::set_source(const void* value, size_t size) {
+  set_has_source();
+  if (source_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    source_ = new ::std::string;
+  }
+  source_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.devtools.protobuf.StackFrame.Data.source)
+}
+inline ::std::string* StackFrame_Data::mutable_source() {
+  set_has_source();
+  if (source_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    source_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.source)
+  return source_;
+}
+inline ::std::string* StackFrame_Data::release_source() {
+  clear_has_source();
+  if (source_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = source_;
+    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void StackFrame_Data::set_allocated_source(::std::string* source) {
+  if (source_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete source_;
+  }
+  if (source) {
+    set_has_source();
+    source_ = source;
+  } else {
+    clear_has_source();
+    source_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.source)
+}
+
+// optional bytes functionDisplayName = 6;
+inline bool StackFrame_Data::has_functiondisplayname() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void StackFrame_Data::set_has_functiondisplayname() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void StackFrame_Data::clear_has_functiondisplayname() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void StackFrame_Data::clear_functiondisplayname() {
+  if (functiondisplayname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    functiondisplayname_->clear();
+  }
+  clear_has_functiondisplayname();
+}
+inline const ::std::string& StackFrame_Data::functiondisplayname() const {
+  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
+  return *functiondisplayname_;
+}
+inline void StackFrame_Data::set_functiondisplayname(const ::std::string& value) {
+  set_has_functiondisplayname();
+  if (functiondisplayname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    functiondisplayname_ = new ::std::string;
+  }
+  functiondisplayname_->assign(value);
+  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
+}
+inline void StackFrame_Data::set_functiondisplayname(const char* value) {
+  set_has_functiondisplayname();
+  if (functiondisplayname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    functiondisplayname_ = new ::std::string;
+  }
+  functiondisplayname_->assign(value);
+  // @@protoc_insertion_point(field_set_char:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
+}
+inline void StackFrame_Data::set_functiondisplayname(const void* value, size_t size) {
+  set_has_functiondisplayname();
+  if (functiondisplayname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    functiondisplayname_ = new ::std::string;
+  }
+  functiondisplayname_->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
+}
+inline ::std::string* StackFrame_Data::mutable_functiondisplayname() {
+  set_has_functiondisplayname();
+  if (functiondisplayname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    functiondisplayname_ = new ::std::string;
+  }
+  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
+  return functiondisplayname_;
+}
+inline ::std::string* StackFrame_Data::release_functiondisplayname() {
+  clear_has_functiondisplayname();
+  if (functiondisplayname_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    return NULL;
+  } else {
+    ::std::string* temp = functiondisplayname_;
+    functiondisplayname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+    return temp;
+  }
+}
+inline void StackFrame_Data::set_allocated_functiondisplayname(::std::string* functiondisplayname) {
+  if (functiondisplayname_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
+    delete functiondisplayname_;
+  }
+  if (functiondisplayname) {
+    set_has_functiondisplayname();
+    functiondisplayname_ = functiondisplayname;
+  } else {
+    clear_has_functiondisplayname();
+    functiondisplayname_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.StackFrame.Data.functionDisplayName)
+}
+
+// optional bool isSystem = 7;
+inline bool StackFrame_Data::has_issystem() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void StackFrame_Data::set_has_issystem() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void StackFrame_Data::clear_has_issystem() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void StackFrame_Data::clear_issystem() {
+  issystem_ = false;
+  clear_has_issystem();
+}
+inline bool StackFrame_Data::issystem() const {
+  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.isSystem)
+  return issystem_;
+}
+inline void StackFrame_Data::set_issystem(bool value) {
+  set_has_issystem();
+  issystem_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.isSystem)
+}
+
+// optional bool isSelfHosted = 8;
+inline bool StackFrame_Data::has_isselfhosted() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void StackFrame_Data::set_has_isselfhosted() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void StackFrame_Data::clear_has_isselfhosted() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void StackFrame_Data::clear_isselfhosted() {
+  isselfhosted_ = false;
+  clear_has_isselfhosted();
+}
+inline bool StackFrame_Data::isselfhosted() const {
+  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.StackFrame.Data.isSelfHosted)
+  return isselfhosted_;
+}
+inline void StackFrame_Data::set_isselfhosted(bool value) {
+  set_has_isselfhosted();
+  isselfhosted_ = value;
+  // @@protoc_insertion_point(field_set:mozilla.devtools.protobuf.StackFrame.Data.isSelfHosted)
+}
+
+// -------------------------------------------------------------------
+
+// StackFrame
+
+// optional .mozilla.devtools.protobuf.StackFrame.Data data = 1;
+inline bool StackFrame::has_data() const {
+  return StackFrameType_case() == kData;
+}
+inline void StackFrame::set_has_data() {
+  _oneof_case_[0] = kData;
+}
+inline void StackFrame::clear_data() {
+  if (has_data()) {
+    delete StackFrameType_.data_;
+    clear_has_StackFrameType();
+  }
+}
+inline const ::mozilla::devtools::protobuf::StackFrame_Data& StackFrame::data() const {
+  return has_data() ? *StackFrameType_.data_
+                      : ::mozilla::devtools::protobuf::StackFrame_Data::default_instance();
+}
+inline ::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::mutable_data() {
+  if (!has_data()) {
+    clear_StackFrameType();
+    set_has_data();
+    StackFrameType_.data_ = new ::mozilla::devtools::protobuf::StackFrame_Data;
+  }
+  return StackFrameType_.data_;
+}
+inline ::mozilla::devtools::protobuf::StackFrame_Data* StackFrame::release_data() {
+  if (has_data()) {
+    clear_has_StackFrameType();
+    ::mozilla::devtools::protobuf::StackFrame_Data* temp = StackFrameType_.data_;
+    StackFrameType_.data_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void StackFrame::set_allocated_data(::mozilla::devtools::protobuf::StackFrame_Data* data) {
+  clear_StackFrameType();
+  if (data) {
+    set_has_data();
+    StackFrameType_.data_ = data;
+  }
+}
+
+// optional uint64 ref = 2;
+inline bool StackFrame::has_ref() const {
+  return StackFrameType_case() == kRef;
+}
+inline void StackFrame::set_has_ref() {
+  _oneof_case_[0] = kRef;
+}
+inline void StackFrame::clear_ref() {
+  if (has_ref()) {
+    StackFrameType_.ref_ = GOOGLE_ULONGLONG(0);
+    clear_has_StackFrameType();
+  }
+}
+inline ::google::protobuf::uint64 StackFrame::ref() const {
+  if (has_ref()) {
+    return StackFrameType_.ref_;
+  }
+  return GOOGLE_ULONGLONG(0);
+}
+inline void StackFrame::set_ref(::google::protobuf::uint64 value) {
+  if (!has_ref()) {
+    clear_StackFrameType();
+    set_has_ref();
+  }
+  StackFrameType_.ref_ = value;
+}
+
+inline bool StackFrame::has_StackFrameType() {
+  return StackFrameType_case() != STACKFRAMETYPE_NOT_SET;
+}
+inline void StackFrame::clear_has_StackFrameType() {
+  _oneof_case_[0] = STACKFRAMETYPE_NOT_SET;
+}
+inline StackFrame::StackFrameTypeCase StackFrame::StackFrameType_case() const {
+  return StackFrame::StackFrameTypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
 // Node
 
 // optional uint64 id = 1;
 inline bool Node::has_id() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
 inline void Node::set_has_id() {
   _has_bits_[0] |= 0x00000001u;
@@ -513,16 +1194,57 @@ Node::edges() const {
   return edges_;
 }
 inline ::google::protobuf::RepeatedPtrField< ::mozilla::devtools::protobuf::Edge >*
 Node::mutable_edges() {
   // @@protoc_insertion_point(field_mutable_list:mozilla.devtools.protobuf.Node.edges)
   return &edges_;
 }
 
+// optional .mozilla.devtools.protobuf.StackFrame allocationStack = 5;
+inline bool Node::has_allocationstack() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void Node::set_has_allocationstack() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void Node::clear_has_allocationstack() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void Node::clear_allocationstack() {
+  if (allocationstack_ != NULL) allocationstack_->::mozilla::devtools::protobuf::StackFrame::Clear();
+  clear_has_allocationstack();
+}
+inline const ::mozilla::devtools::protobuf::StackFrame& Node::allocationstack() const {
+  // @@protoc_insertion_point(field_get:mozilla.devtools.protobuf.Node.allocationStack)
+  return allocationstack_ != NULL ? *allocationstack_ : *default_instance_->allocationstack_;
+}
+inline ::mozilla::devtools::protobuf::StackFrame* Node::mutable_allocationstack() {
+  set_has_allocationstack();
+  if (allocationstack_ == NULL) allocationstack_ = new ::mozilla::devtools::protobuf::StackFrame;
+  // @@protoc_insertion_point(field_mutable:mozilla.devtools.protobuf.Node.allocationStack)
+  return allocationstack_;
+}
+inline ::mozilla::devtools::protobuf::StackFrame* Node::release_allocationstack() {
+  clear_has_allocationstack();
+  ::mozilla::devtools::protobuf::StackFrame* temp = allocationstack_;
+  allocationstack_ = NULL;
+  return temp;
+}
+inline void Node::set_allocated_allocationstack(::mozilla::devtools::protobuf::StackFrame* allocationstack) {
+  delete allocationstack_;
+  allocationstack_ = allocationstack;
+  if (allocationstack) {
+    set_has_allocationstack();
+  } else {
+    clear_has_allocationstack();
+  }
+  // @@protoc_insertion_point(field_set_allocated:mozilla.devtools.protobuf.Node.allocationStack)
+}
+
 // -------------------------------------------------------------------
 
 // Edge
 
 // optional uint64 referent = 1;
 inline bool Edge::has_referent() const {
   return (_has_bits_[0] & 0x00000001u) != 0;
 }
@@ -629,15 +1351,15 @@ inline void Edge::set_allocated_name(::s
 }  // namespace devtools
 }  // namespace mozilla
 
 #ifndef SWIG
 namespace google {
 namespace protobuf {
 
 
-} // namespace protobuf
-} // namespace google
+}  // namespace google
+}  // namespace protobuf
 #endif  // SWIG
 
 // @@protoc_insertion_point(global_scope)
 
 #endif  // PROTOBUF_CoreDump_2eproto__INCLUDED
--- a/toolkit/devtools/server/CoreDump.proto
+++ b/toolkit/devtools/server/CoreDump.proto
@@ -47,23 +47,50 @@
 package mozilla.devtools.protobuf;
 
 // A collection of metadata about this core dump.
 message Metadata {
     // Number of microseconds since midnight (00:00:00) 1 January 1970 UTC.
     optional uint64 timeStamp = 1;
 }
 
+// A serialized version of `JS::ubi::StackFrame`. Older parent frame tails are
+// de-duplicated to cut down on [de]serialization and size costs.
+message StackFrame {
+    oneof StackFrameType {
+        // This is the first time this stack frame has been serialized, and so
+        // here is all of its data.
+        Data   data = 1;
+        // A reference to a stack frame that has already been serialized and has
+        // the given number as its id.
+        uint64 ref  = 2;
+    }
+
+    message Data {
+        optional uint64 id = 1;
+        optional StackFrame parent = 2;
+        optional uint32 line = 3;
+        optional uint32 column = 4;
+        // char16_t[]
+        optional bytes source = 5;
+        // char16_t[]
+        optional bytes functionDisplayName = 6;
+        optional bool isSystem = 7;
+        optional bool isSelfHosted = 8;
+    }
+}
+
 // A serialized version of `JS::ubi::Node` and its outgoing edges.
 message Node {
-    optional uint64 id       = 1;
+    optional uint64     id              = 1;
     // char16_t[]
-    optional bytes  typeName = 2;
-    optional uint64 size     = 3;
-    repeated Edge   edges    = 4;
+    optional bytes      typeName        = 2;
+    optional uint64     size            = 3;
+    repeated Edge       edges           = 4;
+    optional StackFrame allocationStack = 5;
 }
 
 // A serialized edge from the heap graph.
 message Edge {
     optional uint64 referent = 1;
     // char16_t[]
     optional bytes  name     = 2;
 }
\ No newline at end of file