summaryrefslogtreecommitdiffstats
path: root/devtools/shared/heapsnapshot/DeserializedNode.h
blob: abbadf4830ce8877989a682d91a15428c3250717 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_devtools_DeserializedNode__
#define mozilla_devtools_DeserializedNode__

#include <utility>

#include "js/UbiNode.h"
#include "js/UniquePtr.h"
#include "mozilla/HashFunctions.h"
#include "mozilla/Maybe.h"
#include "mozilla/Vector.h"
#include "mozilla/devtools/CoreDump.pb.h"

// `Deserialized{Node,Edge}` translate protobuf messages from our core dump
// format into structures we can rely upon for implementing `JS::ubi::Node`
// specializations on top of. All of the properties of the protobuf messages are
// optional for future compatibility, and this is the layer where we validate
// that the properties that do actually exist in any given message fulfill our
// semantic requirements.
//
// Both `DeserializedNode` and `DeserializedEdge` are always owned by a
// `HeapSnapshot` instance, and their lifetimes must not extend after that of
// their owning `HeapSnapshot`.

namespace mozilla {
namespace devtools {

class HeapSnapshot;

using NodeId = uint64_t;
using StackFrameId = uint64_t;

// A `DeserializedEdge` represents an edge in the heap graph pointing to the
// node with id equal to `DeserializedEdge::referent` that we deserialized from
// a core dump.
struct DeserializedEdge {
  NodeId referent;
  // A borrowed reference to a string owned by this node's owning HeapSnapshot.
  const char16_t* name;

  explicit DeserializedEdge(NodeId referent, const char16_t* edgeName = nullptr)
      : referent(referent), name(edgeName) {}
  DeserializedEdge(DeserializedEdge&& rhs);
  DeserializedEdge& operator=(DeserializedEdge&& rhs);

 private:
  DeserializedEdge(const DeserializedEdge&) = delete;
  DeserializedEdge& operator=(const DeserializedEdge&) = delete;
};

// A `DeserializedNode` is a node in the heap graph that we deserialized from a
// core dump.
struct DeserializedNode {
  using EdgeVector = Vector<DeserializedEdge>;
  using UniqueStringPtr = UniquePtr<char16_t[]>;

  NodeId id;
  JS::ubi::CoarseType coarseType;
  // A borrowed reference to a string owned by this node's owning HeapSnapshot.
  const char16_t* typeName;
  uint64_t size;
  EdgeVector edges;
  Maybe<StackFrameId> allocationStack;
  // A borrowed reference to a string owned by this node's owning HeapSnapshot.
  const char* jsObjectClassName;
  // A borrowed reference to a string owned by this node's owning HeapSnapshot.
  const char* scriptFilename;
  // A borrowed reference to a string owned by this node's owning HeapSnapshot.
  const char16_t* descriptiveTypeName;
  // A weak pointer to this node's owning `HeapSnapshot`. Safe without
  // AddRef'ing because this node's lifetime is equal to that of its owner.
  HeapSnapshot* owner;

  DeserializedNode(NodeId id, JS::ubi::CoarseType coarseType,
                   const char16_t* typeName, uint64_t size, EdgeVector&& edges,
                   const Maybe<StackFrameId>& allocationStack,
                   const char* className, const char* filename,
                   const char16_t* descriptiveName, HeapSnapshot& owner)
      : id(id),
        coarseType(coarseType),
        typeName(typeName),
        size(size),
        edges(std::move(edges)),
        allocationStack(allocationStack),
        jsObjectClassName(className),
        scriptFilename(filename),
        descriptiveTypeName(descriptiveName),
        owner(&owner) {}
  virtual ~DeserializedNode() {}

  DeserializedNode(DeserializedNode&& rhs)
      : id(rhs.id),
        coarseType(rhs.coarseType),
        typeName(rhs.typeName),
        size(rhs.size),
        edges(std::move(rhs.edges)),
        allocationStack(rhs.allocationStack),
        jsObjectClassName(rhs.jsObjectClassName),
        scriptFilename(rhs.scriptFilename),
        descriptiveTypeName(rhs.descriptiveTypeName),
        owner(rhs.owner) {}

  DeserializedNode& operator=(DeserializedNode&& rhs) {
    MOZ_ASSERT(&rhs != this);
    this->~DeserializedNode();
    new (this) DeserializedNode(std::move(rhs));
    return *this;
  }

  // Get a borrowed reference to the given edge's referent. This method is
  // virtual to provide a hook for gmock and gtest.
  virtual JS::ubi::Node getEdgeReferent(const DeserializedEdge& edge);

  struct HashPolicy;

 protected:
  // This is only for use with `MockDeserializedNode` in testing.
  DeserializedNode(NodeId id, const char16_t* typeName, uint64_t size)
      : id(id),
        coarseType(JS::ubi::CoarseType::Other),
        typeName(typeName),
        size(size),
        edges(),
        allocationStack(Nothing()),
        jsObjectClassName(nullptr),
        scriptFilename(nullptr),
        descriptiveTypeName(nullptr),
        owner(nullptr) {}

 private:
  DeserializedNode(const DeserializedNode&) = delete;
  DeserializedNode& operator=(const DeserializedNode&) = delete;
};

static inline js::HashNumber hashIdDerivedFromPtr(uint64_t id) {
  return mozilla::HashGeneric(id);
}

struct DeserializedNode::HashPolicy {
  using Lookup = NodeId;

  static js::HashNumber hash(const Lookup& lookup) {
    return hashIdDerivedFromPtr(lookup);
  }

  static bool match(const DeserializedNode& existing, const Lookup& lookup) {
    return existing.id == lookup;
  }
};

// A `DeserializedStackFrame` is a stack frame referred to by a thing in the
// heap graph that we deserialized from a core dump.
struct DeserializedStackFrame {
  StackFrameId id;
  Maybe<StackFrameId> parent;
  uint32_t line;
  uint32_t column;
  // Borrowed references to strings owned by this DeserializedStackFrame's
  // owning HeapSnapshot.
  const char16_t* source;
  const char16_t* functionDisplayName;
  bool isSystem;
  bool isSelfHosted;
  // A weak pointer to this frame's owning `HeapSnapshot`. Safe without
  // AddRef'ing because this frame's lifetime is equal to that of its owner.
  HeapSnapshot* owner;

  explicit DeserializedStackFrame(StackFrameId id,
                                  const Maybe<StackFrameId>& parent,
                                  uint32_t line, uint32_t column,
                                  const char16_t* source,
                                  const char16_t* functionDisplayName,
                                  bool isSystem, bool isSelfHosted,
                                  HeapSnapshot& owner)
      : id(id),
        parent(parent),
        line(line),
        column(column),
        source(source),
        functionDisplayName(functionDisplayName),
        isSystem(isSystem),
        isSelfHosted(isSelfHosted),
        owner(&owner) {
    MOZ_ASSERT(source);
  }

  JS::ubi::StackFrame getParentStackFrame() const;

  struct HashPolicy;

 protected:
  // This is exposed only for MockDeserializedStackFrame in the gtests.
  explicit DeserializedStackFrame()
      : id(0),
        parent(Nothing()),
        line(0),
        column(0),
        source(nullptr),
        functionDisplayName(nullptr),
        isSystem(false),
        isSelfHosted(false),
        owner(nullptr){};
};

struct DeserializedStackFrame::HashPolicy {
  using Lookup = StackFrameId;

  static js::HashNumber hash(const Lookup& lookup) {
    return hashIdDerivedFromPtr(lookup);
  }

  static bool match(const DeserializedStackFrame& existing,
                    const Lookup& lookup) {
    return existing.id == lookup;
  }
};

}  // namespace devtools
}  // namespace mozilla

namespace JS {
namespace ubi {

using mozilla::devtools::DeserializedNode;
using mozilla::devtools::DeserializedStackFrame;

template <>
class Concrete<DeserializedNode> : public Base {
 protected:
  explicit Concrete(DeserializedNode* ptr) : Base(ptr) {}
  DeserializedNode& get() const { return *static_cast<DeserializedNode*>(ptr); }

 public:
  static void construct(void* storage, DeserializedNode* ptr) {
    new (storage) Concrete(ptr);
  }

  CoarseType coarseType() const final { return get().coarseType; }
  Id identifier() const override { return get().id; }
  bool isLive() const override { return false; }
  const char16_t* typeName() const override;
  Node::Size size(mozilla::MallocSizeOf mallocSizeof) const override;
  const char* jsObjectClassName() const override {
    return get().jsObjectClassName;
  }
  const char* scriptFilename() const final { return get().scriptFilename; }
  const char16_t* descriptiveTypeName() const override {
    return get().descriptiveTypeName;
  }

  bool hasAllocationStack() const override {
    return get().allocationStack.isSome();
  }
  StackFrame allocationStack() const override;

  // We ignore the `bool wantNames` parameter because we can't control whether
  // the core dump was serialized with edge names or not.
  js::UniquePtr<EdgeRange> edges(JSContext* cx, bool) const override;

  static const char16_t concreteTypeName[];
};

template <>
class ConcreteStackFrame<DeserializedStackFrame> : public BaseStackFrame {
 protected:
  explicit ConcreteStackFrame(DeserializedStackFrame* ptr)
      : BaseStackFrame(ptr) {}

  DeserializedStackFrame& get() const {
    return *static_cast<DeserializedStackFrame*>(ptr);
  }

 public:
  static void construct(void* storage, DeserializedStackFrame* ptr) {
    new (storage) ConcreteStackFrame(ptr);
  }

  uint64_t identifier() const override { return get().id; }
  uint32_t line() const override { return get().line; }
  uint32_t column() const override { return get().column; }
  bool isSystem() const override { return get().isSystem; }
  bool isSelfHosted(JSContext* cx) const override { return get().isSelfHosted; }
  void trace(JSTracer* trc) override {}
  AtomOrTwoByteChars source() const override {
    return AtomOrTwoByteChars(get().source);
  }
  uint32_t sourceId() const override {
    // Source IDs are local to their host process and are not serialized.
    return 0;
  }
  AtomOrTwoByteChars functionDisplayName() const override {
    return AtomOrTwoByteChars(get().functionDisplayName);
  }

  StackFrame parent() const override;
  bool constructSavedFrameStack(
      JSContext* cx,
      JS::MutableHandle<JSObject*> outSavedFrameStack) const override;
};

}  // namespace ubi
}  // namespace JS

#endif  // mozilla_devtools_DeserializedNode__