/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h

Bug Summary

File:	var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h
Warning:	line 1725, column 7 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name HeapSnapshot.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/devtools/shared/heapsnapshot -fcoverage-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/devtools/shared/heapsnapshot -resource-dir /usr/lib/llvm-19/lib/clang/19 -include /var/lib/jenkins/workspace/firefox-scan-build/config/gcc_hidden.h -include /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -D GOOGLE_PROTOBUF_NO_RTTI -D MOZ_HAS_MOZGLUE -D MOZILLA_INTERNAL_API -D IMPL_LIBXUL -D MOZ_SUPPORT_LEAKCHECKING -D STATIC_EXPORTABLE_JS_API -I /var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/devtools/shared/heapsnapshot -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders -I /var/lib/jenkins/workspace/firefox-scan-build/ipc/chromium/src -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-19/lib/clang/19/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-09-22-115206-3586786-1 -x c++ /var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp

/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp

→

1/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
2/* This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5 
6#include "HeapSnapshot.h"
7 
8#include <google/protobuf/io/coded_stream.h>
9#include <google/protobuf/io/gzip_stream.h>
10#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
11 
12#include "js/Array.h"  // JS::NewArrayObject
13#include "js/ColumnNumber.h"  // JS::LimitedColumnNumberOneOrigin, JS::TaggedColumnNumberOneOrigin
14#include "js/Debug.h"
15#include "js/PropertyAndElement.h"  // JS_DefineProperty
16#include "js/TypeDecls.h"
17#include "js/UbiNodeBreadthFirst.h"
18#include "js/UbiNodeCensus.h"
19#include "js/UbiNodeDominatorTree.h"
20#include "js/UbiNodeShortestPaths.h"
21#include "mozilla/Attributes.h"
22#include "mozilla/CycleCollectedJSContext.h"
23#include "mozilla/devtools/AutoMemMap.h"
24#include "mozilla/devtools/CoreDump.pb.h"
25#include "mozilla/devtools/DeserializedNode.h"
26#include "mozilla/devtools/DominatorTree.h"
27#include "mozilla/devtools/FileDescriptorOutputStream.h"
28#include "mozilla/devtools/HeapSnapshotTempFileHelperChild.h"
29#include "mozilla/devtools/ZeroCopyNSIOutputStream.h"
30#include "mozilla/dom/ChromeUtils.h"
31#include "mozilla/dom/ContentChild.h"
32#include "mozilla/dom/HeapSnapshotBinding.h"
33#include "mozilla/RangedPtr.h"
34#include "mozilla/Telemetry.h"
35#include "mozilla/Unused.h"
36 
37#include "jsapi.h"
38#include "jsfriendapi.h"
39#include "js/GCVector.h"
40#include "js/MapAndSet.h"
41#include "js/Object.h"                // JS::GetCompartment
42#include "nsComponentManagerUtils.h"  // do_CreateInstance
43#include "nsCycleCollectionParticipant.h"
44#include "nsCRTGlue.h"
45#include "nsIFile.h"
46#include "nsIOutputStream.h"
47#include "nsISupportsImpl.h"
48#include "nsNetUtil.h"
49#include "nsPrintfCString.h"
50#include "prerror.h"
51#include "prio.h"
52#include "prtypes.h"
53#include "SpecialSystemDirectory.h"
54 
55namespace mozilla {
56namespace devtools {
57 
58using namespace JS;
59using namespace dom;
60 
61using ::google::protobuf::io::ArrayInputStream;
62using ::google::protobuf::io::CodedInputStream;
63using ::google::protobuf::io::GzipInputStream;
64using ::google::protobuf::io::ZeroCopyInputStream;
65 
66using JS::ubi::AtomOrTwoByteChars;
67using JS::ubi::ShortestPaths;
68 
69MallocSizeOf GetCurrentThreadDebuggerMallocSizeOf() {
70  auto ccjscx = CycleCollectedJSContext::Get();
71  MOZ_ASSERT(ccjscx)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(ccjscx)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(ccjscx))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("ccjscx", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 71); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ccjscx" ")");
 do { *((volatile int*)__null) = 71; __attribute__((nomerge))
 ::abort(); } while (false); } } while (false);
72  auto cx = ccjscx->Context();
73  MOZ_ASSERT(cx)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(cx)>::isValid, "invalid assertion condition"); if
 ((__builtin_expect(!!(!(!!(cx))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("cx", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 73); AnnotateMozCrashReason("MOZ_ASSERT" "(" "cx" ")"); do {
 *((volatile int*)__null) = 73; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false);
74  auto mallocSizeOf = JS::dbg::GetDebuggerMallocSizeOf(cx);
75  MOZ_ASSERT(mallocSizeOf)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mallocSizeOf)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mallocSizeOf))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("mallocSizeOf", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 75); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mallocSizeOf"
 ")"); do { *((volatile int*)__null) = 75; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
76  return mallocSizeOf;
77}
78 
79/*** Cycle Collection Boilerplate *********************************************/
80 
81NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(HeapSnapshot, mParent)static_assert(std::is_base_of<nsWrapperCache, HeapSnapshot
>::value, "Class should inherit nsWrapperCache"); HeapSnapshot
::cycleCollection HeapSnapshot::_cycleCollectorGlobal( nsCycleCollectionParticipant
::FlagMaybeSingleZoneJSHolder); void HeapSnapshot::cycleCollection
::Trace( void* p, const TraceCallbacks& aCallbacks, void*
 aClosure) { HeapSnapshot* tmp = DowncastCCParticipant<HeapSnapshot
>(p); TraceWrapper(p, aCallbacks, aClosure); (void)tmp; } void
 HeapSnapshot::cycleCollection::TraceWrapper( void* p, const TraceCallbacks
& aCallbacks, void* aClosure) { HeapSnapshot* tmp = DowncastCCParticipant
<HeapSnapshot>(p); tmp->TraceWrapper(aCallbacks, aClosure
); } void HeapSnapshot::cycleCollection::Unlink(void* p) { HeapSnapshot
* tmp = DowncastCCParticipant<HeapSnapshot>(p); ImplCycleCollectionUnlink
(tmp->mParent); tmp->ReleaseWrapper(p); (void)tmp; } nsresult
 HeapSnapshot::cycleCollection::TraverseNative( void* p, nsCycleCollectionTraversalCallback
& cb) { HeapSnapshot* tmp = DowncastCCParticipant<HeapSnapshot
>(p); cb.DescribeRefCountedNode(tmp->mRefCnt.get(), "HeapSnapshot"
); ImplCycleCollectionTraverse(cb, tmp->mParent, "mParent"
, 0); (void)tmp; return NS_OK; }
82 
83NS_IMPL_CYCLE_COLLECTING_ADDREF(HeapSnapshot)MozExternalRefCountType HeapSnapshot::AddRef(void) { static_assert
(!std::is_destructible_v<HeapSnapshot>, "Reference-counted class "
 "HeapSnapshot" " should not have a public destructor. " "Make this class's destructor non-public"
); do { static_assert( mozilla::detail::AssertionConditionType
<decltype(int32_t(mRefCnt) >= 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) >= 0))),
 0))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) >= 0"
 " (" "illegal refcnt" ")", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 83); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) >= 0"
 ") (" "illegal refcnt" ")"); do { *((volatile int*)__null) =
 83; __attribute__((nomerge)) ::abort(); } while (false); } }
 while (false); _mOwningThread.AssertOwnership("HeapSnapshot"
 " not thread-safe"); nsISupports* base = HeapSnapshot::cycleCollection
::Upcast(this); nsrefcnt count = mRefCnt.incr(base); NS_LogAddRef
((this), (count), ("HeapSnapshot"), (uint32_t)(sizeof(*this))
); return count; }
84NS_IMPL_CYCLE_COLLECTING_RELEASE(HeapSnapshot)MozExternalRefCountType HeapSnapshot::Release(void) { do { static_assert
( mozilla::detail::AssertionConditionType<decltype(int32_t
(mRefCnt) > 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) > 0))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) > 0"
 " (" "dup release" ")", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 84); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) > 0"
 ") (" "dup release" ")"); do { *((volatile int*)__null) = 84
; __attribute__((nomerge)) ::abort(); } while (false); } } while
 (false); _mOwningThread.AssertOwnership("HeapSnapshot" " not thread-safe"
); nsISupports* base = HeapSnapshot::cycleCollection::Upcast(
this); nsrefcnt count = mRefCnt.decr(base); NS_LogRelease((this
), (count), ("HeapSnapshot")); return count; } void HeapSnapshot
::DeleteCycleCollectable(void) { delete (this); }
85 
86NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(HeapSnapshot)nsresult HeapSnapshot::QueryInterface(const nsIID& aIID, void
** aInstancePtr) { do { if (!(aInstancePtr)) { NS_DebugBreak(
NS_DEBUG_ASSERTION, "QueryInterface requires a non-NULL destination!"
, "aInstancePtr", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 86); MOZ_PretendNoReturn(); } } while (0); nsISupports* foundInterface
; if (TopThreeWordsEquals( aIID, (nsXPCOMCycleCollectionParticipant
::COMTypeInfo<nsXPCOMCycleCollectionParticipant, void>::
kIID), (nsCycleCollectionISupports::COMTypeInfo<nsCycleCollectionISupports
, void>::kIID)) && (LowWordEquals(aIID, (nsXPCOMCycleCollectionParticipant
::COMTypeInfo<nsXPCOMCycleCollectionParticipant, void>::
kIID)) || LowWordEquals(aIID, (nsCycleCollectionISupports::COMTypeInfo
<nsCycleCollectionISupports, void>::kIID)))) { if (LowWordEquals
(aIID, (nsXPCOMCycleCollectionParticipant::COMTypeInfo<nsXPCOMCycleCollectionParticipant
, void>::kIID))) { *aInstancePtr = HeapSnapshot::cycleCollection
::GetParticipant(); return NS_OK; } if (LowWordEquals(aIID, (
nsCycleCollectionISupports::COMTypeInfo<nsCycleCollectionISupports
, void>::kIID))) { *aInstancePtr = HeapSnapshot::cycleCollection
::Upcast(this); return NS_OK; } foundInterface = nullptr; } else
87  NS_WRAPPERCACHE_INTERFACE_MAP_ENTRYif (aIID.Equals((nsWrapperCache::COMTypeInfo<nsWrapperCache
, void>::kIID))) { *aInstancePtr = static_cast<nsWrapperCache
*>(this); return NS_OK; } else
88  NS_INTERFACE_MAP_ENTRY(nsISupports)if (aIID.Equals(mozilla::detail::kImplementedIID<std::remove_reference_t
<decltype(*this)>, nsISupports>)) foundInterface = static_cast
<nsISupports*>(this); else
89NS_INTERFACE_MAP_ENDfoundInterface = 0; nsresult status; if (!foundInterface) { do
 { static_assert( mozilla::detail::AssertionConditionType<
decltype(!aIID.Equals((nsISupports::COMTypeInfo<nsISupports
, void>::kIID)))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!aIID.Equals((nsISupports::COMTypeInfo
<nsISupports, void>::kIID))))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("!aIID.Equals((nsISupports::COMTypeInfo<nsISupports, void>::kIID))"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 89); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!aIID.Equals((nsISupports::COMTypeInfo<nsISupports, void>::kIID))"
 ")"); do { *((volatile int*)__null) = 89; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); status = NS_NOINTERFACE
; } else { (foundInterface)->AddRef(); status = NS_OK; } *
aInstancePtr = foundInterface; return status; }
90 
91/* virtual */
92JSObject* HeapSnapshot::WrapObject(JSContext* aCx,
93                                   JS::Handle<JSObject*> aGivenProto) {
94  return HeapSnapshot_Binding::Wrap(aCx, this, aGivenProto);
95}
96 
97/*** Reading Heap Snapshots ***************************************************/
98 
99/* static */
100already_AddRefed<HeapSnapshot> HeapSnapshot::Create(JSContext* cx,
101                                                    GlobalObject& global,
102                                                    const uint8_t* buffer,
103                                                    uint32_t size,
104                                                    ErrorResult& rv) {
105  RefPtr<HeapSnapshot> snapshot = new HeapSnapshot(cx, global.GetAsSupports());
106  if (!snapshot->init(cx, buffer, size)) {
107    rv.Throw(NS_ERROR_UNEXPECTED);
108    return nullptr;
109  }
110  return snapshot.forget();
111}
112 
113template <typename MessageType>
114static bool parseMessage(ZeroCopyInputStream& stream, uint32_t sizeOfMessage,
115                         MessageType& message) {
116  // We need to create a new `CodedInputStream` for each message so that the
117  // 64MB limit is applied per-message rather than to the whole stream.
118  CodedInputStream codedStream(&stream);
119 
120  // The protobuf message nesting that core dumps exhibit is dominated by
121  // allocation stacks' frames. In the most deeply nested case, each frame has
122  // two messages: a StackFrame message and a StackFrame::Data message. These
123  // frames are on top of a small constant of other messages. There are a
124  // MAX_STACK_DEPTH number of frames, so we multiply this by 3 to make room for
125  // the two messages per frame plus some head room for the constant number of
126  // non-dominating messages.
127  codedStream.SetRecursionLimit(HeapSnapshot::MAX_STACK_DEPTH * 3);
128 
129  auto limit = codedStream.PushLimit(sizeOfMessage);
130  if (NS_WARN_IF(!message.ParseFromCodedStream(&codedStream))NS_warn_if_impl(!message.ParseFromCodedStream(&codedStream
), "!message.ParseFromCodedStream(&codedStream)", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 130) ||
131      NS_WARN_IF(!codedStream.ConsumedEntireMessage())NS_warn_if_impl(!codedStream.ConsumedEntireMessage(), "!codedStream.ConsumedEntireMessage()"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 131) ||
132      NS_WARN_IF(codedStream.BytesUntilLimit() != 0)NS_warn_if_impl(codedStream.BytesUntilLimit() != 0, "codedStream.BytesUntilLimit() != 0"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 132)) {
133    return false;
134  }
135 
136  codedStream.PopLimit(limit);
137  return true;
138}
139 
140template <typename CharT, typename InternedStringSet>
141struct GetOrInternStringMatcher {
142  InternedStringSet& internedStrings;
143 
144  explicit GetOrInternStringMatcher(InternedStringSet& strings)
145      : internedStrings(strings) {}
146 
147  const CharT* operator()(const std::string* str) {
148    MOZ_ASSERT(str)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(str)>::isValid, "invalid assertion condition"); if
 ((__builtin_expect(!!(!(!!(str))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("str", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 148); AnnotateMozCrashReason("MOZ_ASSERT" "(" "str" ")"); do
 { *((volatile int*)__null) = 148; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false);
149    size_t length = str->length() / sizeof(CharT);
150    auto tempString = reinterpret_cast<const CharT*>(str->data());
151 
152    UniqueFreePtr<CharT[]> owned(NS_xstrndup(tempString, length));
153    if (!internedStrings.append(std::move(owned))) return nullptr;
154 
155    return internedStrings.back().get();
156  }
157 
158  const CharT* operator()(uint64_t ref) {
159    if (MOZ_LIKELY(ref < internedStrings.length())(__builtin_expect(!!(ref < internedStrings.length()), 1))) {
160      auto& string = internedStrings[ref];
161      MOZ_ASSERT(string)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(string)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(string))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("string", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 161); AnnotateMozCrashReason("MOZ_ASSERT" "(" "string" ")")
; do { *((volatile int*)__null) = 161; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
162      return string.get();
163    }
164 
165    return nullptr;
166  }
167};
168 
169template <
170    // Either char or char16_t.
171    typename CharT,
172    // A reference to either `internedOneByteStrings` or
173    // `internedTwoByteStrings` if CharT is char or char16_t respectively.
174    typename InternedStringSet>
175const CharT* HeapSnapshot::getOrInternString(
176    InternedStringSet& internedStrings, Maybe<StringOrRef>& maybeStrOrRef) {
177  // Incomplete message: has neither a string nor a reference to an already
178  // interned string.
179  if (MOZ_UNLIKELY(maybeStrOrRef.isNothing())(__builtin_expect(!!(maybeStrOrRef.isNothing()), 0))) return nullptr;
180 
181  GetOrInternStringMatcher<CharT, InternedStringSet> m(internedStrings);
182  return maybeStrOrRef->match(m);
183}
184 
185// Get a de-duplicated string as a Maybe<StringOrRef> from the given `msg`.
186#define GET_STRING_OR_REF_WITH_PROP_NAMES(msg, strPropertyName,              \
187                                          refPropertyName)                   \
188  (msg.has_##refPropertyName()   ? Some(StringOrRef(msg.refPropertyName()))  \
189   : msg.has_##strPropertyName() ? Some(StringOrRef(&msg.strPropertyName())) \
190                                 : Nothing())
191 
192#define GET_STRING_OR_REF(msg, property)                              \
193  (msg.has_##property##ref() ? Some(StringOrRef(msg.property##ref())) \
194   : msg.has_##property()    ? Some(StringOrRef(&msg.property()))     \
195                             : Nothing())
196 
197bool HeapSnapshot::saveNode(const protobuf::Node& node,
198                            NodeIdSet& edgeReferents) {
199  // NB: de-duplicated string properties must be read back and interned in the
200  // same order here as they are written and serialized in
201  // `CoreDumpWriter::writeNode` or else indices in references to already
202  // serialized strings will be off.
203 
204  if (NS_WARN_IF(!node.has_id())NS_warn_if_impl(!node.has_id(), "!node.has_id()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 204)) return false;
205  NodeId id = node.id();
206 
207  // NodeIds are derived from pointers (at most 48 bits) and we rely on them
208  // fitting into JS numbers (IEEE 754 doubles, can precisely store 53 bit
209  // integers) despite storing them on disk as 64 bit integers.
210  if (NS_WARN_IF(!JS::Value::isNumberRepresentable(id))NS_warn_if_impl(!JS::Value::isNumberRepresentable(id), "!JS::Value::isNumberRepresentable(id)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 210)) return false;
211 
212  // Should only deserialize each node once.
213  if (NS_WARN_IF(nodes.has(id))NS_warn_if_impl(nodes.has(id), "nodes.has(id)", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 213)) return false;
214 
215  if (NS_WARN_IF(!JS::ubi::Uint32IsValidCoarseType(node.coarsetype()))NS_warn_if_impl(!JS::ubi::Uint32IsValidCoarseType(node.coarsetype
()), "!JS::ubi::Uint32IsValidCoarseType(node.coarsetype())", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 215))
216    return false;
217  auto coarseType = JS::ubi::Uint32ToCoarseType(node.coarsetype());
218 
219  Maybe<StringOrRef> typeNameOrRef =
220      GET_STRING_OR_REF_WITH_PROP_NAMES(node, typename_, typenameref);
221  auto typeName =
222      getOrInternString<char16_t>(internedTwoByteStrings, typeNameOrRef);
223  if (NS_WARN_IF(!typeName)NS_warn_if_impl(!typeName, "!typeName", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 223)) return false;
224 
225  if (NS_WARN_IF(!node.has_size())NS_warn_if_impl(!node.has_size(), "!node.has_size()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 225)) return false;
226  uint64_t size = node.size();
227 
228  auto edgesLength = node.edges_size();
229  DeserializedNode::EdgeVector edges;
230  if (NS_WARN_IF(!edges.reserve(edgesLength))NS_warn_if_impl(!edges.reserve(edgesLength), "!edges.reserve(edgesLength)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 230)) return false;
231  for (decltype(edgesLength) i = 0; i < edgesLength; i++) {
232    auto& protoEdge = node.edges(i);
233 
234    if (NS_WARN_IF(!protoEdge.has_referent())NS_warn_if_impl(!protoEdge.has_referent(), "!protoEdge.has_referent()"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 234)) return false;
235    NodeId referent = protoEdge.referent();
236 
237    if (NS_WARN_IF(!edgeReferents.put(referent))NS_warn_if_impl(!edgeReferents.put(referent), "!edgeReferents.put(referent)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 237)) return false;
238 
239    const char16_t* edgeName = nullptr;
240    if (protoEdge.EdgeNameOrRef_case() !=
241        protobuf::Edge::EDGENAMEORREF_NOT_SET) {
242      Maybe<StringOrRef> edgeNameOrRef = GET_STRING_OR_REF(protoEdge, name);
243      edgeName =
244          getOrInternString<char16_t>(internedTwoByteStrings, edgeNameOrRef);
245      if (NS_WARN_IF(!edgeName)NS_warn_if_impl(!edgeName, "!edgeName", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 245)) return false;
246    }
247 
248    edges.infallibleAppend(DeserializedEdge(referent, edgeName));
249  }
250 
251  Maybe<StackFrameId> allocationStack;
252  if (node.has_allocationstack()) {
253    StackFrameId id = 0;
254    if (NS_WARN_IF(!saveStackFrame(node.allocationstack(), id))NS_warn_if_impl(!saveStackFrame(node.allocationstack(), id), "!saveStackFrame(node.allocationstack(), id)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 254)) return false;
255    allocationStack.emplace(id);
256  }
257  MOZ_ASSERT(allocationStack.isSome() == node.has_allocationstack())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(allocationStack.isSome() == node.has_allocationstack
())>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(allocationStack.isSome() == node.has_allocationstack
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("allocationStack.isSome() == node.has_allocationstack()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 257); AnnotateMozCrashReason("MOZ_ASSERT" "(" "allocationStack.isSome() == node.has_allocationstack()"
 ")"); do { *((volatile int*)__null) = 257; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
258 
259  const char* jsObjectClassName = nullptr;
260  if (node.JSObjectClassNameOrRef_case() !=
261      protobuf::Node::JSOBJECTCLASSNAMEORREF_NOT_SET) {
262    Maybe<StringOrRef> clsNameOrRef =
263        GET_STRING_OR_REF(node, jsobjectclassname);
264    jsObjectClassName =
265        getOrInternString<char>(internedOneByteStrings, clsNameOrRef);
266    if (NS_WARN_IF(!jsObjectClassName)NS_warn_if_impl(!jsObjectClassName, "!jsObjectClassName", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 266)) return false;
267  }
268 
269  const char* scriptFilename = nullptr;
270  if (node.ScriptFilenameOrRef_case() !=
271      protobuf::Node::SCRIPTFILENAMEORREF_NOT_SET) {
272    Maybe<StringOrRef> scriptFilenameOrRef =
273        GET_STRING_OR_REF(node, scriptfilename);
274    scriptFilename =
275        getOrInternString<char>(internedOneByteStrings, scriptFilenameOrRef);
276    if (NS_WARN_IF(!scriptFilename)NS_warn_if_impl(!scriptFilename, "!scriptFilename", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 276)) return false;
277  }
278 
279  const char16_t* descriptiveTypeName = nullptr;
280  if (node.descriptiveTypeNameOrRef_case() !=
281      protobuf::Node::DESCRIPTIVETYPENAMEORREF_NOT_SET) {
282    Maybe<StringOrRef> descriptiveTypeNameOrRef =
283        GET_STRING_OR_REF(node, descriptivetypename);
284    descriptiveTypeName = getOrInternString<char16_t>(internedTwoByteStrings,
285                                                      descriptiveTypeNameOrRef);
286    if (NS_WARN_IF(!descriptiveTypeName)NS_warn_if_impl(!descriptiveTypeName, "!descriptiveTypeName",
 "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 286)) return false;
287  }
288 
289  if (NS_WARN_IF(!nodes.putNew(NS_warn_if_impl(!nodes.putNew( id, DeserializedNode(id, coarseType
, typeName, size, std::move(edges), allocationStack, jsObjectClassName
, scriptFilename, descriptiveTypeName, *this)), "!nodes.putNew( id, DeserializedNode(id, coarseType, typeName, size, std::move(edges), allocationStack, jsObjectClassName, scriptFilename, descriptiveTypeName, *this))"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 292)
290          id, DeserializedNode(id, coarseType, typeName, size, std::move(edges),NS_warn_if_impl(!nodes.putNew( id, DeserializedNode(id, coarseType
, typeName, size, std::move(edges), allocationStack, jsObjectClassName
, scriptFilename, descriptiveTypeName, *this)), "!nodes.putNew( id, DeserializedNode(id, coarseType, typeName, size, std::move(edges), allocationStack, jsObjectClassName, scriptFilename, descriptiveTypeName, *this))"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 292)
291                               allocationStack, jsObjectClassName,NS_warn_if_impl(!nodes.putNew( id, DeserializedNode(id, coarseType
, typeName, size, std::move(edges), allocationStack, jsObjectClassName
, scriptFilename, descriptiveTypeName, *this)), "!nodes.putNew( id, DeserializedNode(id, coarseType, typeName, size, std::move(edges), allocationStack, jsObjectClassName, scriptFilename, descriptiveTypeName, *this))"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 292)
292                               scriptFilename, descriptiveTypeName, *this)))NS_warn_if_impl(!nodes.putNew( id, DeserializedNode(id, coarseType
, typeName, size, std::move(edges), allocationStack, jsObjectClassName
, scriptFilename, descriptiveTypeName, *this)), "!nodes.putNew( id, DeserializedNode(id, coarseType, typeName, size, std::move(edges), allocationStack, jsObjectClassName, scriptFilename, descriptiveTypeName, *this))"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 292)) {
293    return false;
294  };
295 
296  return true;
297}
298 
299bool HeapSnapshot::saveStackFrame(const protobuf::StackFrame& frame,
300                                  StackFrameId& outFrameId) {
301  // NB: de-duplicated string properties must be read in the same order here as
302  // they are written in `CoreDumpWriter::getProtobufStackFrame` or else indices
303  // in references to already serialized strings will be off.
304 
305  if (frame.has_ref()) {
306    // We should only get a reference to the previous frame if we have already
307    // seen the previous frame.
308    if (!frames.has(frame.ref())) return false;
309 
310    outFrameId = frame.ref();
311    return true;
312  }
313 
314  // Incomplete message.
315  if (!frame.has_data()) return false;
316 
317  auto data = frame.data();
318 
319  if (!data.has_id()) return false;
320  StackFrameId id = data.id();
321 
322  // This should be the first and only time we see this frame.
323  if (frames.has(id)) return false;
324 
325  if (!data.has_line()) return false;
326  uint32_t line = data.line();
327 
328  if (!data.has_column()) return false;
329  JS::TaggedColumnNumberOneOrigin column(
330      JS::LimitedColumnNumberOneOrigin(data.column()));
331 
332  if (!data.has_issystem()) return false;
333  bool isSystem = data.issystem();
334 
335  if (!data.has_isselfhosted()) return false;
336  bool isSelfHosted = data.isselfhosted();
337 
338  Maybe<StringOrRef> sourceOrRef = GET_STRING_OR_REF(data, source);
339  auto source =
340      getOrInternString<char16_t>(internedTwoByteStrings, sourceOrRef);
341  if (!source) return false;
342 
343  const char16_t* functionDisplayName = nullptr;
344  if (data.FunctionDisplayNameOrRef_case() !=
345      protobuf::StackFrame_Data::FUNCTIONDISPLAYNAMEORREF_NOT_SET) {
346    Maybe<StringOrRef> nameOrRef = GET_STRING_OR_REF(data, functiondisplayname);
347    functionDisplayName =
348        getOrInternString<char16_t>(internedTwoByteStrings, nameOrRef);
349    if (!functionDisplayName) return false;
350  }
351 
352  Maybe<StackFrameId> parent;
353  if (data.has_parent()) {
354    StackFrameId parentId = 0;
355    if (!saveStackFrame(data.parent(), parentId)) return false;
356    parent = Some(parentId);
357  }
358 
359  if (!frames.putNew(id,
360                     DeserializedStackFrame(id, parent, line, column, source,
361                                            functionDisplayName, isSystem,
362                                            isSelfHosted, *this))) {
363    return false;
364  }
365 
366  outFrameId = id;
367  return true;
368}
369 
370#undef GET_STRING_OR_REF_WITH_PROP_NAMES
371#undef GET_STRING_OR_REF
372 
373// Because protobuf messages aren't self-delimiting, we serialize each message
374// preceded by its size in bytes. When deserializing, we read this size and then
375// limit reading from the stream to the given byte size. If we didn't, then the
376// first message would consume the entire stream.
377static bool readSizeOfNextMessage(ZeroCopyInputStream& stream,
378                                  uint32_t* sizep) {
379  MOZ_ASSERT(sizep)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(sizep)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(sizep))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("sizep", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 379); AnnotateMozCrashReason("MOZ_ASSERT" "(" "sizep" ")");
 do { *((volatile int*)__null) = 379; __attribute__((nomerge)
) ::abort(); } while (false); } } while (false);
380  CodedInputStream codedStream(&stream);
381  return codedStream.ReadVarint32(sizep) && *sizep > 0;
382}
383 
384bool HeapSnapshot::init(JSContext* cx, const uint8_t* buffer, uint32_t size) {
385  ArrayInputStream stream(buffer, size);
386  GzipInputStream gzipStream(&stream);
387  uint32_t sizeOfMessage = 0;
388 
389  // First is the metadata.
390 
391  protobuf::Metadata metadata;
392  if (NS_WARN_IF(!readSizeOfNextMessage(gzipStream, &sizeOfMessage))NS_warn_if_impl(!readSizeOfNextMessage(gzipStream, &sizeOfMessage
), "!readSizeOfNextMessage(gzipStream, &sizeOfMessage)", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 392))
393    return false;
394  if (!parseMessage(gzipStream, sizeOfMessage, metadata)) return false;
395  if (metadata.has_timestamp()) timestamp.emplace(metadata.timestamp());
396 
397  // Next is the root node.
398 
399  protobuf::Node root;
400  if (NS_WARN_IF(!readSizeOfNextMessage(gzipStream, &sizeOfMessage))NS_warn_if_impl(!readSizeOfNextMessage(gzipStream, &sizeOfMessage
), "!readSizeOfNextMessage(gzipStream, &sizeOfMessage)", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 400))
401    return false;
402  if (!parseMessage(gzipStream, sizeOfMessage, root)) return false;
403 
404  // Although the id is optional in the protobuf format for future proofing, we
405  // can't currently do anything without it.
406  if (NS_WARN_IF(!root.has_id())NS_warn_if_impl(!root.has_id(), "!root.has_id()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 406)) return false;
407  rootId = root.id();
408 
409  // The set of all node ids we've found edges pointing to.
410  NodeIdSet edgeReferents(cx);
411 
412  if (NS_WARN_IF(!saveNode(root, edgeReferents))NS_warn_if_impl(!saveNode(root, edgeReferents), "!saveNode(root, edgeReferents)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 412)) return false;
413 
414  // Finally, the rest of the nodes in the core dump.
415 
416  // Test for the end of the stream. The protobuf library gives no way to tell
417  // the difference between an underlying read error and the stream being
418  // done. All we can do is attempt to read the size of the next message and
419  // extrapolate guestimations from the result of that operation.
420  while (readSizeOfNextMessage(gzipStream, &sizeOfMessage)) {
421    protobuf::Node node;
422    if (!parseMessage(gzipStream, sizeOfMessage, node)) return false;
423    if (NS_WARN_IF(!saveNode(node, edgeReferents))NS_warn_if_impl(!saveNode(node, edgeReferents), "!saveNode(node, edgeReferents)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 423)) return false;
424  }
425 
426  // Check the set of node ids referred to by edges we found and ensure that we
427  // have the node corresponding to each id. If we don't have all of them, it is
428  // unsafe to perform analyses of this heap snapshot.
429  for (auto iter = edgeReferents.iter(); !iter.done(); iter.next()) {
430    if (NS_WARN_IF(!nodes.has(iter.get()))NS_warn_if_impl(!nodes.has(iter.get()), "!nodes.has(iter.get())"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 430)) return false;
431  }
432 
433  return true;
434}
435 
436/*** Heap Snapshot Analyses ***************************************************/
437 
438void HeapSnapshot::TakeCensus(JSContext* cx, JS::Handle<JSObject*> options,
439                              JS::MutableHandle<JS::Value> rval,
440                              ErrorResult& rv) {
441  JS::ubi::Census census(cx);
442 
443  JS::ubi::CountTypePtr rootType;
444  if (NS_WARN_IF(!JS::ubi::ParseCensusOptions(cx, census, options, rootType))NS_warn_if_impl(!JS::ubi::ParseCensusOptions(cx, census, options
, rootType), "!JS::ubi::ParseCensusOptions(cx, census, options, rootType)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 444)) {
445    rv.Throw(NS_ERROR_UNEXPECTED);
446    return;
447  }
448 
449  JS::ubi::RootedCount rootCount(cx, rootType->makeCount());
450  if (NS_WARN_IF(!rootCount)NS_warn_if_impl(!rootCount, "!rootCount", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 450)) {
451    rv.Throw(NS_ERROR_OUT_OF_MEMORY);
452    return;
453  }
454 
455  JS::ubi::CensusHandler handler(census, rootCount,
456                                 GetCurrentThreadDebuggerMallocSizeOf());
457 
458  {
459    JS::AutoCheckCannotGC nogc;
460 
461    JS::ubi::CensusTraversal traversal(cx, handler, nogc);
462 
463    if (NS_WARN_IF(!traversal.addStart(getRoot()))NS_warn_if_impl(!traversal.addStart(getRoot()), "!traversal.addStart(getRoot())"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 463)) {
464      rv.Throw(NS_ERROR_OUT_OF_MEMORY);
465      return;
466    }
467 
468    if (NS_WARN_IF(!traversal.traverse())NS_warn_if_impl(!traversal.traverse(), "!traversal.traverse()"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 468)) {
469      rv.Throw(NS_ERROR_UNEXPECTED);
470      return;
471    }
472  }
473 
474  if (NS_WARN_IF(!handler.report(cx, rval))NS_warn_if_impl(!handler.report(cx, rval), "!handler.report(cx, rval)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 474)) {
475    rv.Throw(NS_ERROR_OUT_OF_MEMORY);
476    return;
477  }
478}
479 
480void HeapSnapshot::DescribeNode(JSContext* cx, JS::Handle<JSObject*> breakdown,
481                                uint64_t nodeId,
482                                JS::MutableHandle<JS::Value> rval,
483                                ErrorResult& rv) {
484  MOZ_ASSERT(breakdown)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(breakdown)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(breakdown))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("breakdown", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 484); AnnotateMozCrashReason("MOZ_ASSERT" "(" "breakdown" ")"
); do { *((volatile int*)__null) = 484; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
485  JS::Rooted<JS::Value> breakdownVal(cx, JS::ObjectValue(*breakdown));
486  JS::Rooted<JS::GCVector<JSLinearString*>> seen(cx, cx);
487  JS::ubi::CountTypePtr rootType =
488      JS::ubi::ParseBreakdown(cx, breakdownVal, &seen);
489  if (NS_WARN_IF(!rootType)NS_warn_if_impl(!rootType, "!rootType", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 489)) {
490    rv.Throw(NS_ERROR_UNEXPECTED);
491    return;
492  }
493 
494  JS::ubi::RootedCount rootCount(cx, rootType->makeCount());
495  if (NS_WARN_IF(!rootCount)NS_warn_if_impl(!rootCount, "!rootCount", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 495)) {
496    rv.Throw(NS_ERROR_OUT_OF_MEMORY);
497    return;
498  }
499 
500  JS::ubi::Node::Id id(nodeId);
501  Maybe<JS::ubi::Node> node = getNodeById(id);
502  if (NS_WARN_IF(node.isNothing())NS_warn_if_impl(node.isNothing(), "node.isNothing()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 502)) {
503    rv.Throw(NS_ERROR_INVALID_ARG);
504    return;
505  }
506 
507  MallocSizeOf mallocSizeOf = GetCurrentThreadDebuggerMallocSizeOf();
508  if (NS_WARN_IF(!rootCount->count(mallocSizeOf, *node))NS_warn_if_impl(!rootCount->count(mallocSizeOf, *node), "!rootCount->count(mallocSizeOf, *node)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 508)) {
509    rv.Throw(NS_ERROR_OUT_OF_MEMORY);
510    return;
511  }
512 
513  if (NS_WARN_IF(!rootCount->report(cx, rval))NS_warn_if_impl(!rootCount->report(cx, rval), "!rootCount->report(cx, rval)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 513)) {
514    rv.Throw(NS_ERROR_OUT_OF_MEMORY);
515    return;
516  }
517}
518 
519already_AddRefed<DominatorTree> HeapSnapshot::ComputeDominatorTree(
520    ErrorResult& rv) {
521  Maybe<JS::ubi::DominatorTree> maybeTree;
522  {
523    auto ccjscx = CycleCollectedJSContext::Get();
524    MOZ_ASSERT(ccjscx)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(ccjscx)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(ccjscx))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("ccjscx", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 524); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ccjscx" ")")
; do { *((volatile int*)__null) = 524; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
525    auto cx = ccjscx->Context();
526    MOZ_ASSERT(cx)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(cx)>::isValid, "invalid assertion condition"); if
 ((__builtin_expect(!!(!(!!(cx))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("cx", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 526); AnnotateMozCrashReason("MOZ_ASSERT" "(" "cx" ")"); do
 { *((volatile int*)__null) = 526; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false);
527    JS::AutoCheckCannotGC nogc(cx);
528    maybeTree = JS::ubi::DominatorTree::Create(cx, nogc, getRoot());
529  }
530 
531  if (NS_WARN_IF(maybeTree.isNothing())NS_warn_if_impl(maybeTree.isNothing(), "maybeTree.isNothing()"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 531)) {
532    rv.Throw(NS_ERROR_OUT_OF_MEMORY);
533    return nullptr;
534  }
535 
536  return MakeAndAddRef<DominatorTree>(std::move(*maybeTree), this, mParent);
537}
538 
539void HeapSnapshot::ComputeShortestPaths(JSContext* cx, uint64_t start,
540                                        const Sequence<uint64_t>& targets,
541                                        uint64_t maxNumPaths,
542                                        JS::MutableHandle<JSObject*> results,
543                                        ErrorResult& rv) {
544  // First ensure that our inputs are valid.
545 
546  if (NS_WARN_IF(maxNumPaths == 0)NS_warn_if_impl(maxNumPaths == 0, "maxNumPaths == 0", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 546)) {
1
Assuming 'maxNumPaths' is not equal to 0→
2
←
Taking false branch→
547    rv.Throw(NS_ERROR_INVALID_ARG);
548    return;
549  }
550 
551  Maybe<JS::ubi::Node> startNode = getNodeById(start);
552  if (NS_WARN_IF(startNode.isNothing())NS_warn_if_impl(startNode.isNothing(), "startNode.isNothing()"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 552)) {
3
←
Taking false branch→
553    rv.Throw(NS_ERROR_INVALID_ARG);
554    return;
555  }
556 
557  if (NS_WARN_IF(targets.Length() == 0)NS_warn_if_impl(targets.Length() == 0, "targets.Length() == 0"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 557)) {
4
←
Assuming the condition is false→
5
←
Taking false branch→
558    rv.Throw(NS_ERROR_INVALID_ARG);
559    return;
560  }
561 
562  // Aggregate the targets into a set and make sure that they exist in the heap
563  // snapshot.
564 
565  JS::ubi::NodeSet targetsSet;
566 
567  for (const auto& target : targets) {
568    Maybe<JS::ubi::Node> targetNode = getNodeById(target);
569    if (NS_WARN_IF(targetNode.isNothing())NS_warn_if_impl(targetNode.isNothing(), "targetNode.isNothing()"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 569)) {
6
←
Taking false branch→
570      rv.Throw(NS_ERROR_INVALID_ARG);
571      return;
572    }
573 
574    if (NS_WARN_IF(!targetsSet.put(*targetNode))NS_warn_if_impl(!targetsSet.put(*targetNode), "!targetsSet.put(*targetNode)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 574)) {
7
←
Assuming the condition is false→
8
←
Taking false branch→
575      rv.Throw(NS_ERROR_OUT_OF_MEMORY);
576      return;
577    }
578  }
579 
580  // Walk the heap graph and find the shortest paths.
581 
582  Maybe<ShortestPaths> maybeShortestPaths;
583  {
584    JS::AutoCheckCannotGC nogc(cx);
585    maybeShortestPaths = ShortestPaths::Create(
586        cx, nogc, maxNumPaths, *startNode, std::move(targetsSet));
587  }
588 
589  if (NS_WARN_IF(maybeShortestPaths.isNothing())NS_warn_if_impl(maybeShortestPaths.isNothing(), "maybeShortestPaths.isNothing()"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 589)) {
9
←
Taking false branch→
590    rv.Throw(NS_ERROR_OUT_OF_MEMORY);
591    return;
592  }
593 
594  auto& shortestPaths = *maybeShortestPaths;
595 
596  // Convert the results into a Map object mapping target node IDs to arrays of
597  // paths found.
598 
599  JS::Rooted<JSObject*> resultsMap(cx, JS::NewMapObject(cx));
600  if (NS_WARN_IF(!resultsMap)NS_warn_if_impl(!resultsMap, "!resultsMap", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 600)) {
10
←
Taking true branch→
601    rv.Throw(NS_ERROR_OUT_OF_MEMORY);
602    return;
11
←
Calling implicit destructor for 'Maybe<JS::ubi::ShortestPaths>'→
12
←
Calling '~MaybeStorage'→
603  }
604 
605  for (auto iter = shortestPaths.targetIter(); !iter.done(); iter.next()) {
606    JS::Rooted<JS::Value> key(cx, JS::NumberValue(iter.get().identifier()));
607    JS::RootedVector<JS::Value> paths(cx);
608 
609    bool ok = shortestPaths.forEachPath(iter.get(), [&](JS::ubi::Path& path) {
610      JS::RootedVector<JS::Value> pathValues(cx);
611 
612      for (JS::ubi::BackEdge* edge : path) {
613        JS::Rooted<JSObject*> pathPart(cx, JS_NewPlainObject(cx));
614        if (!pathPart) {
615          return false;
616        }
617 
618        JS::Rooted<JS::Value> predecessor(
619            cx, NumberValue(edge->predecessor().identifier()));
620        if (!JS_DefineProperty(cx, pathPart, "predecessor", predecessor,
621                               JSPROP_ENUMERATE)) {
622          return false;
623        }
624 
625        JS::Rooted<JS::Value> edgeNameVal(cx, NullValue());
626        if (edge->name()) {
627          JS::Rooted<JSString*> edgeName(
628              cx, JS_AtomizeUCString(cx, edge->name().get()));
629          if (!edgeName) {
630            return false;
631          }
632          edgeNameVal = StringValue(edgeName);
633        }
634 
635        if (!JS_DefineProperty(cx, pathPart, "edge", edgeNameVal,
636                               JSPROP_ENUMERATE)) {
637          return false;
638        }
639 
640        if (!pathValues.append(ObjectValue(*pathPart))) {
641          return false;
642        }
643      }
644 
645      JS::Rooted<JSObject*> pathObj(cx, JS::NewArrayObject(cx, pathValues));
646      return pathObj && paths.append(ObjectValue(*pathObj));
647    });
648 
649    if (NS_WARN_IF(!ok)NS_warn_if_impl(!ok, "!ok", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 649)) {
650      rv.Throw(NS_ERROR_OUT_OF_MEMORY);
651      return;
652    }
653 
654    JS::Rooted<JSObject*> pathsArray(cx, JS::NewArrayObject(cx, paths));
655    if (NS_WARN_IF(!pathsArray)NS_warn_if_impl(!pathsArray, "!pathsArray", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 655)) {
656      rv.Throw(NS_ERROR_OUT_OF_MEMORY);
657      return;
658    }
659 
660    JS::Rooted<JS::Value> pathsVal(cx, ObjectValue(*pathsArray));
661    if (NS_WARN_IF(!JS::MapSet(cx, resultsMap, key, pathsVal))NS_warn_if_impl(!JS::MapSet(cx, resultsMap, key, pathsVal), "!JS::MapSet(cx, resultsMap, key, pathsVal)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 661)) {
662      rv.Throw(NS_ERROR_OUT_OF_MEMORY);
663      return;
664    }
665  }
666 
667  results.set(resultsMap);
668}
669 
670/*** Saving Heap Snapshots ****************************************************/
671 
672// If we are only taking a snapshot of the heap affected by the given set of
673// globals, find the set of compartments the globals are allocated
674// within. Returns false on OOM failure.
675static bool PopulateCompartmentsWithGlobals(
676    CompartmentSet& compartments, JS::HandleVector<JSObject*> globals) {
677  unsigned length = globals.length();
678  for (unsigned i = 0; i < length; i++) {
679    if (!compartments.put(JS::GetCompartment(globals[i]))) return false;
680  }
681 
682  return true;
683}
684 
685// Add the given set of globals as explicit roots in the given roots
686// list. Returns false on OOM failure.
687static bool AddGlobalsAsRoots(JS::HandleVector<JSObject*> globals,
688                              ubi::RootList& roots) {
689  unsigned length = globals.length();
690  for (unsigned i = 0; i < length; i++) {
691    if (!roots.addRoot(ubi::Node(globals[i].get()), u"heap snapshot global")) {
692      return false;
693    }
694  }
695  return true;
696}
697 
698// Choose roots and limits for a traversal, given `boundaries`. Set `roots` to
699// the set of nodes within the boundaries that are referred to by nodes
700// outside. If `boundaries` does not include all JS compartments, initialize
701// `compartments` to the set of included compartments; otherwise, leave
702// `compartments` uninitialized. (You can use compartments.initialized() to
703// check.)
704//
705// If `boundaries` is incoherent, or we encounter an error while trying to
706// handle it, or we run out of memory, set `rv` appropriately and return
707// `false`.
708//
709// Return value is a pair of the status and an AutoCheckCannotGC token,
710// forwarded from ubi::RootList::init(), to ensure that the caller does
711// not GC while the RootList is live and initialized.
712static std::pair<bool, AutoCheckCannotGC> EstablishBoundaries(
713    JSContext* cx, ErrorResult& rv, const HeapSnapshotBoundaries& boundaries,
714    ubi::RootList& roots, CompartmentSet& compartments) {
715  MOZ_ASSERT(!roots.initialized())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!roots.initialized())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!roots.initialized()))), 0))
) { do { } while (false); MOZ_ReportAssertionFailure("!roots.initialized()"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 715); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!roots.initialized()"
 ")"); do { *((volatile int*)__null) = 715; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
716  MOZ_ASSERT(compartments.empty())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(compartments.empty())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(compartments.empty()))), 0))
) { do { } while (false); MOZ_ReportAssertionFailure("compartments.empty()"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 716); AnnotateMozCrashReason("MOZ_ASSERT" "(" "compartments.empty()"
 ")"); do { *((volatile int*)__null) = 716; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
717 
718  bool foundBoundaryProperty = false;
719 
720  if (boundaries.mRuntime.WasPassed()) {
721    foundBoundaryProperty = true;
722 
723    if (!boundaries.mRuntime.Value()) {
724      rv.Throw(NS_ERROR_INVALID_ARG);
725      return {false, AutoCheckCannotGC(cx)};
726    }
727 
728    auto [ok, nogc] = roots.init();
729    if (!ok) {
730      rv.Throw(NS_ERROR_OUT_OF_MEMORY);
731      return {false, nogc};
732    }
733  }
734 
735  if (boundaries.mDebugger.WasPassed()) {
736    if (foundBoundaryProperty) {
737      rv.Throw(NS_ERROR_INVALID_ARG);
738      return {false, AutoCheckCannotGC(cx)};
739    }
740    foundBoundaryProperty = true;
741 
742    JSObject* dbgObj = boundaries.mDebugger.Value();
743    if (!dbgObj || !dbg::IsDebugger(*dbgObj)) {
744      rv.Throw(NS_ERROR_INVALID_ARG);
745      return {false, AutoCheckCannotGC(cx)};
746    }
747 
748    JS::RootedVector<JSObject*> globals(cx);
749    if (!dbg::GetDebuggeeGlobals(cx, *dbgObj, &globals) ||
750        !PopulateCompartmentsWithGlobals(compartments, globals) ||
751        !roots.init(compartments).first || !AddGlobalsAsRoots(globals, roots)) {
752      rv.Throw(NS_ERROR_OUT_OF_MEMORY);
753      return {false, AutoCheckCannotGC(cx)};
754    }
755  }
756 
757  if (boundaries.mGlobals.WasPassed()) {
758    if (foundBoundaryProperty) {
759      rv.Throw(NS_ERROR_INVALID_ARG);
760      return {false, AutoCheckCannotGC(cx)};
761    }
762    foundBoundaryProperty = true;
763 
764    uint32_t length = boundaries.mGlobals.Value().Length();
765    if (length == 0) {
766      rv.Throw(NS_ERROR_INVALID_ARG);
767      return {false, AutoCheckCannotGC(cx)};
768    }
769 
770    JS::RootedVector<JSObject*> globals(cx);
771    for (uint32_t i = 0; i < length; i++) {
772      JSObject* global = boundaries.mGlobals.Value().ElementAt(i);
773      if (!JS_IsGlobalObject(global)) {
774        rv.Throw(NS_ERROR_INVALID_ARG);
775        return {false, AutoCheckCannotGC(cx)};
776      }
777      if (!globals.append(global)) {
778        rv.Throw(NS_ERROR_OUT_OF_MEMORY);
779        return {false, AutoCheckCannotGC(cx)};
780      }
781    }
782 
783    if (!PopulateCompartmentsWithGlobals(compartments, globals) ||
784        !roots.init(compartments).first || !AddGlobalsAsRoots(globals, roots)) {
785      rv.Throw(NS_ERROR_OUT_OF_MEMORY);
786      return {false, AutoCheckCannotGC(cx)};
787    }
788  }
789  AutoCheckCannotGC nogc(cx);
790 
791  if (!foundBoundaryProperty) {
792    rv.Throw(NS_ERROR_INVALID_ARG);
793    return {false, nogc};
794  }
795 
796  MOZ_ASSERT(roots.initialized())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(roots.initialized())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(roots.initialized()))), 0)))
 { do { } while (false); MOZ_ReportAssertionFailure("roots.initialized()"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 796); AnnotateMozCrashReason("MOZ_ASSERT" "(" "roots.initialized()"
 ")"); do { *((volatile int*)__null) = 796; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
797  return {true, nogc};
798}
799 
800// A variant covering all the various two-byte strings that we can get from the
801// ubi::Node API.
802class TwoByteString
803    : public Variant<JSAtom*, const char16_t*, JS::ubi::EdgeName> {
804  using Base = Variant<JSAtom*, const char16_t*, JS::ubi::EdgeName>;
805 
806  struct CopyToBufferMatcher {
807    RangedPtr<char16_t> destination;
808    size_t maxLength;
809 
810    CopyToBufferMatcher(RangedPtr<char16_t> destination, size_t maxLength)
811        : destination(destination), maxLength(maxLength) {}
812 
813    size_t operator()(JS::ubi::EdgeName& ptr) {
814      return ptr ? operator()(ptr.get()) : 0;
815    }
816 
817    size_t operator()(JSAtom* atom) {
818      MOZ_ASSERT(atom)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(atom)>::isValid, "invalid assertion condition"); if
 ((__builtin_expect(!!(!(!!(atom))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("atom", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 818); AnnotateMozCrashReason("MOZ_ASSERT" "(" "atom" ")"); do
 { *((volatile int*)__null) = 818; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false);
819      JS::ubi::AtomOrTwoByteChars s(atom);
820      return s.copyToBuffer(destination, maxLength);
821    }
822 
823    size_t operator()(const char16_t* chars) {
824      MOZ_ASSERT(chars)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(chars)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(chars))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("chars", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 824); AnnotateMozCrashReason("MOZ_ASSERT" "(" "chars" ")");
 do { *((volatile int*)__null) = 824; __attribute__((nomerge)
) ::abort(); } while (false); } } while (false);
825      JS::ubi::AtomOrTwoByteChars s(chars);
826      return s.copyToBuffer(destination, maxLength);
827    }
828  };
829 
830 public:
831  template <typename T>
832  MOZ_IMPLICIT TwoByteString(T&& rhs) : Base(std::forward<T>(rhs)) {}
833 
834  template <typename T>
835  TwoByteString& operator=(T&& rhs) {
836    MOZ_ASSERT(this != &rhs, "self-move disallowed")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(this != &rhs)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(this != &rhs))), 0))) { do
 { } while (false); MOZ_ReportAssertionFailure("this != &rhs"
 " (" "self-move disallowed" ")", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 836); AnnotateMozCrashReason("MOZ_ASSERT" "(" "this != &rhs"
 ") (" "self-move disallowed" ")"); do { *((volatile int*)__null
) = 836; __attribute__((nomerge)) ::abort(); } while (false);
 } } while (false);
837    this->~TwoByteString();
838    new (this) TwoByteString(std::forward<T>(rhs));
839    return *this;
840  }
841 
842  TwoByteString(const TwoByteString&) = delete;
843  TwoByteString& operator=(const TwoByteString&) = delete;
844 
845  // Rewrap the inner value of a JS::ubi::AtomOrTwoByteChars as a TwoByteString.
846  static TwoByteString from(JS::ubi::AtomOrTwoByteChars&& s) {
847    return s.match([](auto* a) { return TwoByteString(a); });
848  }
849 
850  // Returns true if the given TwoByteString is non-null, false otherwise.
851  bool isNonNull() const {
852    return match([](auto& t) { return t != nullptr; });
853  }
854 
855  // Return the length of the string, 0 if it is null.
856  size_t length() const {
857    return match(
858        [](JSAtom* atom) -> size_t {
859          MOZ_ASSERT(atom)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(atom)>::isValid, "invalid assertion condition"); if
 ((__builtin_expect(!!(!(!!(atom))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("atom", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 859); AnnotateMozCrashReason("MOZ_ASSERT" "(" "atom" ")"); do
 { *((volatile int*)__null) = 859; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false);
860          JS::ubi::AtomOrTwoByteChars s(atom);
861          return s.length();
862        },
863        [](const char16_t* chars) -> size_t {
864          MOZ_ASSERT(chars)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(chars)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(chars))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("chars", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 864); AnnotateMozCrashReason("MOZ_ASSERT" "(" "chars" ")");
 do { *((volatile int*)__null) = 864; __attribute__((nomerge)
) ::abort(); } while (false); } } while (false);
865          return NS_strlen(chars);
866        },
867        [](const JS::ubi::EdgeName& ptr) -> size_t {
868          MOZ_ASSERT(ptr)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(ptr)>::isValid, "invalid assertion condition"); if
 ((__builtin_expect(!!(!(!!(ptr))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("ptr", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 868); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ptr" ")"); do
 { *((volatile int*)__null) = 868; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false);
869          return NS_strlen(ptr.get());
870        });
871  }
872 
873  // Copy the contents of a TwoByteString into the provided buffer. The buffer
874  // is NOT null terminated. The number of characters written is returned.
875  size_t copyToBuffer(RangedPtr<char16_t> destination, size_t maxLength) {
876    CopyToBufferMatcher m(destination, maxLength);
877    return match(m);
878  }
879 
880  struct HashPolicy;
881};
882 
883// A hashing policy for TwoByteString.
884//
885// Atoms are pointer hashed and use pointer equality, which means that we
886// tolerate some duplication across atoms and the other two types of two-byte
887// strings. In practice, we expect the amount of this duplication to be very low
888// because each type is generally a different semantic thing in addition to
889// having a slightly different representation. For example, the set of edge
890// names and the set stack frames' source names naturally tend not to overlap
891// very much if at all.
892struct TwoByteString::HashPolicy {
893  using Lookup = TwoByteString;
894 
895  static js::HashNumber hash(const Lookup& l) {
896    return l.match(
897        [](const JSAtom* atom) {
898          return js::DefaultHasher<const JSAtom*>::hash(atom);
899        },
900        [](const char16_t* chars) {
901          MOZ_ASSERT(chars)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(chars)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(chars))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("chars", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 901); AnnotateMozCrashReason("MOZ_ASSERT" "(" "chars" ")");
 do { *((volatile int*)__null) = 901; __attribute__((nomerge)
) ::abort(); } while (false); } } while (false);
902          auto length = NS_strlen(chars);
903          return HashString(chars, length);
904        },
905        [](const JS::ubi::EdgeName& ptr) {
906          const char16_t* chars = ptr.get();
907          MOZ_ASSERT(chars)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(chars)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(chars))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("chars", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 907); AnnotateMozCrashReason("MOZ_ASSERT" "(" "chars" ")");
 do { *((volatile int*)__null) = 907; __attribute__((nomerge)
) ::abort(); } while (false); } } while (false);
908          auto length = NS_strlen(chars);
909          return HashString(chars, length);
910        });
911  }
912 
913  struct EqualityMatcher {
914    const TwoByteString& rhs;
915    explicit EqualityMatcher(const TwoByteString& rhs) : rhs(rhs) {}
916 
917    bool operator()(const JSAtom* atom) {
918      return rhs.is<JSAtom*>() && rhs.as<JSAtom*>() == atom;
919    }
920 
921    bool operator()(const char16_t* chars) {
922      MOZ_ASSERT(chars)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(chars)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(chars))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("chars", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 922); AnnotateMozCrashReason("MOZ_ASSERT" "(" "chars" ")");
 do { *((volatile int*)__null) = 922; __attribute__((nomerge)
) ::abort(); } while (false); } } while (false);
923 
924      const char16_t* rhsChars = nullptr;
925      if (rhs.is<const char16_t*>())
926        rhsChars = rhs.as<const char16_t*>();
927      else if (rhs.is<JS::ubi::EdgeName>())
928        rhsChars = rhs.as<JS::ubi::EdgeName>().get();
929      else
930        return false;
931      MOZ_ASSERT(rhsChars)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(rhsChars)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(rhsChars))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("rhsChars", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 931); AnnotateMozCrashReason("MOZ_ASSERT" "(" "rhsChars" ")"
); do { *((volatile int*)__null) = 931; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
932 
933      auto length = NS_strlen(chars);
934      if (NS_strlen(rhsChars) != length) return false;
935 
936      return memcmp(chars, rhsChars, length * sizeof(char16_t)) == 0;
937    }
938 
939    bool operator()(const JS::ubi::EdgeName& ptr) {
940      MOZ_ASSERT(ptr)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(ptr)>::isValid, "invalid assertion condition"); if
 ((__builtin_expect(!!(!(!!(ptr))), 0))) { do { } while (false
); MOZ_ReportAssertionFailure("ptr", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 940); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ptr" ")"); do
 { *((volatile int*)__null) = 940; __attribute__((nomerge)) ::
abort(); } while (false); } } while (false);
941      return operator()(ptr.get());
942    }
943  };
944 
945  static bool match(const TwoByteString& k, const Lookup& l) {
946    EqualityMatcher eq(l);
947    return k.match(eq);
948  }
949 
950  static void rekey(TwoByteString& k, TwoByteString&& newKey) {
951    k = std::move(newKey);
952  }
953};
954 
955// Returns whether `edge` should be included in a heap snapshot of
956// `compartments`. The optional `policy` out-param is set to INCLUDE_EDGES
957// if we want to include the referent's edges, or EXCLUDE_EDGES if we don't
958// want to include them.
959static bool ShouldIncludeEdge(JS::CompartmentSet* compartments,
960                              const ubi::Node& origin, const ubi::Edge& edge,
961                              CoreDumpWriter::EdgePolicy* policy = nullptr) {
962  if (policy) {
963    *policy = CoreDumpWriter::INCLUDE_EDGES;
964  }
965 
966  if (!compartments) {
967    // We aren't targeting a particular set of compartments, so serialize all
968    // the things!
969    return true;
970  }
971 
972  // We are targeting a particular set of compartments. If this node is in our
973  // target set, serialize it and all of its edges. If this node is _not_ in our
974  // target set, we also serialize under the assumption that it is a shared
975  // resource being used by something in our target compartments since we
976  // reached it by traversing the heap graph. However, we do not serialize its
977  // outgoing edges and we abandon further traversal from this node.
978  //
979  // If the node does not belong to any compartment, we also serialize its
980  // outgoing edges. This case is relevant for Shapes: they don't belong to a
981  // specific compartment and contain edges to parent/kids Shapes we want to
982  // include. Note that these Shapes may contain pointers into our target
983  // compartment (the Shape's getter/setter JSObjects). However, we do not
984  // serialize nodes in other compartments that are reachable from these
985  // non-compartment nodes.
986 
987  JS::Compartment* compartment = edge.referent.compartment();
988 
989  if (!compartment || compartments->has(compartment)) {
990    return true;
991  }
992 
993  if (policy) {
994    *policy = CoreDumpWriter::EXCLUDE_EDGES;
995  }
996 
997  return !!origin.compartment();
998}
999 
1000// A `CoreDumpWriter` that serializes nodes to protobufs and writes them to the
1001// given `ZeroCopyOutputStream`.
1002class MOZ_STACK_CLASS StreamWriter : public CoreDumpWriter {
1003  using FrameSet = js::HashSet<uint64_t>;
1004  using TwoByteStringMap =
1005      js::HashMap<TwoByteString, uint64_t, TwoByteString::HashPolicy>;
1006  using OneByteStringMap = js::HashMap<const char*, uint64_t>;
1007 
1008  JSContext* cx;
1009  bool wantNames;
1010  // The set of |JS::ubi::StackFrame::identifier()|s that have already been
1011  // serialized and written to the core dump.
1012  FrameSet framesAlreadySerialized;
1013  // The set of two-byte strings that have already been serialized and written
1014  // to the core dump.
1015  TwoByteStringMap twoByteStringsAlreadySerialized;
1016  // The set of one-byte strings that have already been serialized and written
1017  // to the core dump.
1018  OneByteStringMap oneByteStringsAlreadySerialized;
1019 
1020  ::google::protobuf::io::ZeroCopyOutputStream& stream;
1021 
1022  JS::CompartmentSet* compartments;
1023 
1024  bool writeMessage(const ::google::protobuf::MessageLite& message) {
1025    // We have to create a new CodedOutputStream when writing each message so
1026    // that the 64MB size limit used by Coded{Output,Input}Stream to prevent
1027    // integer overflow is enforced per message rather than on the whole stream.
1028    ::google::protobuf::io::CodedOutputStream codedStream(&stream);
1029    codedStream.WriteVarint32(message.ByteSizeLong());
1030    message.SerializeWithCachedSizes(&codedStream);
1031    return !codedStream.HadError();
1032  }
1033 
1034  // Attach the full two-byte string or a reference to a two-byte string that
1035  // has already been serialized to a protobuf message.
1036  template <typename SetStringFunction, typename SetRefFunction>
1037  bool attachTwoByteString(TwoByteString& string, SetStringFunction setString,
1038                           SetRefFunction setRef) {
1039    auto ptr = twoByteStringsAlreadySerialized.lookupForAdd(string);
1040    if (ptr) {
1041      setRef(ptr->value());
1042      return true;
1043    }
1044 
1045    auto length = string.length();
1046    auto stringData = MakeUnique<std::string>(length * sizeof(char16_t), '\0');
1047    if (!stringData) return false;
1048 
1049    auto buf = const_cast<char16_t*>(
1050        reinterpret_cast<const char16_t*>(stringData->data()));
1051    string.copyToBuffer(RangedPtr<char16_t>(buf, length), length);
1052 
1053    uint64_t ref = twoByteStringsAlreadySerialized.count();
1054    if (!twoByteStringsAlreadySerialized.add(ptr, std::move(string), ref))
1055      return false;
1056 
1057    setString(stringData.release());
1058    return true;
1059  }
1060 
1061  // Attach the full one-byte string or a reference to a one-byte string that
1062  // has already been serialized to a protobuf message.
1063  template <typename SetStringFunction, typename SetRefFunction>
1064  bool attachOneByteString(const char* string, SetStringFunction setString,
1065                           SetRefFunction setRef) {
1066    auto ptr = oneByteStringsAlreadySerialized.lookupForAdd(string);
1067    if (ptr) {
1068      setRef(ptr->value());
1069      return true;
1070    }
1071 
1072    auto length = strlen(string);
1073    auto stringData = MakeUnique<std::string>(string, length);
1074    if (!stringData) return false;
1075 
1076    uint64_t ref = oneByteStringsAlreadySerialized.count();
1077    if (!oneByteStringsAlreadySerialized.add(ptr, string, ref)) return false;
1078 
1079    setString(stringData.release());
1080    return true;
1081  }
1082 
1083  protobuf::StackFrame* getProtobufStackFrame(JS::ubi::StackFrame& frame,
1084                                              size_t depth = 1) {
1085    // NB: de-duplicated string properties must be written in the same order
1086    // here as they are read in `HeapSnapshot::saveStackFrame` or else indices
1087    // in references to already serialized strings will be off.
1088 
1089    MOZ_ASSERT(frame,do { static_assert( mozilla::detail::AssertionConditionType<
decltype(frame)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(frame))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("frame" " (" "null frames should be represented as the lack of a serialized "
 "stack frame" ")", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1091); AnnotateMozCrashReason("MOZ_ASSERT" "(" "frame" ") ("
 "null frames should be represented as the lack of a serialized "
 "stack frame" ")"); do { *((volatile int*)__null) = 1091; __attribute__
((nomerge)) ::abort(); } while (false); } } while (false)
1090               "null frames should be represented as the lack of a serialized "do { static_assert( mozilla::detail::AssertionConditionType<
decltype(frame)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(frame))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("frame" " (" "null frames should be represented as the lack of a serialized "
 "stack frame" ")", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1091); AnnotateMozCrashReason("MOZ_ASSERT" "(" "frame" ") ("
 "null frames should be represented as the lack of a serialized "
 "stack frame" ")"); do { *((volatile int*)__null) = 1091; __attribute__
((nomerge)) ::abort(); } while (false); } } while (false)
1091               "stack frame")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(frame)>::isValid, "invalid assertion condition");
 if ((__builtin_expect(!!(!(!!(frame))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("frame" " (" "null frames should be represented as the lack of a serialized "
 "stack frame" ")", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1091); AnnotateMozCrashReason("MOZ_ASSERT" "(" "frame" ") ("
 "null frames should be represented as the lack of a serialized "
 "stack frame" ")"); do { *((volatile int*)__null) = 1091; __attribute__
((nomerge)) ::abort(); } while (false); } } while (false);
1092 
1093    auto id = frame.identifier();
1094    auto protobufStackFrame = MakeUnique<protobuf::StackFrame>();
1095    if (!protobufStackFrame) return nullptr;
1096 
1097    if (framesAlreadySerialized.has(id)) {
1098      protobufStackFrame->set_ref(id);
1099      return protobufStackFrame.release();
1100    }
1101 
1102    auto data = MakeUnique<protobuf::StackFrame_Data>();
1103    if (!data) return nullptr;
1104 
1105    data->set_id(id);
1106    data->set_line(frame.line());
1107    data->set_column(frame.column().oneOriginValue());
1108    data->set_issystem(frame.isSystem());
1109    data->set_isselfhosted(frame.isSelfHosted(cx));
1110 
1111    auto dupeSource = TwoByteString::from(frame.source());
1112    if (!attachTwoByteString(
1113            dupeSource,
1114            [&](std::string* source) { data->set_allocated_source(source); },
1115            [&](uint64_t ref) { data->set_sourceref(ref); })) {
1116      return nullptr;
1117    }
1118 
1119    auto dupeName = TwoByteString::from(frame.functionDisplayName());
1120    if (dupeName.isNonNull()) {
1121      if (!attachTwoByteString(
1122              dupeName,
1123              [&](std::string* name) {
1124                data->set_allocated_functiondisplayname(name);
1125              },
1126              [&](uint64_t ref) { data->set_functiondisplaynameref(ref); })) {
1127        return nullptr;
1128      }
1129    }
1130 
1131    auto parent = frame.parent();
1132    if (parent && depth < HeapSnapshot::MAX_STACK_DEPTH) {
1133      auto protobufParent = getProtobufStackFrame(parent, depth + 1);
1134      if (!protobufParent) return nullptr;
1135      data->set_allocated_parent(protobufParent);
1136    }
1137 
1138    protobufStackFrame->set_allocated_data(data.release());
1139 
1140    if (!framesAlreadySerialized.put(id)) return nullptr;
1141 
1142    return protobufStackFrame.release();
1143  }
1144 
1145 public:
1146  StreamWriter(JSContext* cx,
1147               ::google::protobuf::io::ZeroCopyOutputStream& stream,
1148               bool wantNames, JS::CompartmentSet* compartments)
1149      : cx(cx),
1150        wantNames(wantNames),
1151        framesAlreadySerialized(cx),
1152        twoByteStringsAlreadySerialized(cx),
1153        oneByteStringsAlreadySerialized(cx),
1154        stream(stream),
1155        compartments(compartments) {}
1156 
1157  ~StreamWriter() override {}
1158 
1159  bool writeMetadata(uint64_t timestamp) final {
1160    protobuf::Metadata metadata;
1161    metadata.set_timestamp(timestamp);
1162    return writeMessage(metadata);
1163  }
1164 
1165  bool writeNode(const JS::ubi::Node& ubiNode, EdgePolicy includeEdges) final {
1166    // NB: de-duplicated string properties must be written in the same order
1167    // here as they are read in `HeapSnapshot::saveNode` or else indices in
1168    // references to already serialized strings will be off.
1169 
1170    protobuf::Node protobufNode;
1171    protobufNode.set_id(ubiNode.identifier());
1172 
1173    protobufNode.set_coarsetype(
1174        JS::ubi::CoarseTypeToUint32(ubiNode.coarseType()));
1175 
1176    auto typeName = TwoByteString(ubiNode.typeName());
1177    if (NS_WARN_IF(!attachTwoByteString(NS_warn_if_impl(!attachTwoByteString( typeName, [&](std::
string* name) { protobufNode.set_allocated_typename_(name); }
, [&](uint64_t ref) { protobufNode.set_typenameref(ref); }
), "!attachTwoByteString( typeName, [&](std::string* name) { protobufNode.set_allocated_typename_(name); }, [&](uint64_t ref) { protobufNode.set_typenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1182)
1178            typeName,NS_warn_if_impl(!attachTwoByteString( typeName, [&](std::
string* name) { protobufNode.set_allocated_typename_(name); }
, [&](uint64_t ref) { protobufNode.set_typenameref(ref); }
), "!attachTwoByteString( typeName, [&](std::string* name) { protobufNode.set_allocated_typename_(name); }, [&](uint64_t ref) { protobufNode.set_typenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1182)
1179            [&](std::string* name) {NS_warn_if_impl(!attachTwoByteString( typeName, [&](std::
string* name) { protobufNode.set_allocated_typename_(name); }
, [&](uint64_t ref) { protobufNode.set_typenameref(ref); }
), "!attachTwoByteString( typeName, [&](std::string* name) { protobufNode.set_allocated_typename_(name); }, [&](uint64_t ref) { protobufNode.set_typenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1182)
1180              protobufNode.set_allocated_typename_(name);NS_warn_if_impl(!attachTwoByteString( typeName, [&](std::
string* name) { protobufNode.set_allocated_typename_(name); }
, [&](uint64_t ref) { protobufNode.set_typenameref(ref); }
), "!attachTwoByteString( typeName, [&](std::string* name) { protobufNode.set_allocated_typename_(name); }, [&](uint64_t ref) { protobufNode.set_typenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1182)
1181            },NS_warn_if_impl(!attachTwoByteString( typeName, [&](std::
string* name) { protobufNode.set_allocated_typename_(name); }
, [&](uint64_t ref) { protobufNode.set_typenameref(ref); }
), "!attachTwoByteString( typeName, [&](std::string* name) { protobufNode.set_allocated_typename_(name); }, [&](uint64_t ref) { protobufNode.set_typenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1182)
1182            [&](uint64_t ref) { protobufNode.set_typenameref(ref); }))NS_warn_if_impl(!attachTwoByteString( typeName, [&](std::
string* name) { protobufNode.set_allocated_typename_(name); }
, [&](uint64_t ref) { protobufNode.set_typenameref(ref); }
), "!attachTwoByteString( typeName, [&](std::string* name) { protobufNode.set_allocated_typename_(name); }, [&](uint64_t ref) { protobufNode.set_typenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1182)) {
1183      return false;
1184    }
1185 
1186    mozilla::MallocSizeOf mallocSizeOf = dbg::GetDebuggerMallocSizeOf(cx);
1187    MOZ_ASSERT(mallocSizeOf)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mallocSizeOf)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mallocSizeOf))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("mallocSizeOf", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1187); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mallocSizeOf"
 ")"); do { *((volatile int*)__null) = 1187; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
1188    protobufNode.set_size(ubiNode.size(mallocSizeOf));
1189 
1190    if (includeEdges) {
1191      auto edges = ubiNode.edges(cx, wantNames);
1192      if (NS_WARN_IF(!edges)NS_warn_if_impl(!edges, "!edges", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1192)) return false;
1193 
1194      for (; !edges->empty(); edges->popFront()) {
1195        ubi::Edge& ubiEdge = edges->front();
1196        if (!ShouldIncludeEdge(compartments, ubiNode, ubiEdge)) {
1197          continue;
1198        }
1199 
1200        protobuf::Edge* protobufEdge = protobufNode.add_edges();
1201        if (NS_WARN_IF(!protobufEdge)NS_warn_if_impl(!protobufEdge, "!protobufEdge", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1201)) {
1202          return false;
1203        }
1204 
1205        protobufEdge->set_referent(ubiEdge.referent.identifier());
1206 
1207        if (wantNames && ubiEdge.name) {
1208          TwoByteString edgeName(std::move(ubiEdge.name));
1209          if (NS_WARN_IF(!attachTwoByteString(NS_warn_if_impl(!attachTwoByteString( edgeName, [&](std::
string* name) { protobufEdge->set_allocated_name(name); },
 [&](uint64_t ref) { protobufEdge->set_nameref(ref); }
), "!attachTwoByteString( edgeName, [&](std::string* name) { protobufEdge->set_allocated_name(name); }, [&](uint64_t ref) { protobufEdge->set_nameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1214)
1210                  edgeName,NS_warn_if_impl(!attachTwoByteString( edgeName, [&](std::
string* name) { protobufEdge->set_allocated_name(name); },
 [&](uint64_t ref) { protobufEdge->set_nameref(ref); }
), "!attachTwoByteString( edgeName, [&](std::string* name) { protobufEdge->set_allocated_name(name); }, [&](uint64_t ref) { protobufEdge->set_nameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1214)
1211                  [&](std::string* name) {NS_warn_if_impl(!attachTwoByteString( edgeName, [&](std::
string* name) { protobufEdge->set_allocated_name(name); },
 [&](uint64_t ref) { protobufEdge->set_nameref(ref); }
), "!attachTwoByteString( edgeName, [&](std::string* name) { protobufEdge->set_allocated_name(name); }, [&](uint64_t ref) { protobufEdge->set_nameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1214)
1212                    protobufEdge->set_allocated_name(name);NS_warn_if_impl(!attachTwoByteString( edgeName, [&](std::
string* name) { protobufEdge->set_allocated_name(name); },
 [&](uint64_t ref) { protobufEdge->set_nameref(ref); }
), "!attachTwoByteString( edgeName, [&](std::string* name) { protobufEdge->set_allocated_name(name); }, [&](uint64_t ref) { protobufEdge->set_nameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1214)
1213                  },NS_warn_if_impl(!attachTwoByteString( edgeName, [&](std::
string* name) { protobufEdge->set_allocated_name(name); },
 [&](uint64_t ref) { protobufEdge->set_nameref(ref); }
), "!attachTwoByteString( edgeName, [&](std::string* name) { protobufEdge->set_allocated_name(name); }, [&](uint64_t ref) { protobufEdge->set_nameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1214)
1214                  [&](uint64_t ref) { protobufEdge->set_nameref(ref); }))NS_warn_if_impl(!attachTwoByteString( edgeName, [&](std::
string* name) { protobufEdge->set_allocated_name(name); },
 [&](uint64_t ref) { protobufEdge->set_nameref(ref); }
), "!attachTwoByteString( edgeName, [&](std::string* name) { protobufEdge->set_allocated_name(name); }, [&](uint64_t ref) { protobufEdge->set_nameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1214)) {
1215            return false;
1216          }
1217        }
1218      }
1219    }
1220 
1221    if (ubiNode.hasAllocationStack()) {
1222      auto ubiStackFrame = ubiNode.allocationStack();
1223      auto protoStackFrame = getProtobufStackFrame(ubiStackFrame);
1224      if (NS_WARN_IF(!protoStackFrame)NS_warn_if_impl(!protoStackFrame, "!protoStackFrame", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1224)) return false;
1225      protobufNode.set_allocated_allocationstack(protoStackFrame);
1226    }
1227 
1228    if (auto className = ubiNode.jsObjectClassName()) {
1229      if (NS_WARN_IF(!attachOneByteString(NS_warn_if_impl(!attachOneByteString( className, [&](std::
string* name) { protobufNode.set_allocated_jsobjectclassname(
name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref
(ref); }), "!attachOneByteString( className, [&](std::string* name) { protobufNode.set_allocated_jsobjectclassname(name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1236)
1230              className,NS_warn_if_impl(!attachOneByteString( className, [&](std::
string* name) { protobufNode.set_allocated_jsobjectclassname(
name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref
(ref); }), "!attachOneByteString( className, [&](std::string* name) { protobufNode.set_allocated_jsobjectclassname(name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1236)
1231              [&](std::string* name) {NS_warn_if_impl(!attachOneByteString( className, [&](std::
string* name) { protobufNode.set_allocated_jsobjectclassname(
name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref
(ref); }), "!attachOneByteString( className, [&](std::string* name) { protobufNode.set_allocated_jsobjectclassname(name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1236)
1232                protobufNode.set_allocated_jsobjectclassname(name);NS_warn_if_impl(!attachOneByteString( className, [&](std::
string* name) { protobufNode.set_allocated_jsobjectclassname(
name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref
(ref); }), "!attachOneByteString( className, [&](std::string* name) { protobufNode.set_allocated_jsobjectclassname(name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1236)
1233              },NS_warn_if_impl(!attachOneByteString( className, [&](std::
string* name) { protobufNode.set_allocated_jsobjectclassname(
name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref
(ref); }), "!attachOneByteString( className, [&](std::string* name) { protobufNode.set_allocated_jsobjectclassname(name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1236)
1234              [&](uint64_t ref) {NS_warn_if_impl(!attachOneByteString( className, [&](std::
string* name) { protobufNode.set_allocated_jsobjectclassname(
name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref
(ref); }), "!attachOneByteString( className, [&](std::string* name) { protobufNode.set_allocated_jsobjectclassname(name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1236)
1235                protobufNode.set_jsobjectclassnameref(ref);NS_warn_if_impl(!attachOneByteString( className, [&](std::
string* name) { protobufNode.set_allocated_jsobjectclassname(
name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref
(ref); }), "!attachOneByteString( className, [&](std::string* name) { protobufNode.set_allocated_jsobjectclassname(name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1236)
1236              }))NS_warn_if_impl(!attachOneByteString( className, [&](std::
string* name) { protobufNode.set_allocated_jsobjectclassname(
name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref
(ref); }), "!attachOneByteString( className, [&](std::string* name) { protobufNode.set_allocated_jsobjectclassname(name); }, [&](uint64_t ref) { protobufNode.set_jsobjectclassnameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1236)) {
1237        return false;
1238      }
1239    }
1240 
1241    if (auto scriptFilename = ubiNode.scriptFilename()) {
1242      if (NS_WARN_IF(!attachOneByteString(NS_warn_if_impl(!attachOneByteString( scriptFilename, [&]
(std::string* name) { protobufNode.set_allocated_scriptfilename
(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref
(ref); }), "!attachOneByteString( scriptFilename, [&](std::string* name) { protobufNode.set_allocated_scriptfilename(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1249)
1243              scriptFilename,NS_warn_if_impl(!attachOneByteString( scriptFilename, [&]
(std::string* name) { protobufNode.set_allocated_scriptfilename
(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref
(ref); }), "!attachOneByteString( scriptFilename, [&](std::string* name) { protobufNode.set_allocated_scriptfilename(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1249)
1244              [&](std::string* name) {NS_warn_if_impl(!attachOneByteString( scriptFilename, [&]
(std::string* name) { protobufNode.set_allocated_scriptfilename
(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref
(ref); }), "!attachOneByteString( scriptFilename, [&](std::string* name) { protobufNode.set_allocated_scriptfilename(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1249)
1245                protobufNode.set_allocated_scriptfilename(name);NS_warn_if_impl(!attachOneByteString( scriptFilename, [&]
(std::string* name) { protobufNode.set_allocated_scriptfilename
(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref
(ref); }), "!attachOneByteString( scriptFilename, [&](std::string* name) { protobufNode.set_allocated_scriptfilename(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1249)
1246              },NS_warn_if_impl(!attachOneByteString( scriptFilename, [&]
(std::string* name) { protobufNode.set_allocated_scriptfilename
(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref
(ref); }), "!attachOneByteString( scriptFilename, [&](std::string* name) { protobufNode.set_allocated_scriptfilename(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1249)
1247              [&](uint64_t ref) {NS_warn_if_impl(!attachOneByteString( scriptFilename, [&]
(std::string* name) { protobufNode.set_allocated_scriptfilename
(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref
(ref); }), "!attachOneByteString( scriptFilename, [&](std::string* name) { protobufNode.set_allocated_scriptfilename(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1249)
1248                protobufNode.set_scriptfilenameref(ref);NS_warn_if_impl(!attachOneByteString( scriptFilename, [&]
(std::string* name) { protobufNode.set_allocated_scriptfilename
(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref
(ref); }), "!attachOneByteString( scriptFilename, [&](std::string* name) { protobufNode.set_allocated_scriptfilename(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1249)
1249              }))NS_warn_if_impl(!attachOneByteString( scriptFilename, [&]
(std::string* name) { protobufNode.set_allocated_scriptfilename
(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref
(ref); }), "!attachOneByteString( scriptFilename, [&](std::string* name) { protobufNode.set_allocated_scriptfilename(name); }, [&](uint64_t ref) { protobufNode.set_scriptfilenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1249)) {
1250        return false;
1251      }
1252    }
1253 
1254    if (ubiNode.descriptiveTypeName()) {
1255      auto descriptiveTypeName = TwoByteString(ubiNode.descriptiveTypeName());
1256      if (NS_WARN_IF(!attachTwoByteString(NS_warn_if_impl(!attachTwoByteString( descriptiveTypeName, [&
](std::string* name) { protobufNode.set_allocated_descriptivetypename
(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref
(ref); }), "!attachTwoByteString( descriptiveTypeName, [&](std::string* name) { protobufNode.set_allocated_descriptivetypename(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1263)
1257              descriptiveTypeName,NS_warn_if_impl(!attachTwoByteString( descriptiveTypeName, [&
](std::string* name) { protobufNode.set_allocated_descriptivetypename
(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref
(ref); }), "!attachTwoByteString( descriptiveTypeName, [&](std::string* name) { protobufNode.set_allocated_descriptivetypename(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1263)
1258              [&](std::string* name) {NS_warn_if_impl(!attachTwoByteString( descriptiveTypeName, [&
](std::string* name) { protobufNode.set_allocated_descriptivetypename
(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref
(ref); }), "!attachTwoByteString( descriptiveTypeName, [&](std::string* name) { protobufNode.set_allocated_descriptivetypename(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1263)
1259                protobufNode.set_allocated_descriptivetypename(name);NS_warn_if_impl(!attachTwoByteString( descriptiveTypeName, [&
](std::string* name) { protobufNode.set_allocated_descriptivetypename
(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref
(ref); }), "!attachTwoByteString( descriptiveTypeName, [&](std::string* name) { protobufNode.set_allocated_descriptivetypename(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1263)
1260              },NS_warn_if_impl(!attachTwoByteString( descriptiveTypeName, [&
](std::string* name) { protobufNode.set_allocated_descriptivetypename
(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref
(ref); }), "!attachTwoByteString( descriptiveTypeName, [&](std::string* name) { protobufNode.set_allocated_descriptivetypename(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1263)
1261              [&](uint64_t ref) {NS_warn_if_impl(!attachTwoByteString( descriptiveTypeName, [&
](std::string* name) { protobufNode.set_allocated_descriptivetypename
(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref
(ref); }), "!attachTwoByteString( descriptiveTypeName, [&](std::string* name) { protobufNode.set_allocated_descriptivetypename(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1263)
1262                protobufNode.set_descriptivetypenameref(ref);NS_warn_if_impl(!attachTwoByteString( descriptiveTypeName, [&
](std::string* name) { protobufNode.set_allocated_descriptivetypename
(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref
(ref); }), "!attachTwoByteString( descriptiveTypeName, [&](std::string* name) { protobufNode.set_allocated_descriptivetypename(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1263)
1263              }))NS_warn_if_impl(!attachTwoByteString( descriptiveTypeName, [&
](std::string* name) { protobufNode.set_allocated_descriptivetypename
(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref
(ref); }), "!attachTwoByteString( descriptiveTypeName, [&](std::string* name) { protobufNode.set_allocated_descriptivetypename(name); }, [&](uint64_t ref) { protobufNode.set_descriptivetypenameref(ref); })"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1263)) {
1264        return false;
1265      }
1266    }
1267 
1268    return writeMessage(protobufNode);
1269  }
1270};
1271 
1272// A JS::ubi::BreadthFirst handler that serializes a snapshot of the heap into a
1273// core dump.
1274class MOZ_STACK_CLASS HeapSnapshotHandler {
1275  CoreDumpWriter& writer;
1276  JS::CompartmentSet* compartments;
1277 
1278 public:
1279  // For telemetry.
1280  uint32_t nodeCount;
1281  uint32_t edgeCount;
1282 
1283  HeapSnapshotHandler(CoreDumpWriter& writer, JS::CompartmentSet* compartments)
1284      : writer(writer),
1285        compartments(compartments),
1286        nodeCount(0),
1287        edgeCount(0) {}
1288 
1289  // JS::ubi::BreadthFirst handler interface.
1290 
1291  class NodeData {};
1292  typedef JS::ubi::BreadthFirst<HeapSnapshotHandler> Traversal;
1293  bool operator()(Traversal& traversal, JS::ubi::Node origin,
1294                  const JS::ubi::Edge& edge, NodeData*, bool first) {
1295    edgeCount++;
1296 
1297    // We're only interested in the first time we reach edge.referent, not in
1298    // every edge arriving at that node. "But, don't we want to serialize every
1299    // edge in the heap graph?" you ask. Don't worry! This edge is still
1300    // serialized into the core dump. Serializing a node also serializes each of
1301    // its edges, and if we are traversing a given edge, we must have already
1302    // visited and serialized the origin node and its edges.
1303    if (!first) return true;
1304 
1305    CoreDumpWriter::EdgePolicy policy;
1306    if (!ShouldIncludeEdge(compartments, origin, edge, &policy)) {
1307      // Because ShouldIncludeEdge considers the |origin| node as well, we don't
1308      // want to consider this node 'visited' until we write it to the core
1309      // dump.
1310      traversal.doNotMarkReferentAsVisited();
1311      return true;
1312    }
1313 
1314    nodeCount++;
1315 
1316    if (policy == CoreDumpWriter::EXCLUDE_EDGES) traversal.abandonReferent();
1317 
1318    return writer.writeNode(edge.referent, policy);
1319  }
1320};
1321 
1322bool WriteHeapGraph(JSContext* cx, const JS::ubi::Node& node,
1323                    CoreDumpWriter& writer, bool wantNames,
1324                    JS::CompartmentSet* compartments,
1325                    JS::AutoCheckCannotGC& noGC, uint32_t& outNodeCount,
1326                    uint32_t& outEdgeCount) {
1327  // Serialize the starting node to the core dump.
1328 
1329  if (NS_WARN_IF(!writer.writeNode(node, CoreDumpWriter::INCLUDE_EDGES))NS_warn_if_impl(!writer.writeNode(node, CoreDumpWriter::INCLUDE_EDGES
), "!writer.writeNode(node, CoreDumpWriter::INCLUDE_EDGES)", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1329)) {
1330    return false;
1331  }
1332 
1333  // Walk the heap graph starting from the given node and serialize it into the
1334  // core dump.
1335 
1336  HeapSnapshotHandler handler(writer, compartments);
1337  HeapSnapshotHandler::Traversal traversal(cx, handler, noGC);
1338  traversal.wantNames = wantNames;
1339 
1340  bool ok = traversal.addStartVisited(node) && traversal.traverse();
1341 
1342  if (ok) {
1343    outNodeCount = handler.nodeCount;
1344    outEdgeCount = handler.edgeCount;
1345  }
1346 
1347  return ok;
1348}
1349 
1350static unsigned long msSinceProcessCreation(const TimeStamp& now) {
1351  auto duration = now - TimeStamp::ProcessCreation();
1352  return (unsigned long)duration.ToMilliseconds();
1353}
1354 
1355/* static */
1356already_AddRefed<nsIFile> HeapSnapshot::CreateUniqueCoreDumpFile(
1357    ErrorResult& rv, const TimeStamp& now, nsAString& outFilePath,
1358    nsAString& outSnapshotId) {
1359  MOZ_RELEASE_ASSERT(XRE_IsParentProcess())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(XRE_IsParentProcess())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(XRE_IsParentProcess()))), 0)
)) { do { } while (false); MOZ_ReportAssertionFailure("XRE_IsParentProcess()"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1359); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "XRE_IsParentProcess()"
 ")"); do { *((volatile int*)__null) = 1359; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
1360  nsCOMPtr<nsIFile> file;
1361  rv = GetSpecialSystemDirectory(OS_TemporaryDirectory, getter_AddRefs(file));
1362  if (NS_WARN_IF(rv.Failed())NS_warn_if_impl(rv.Failed(), "rv.Failed()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1362)) return nullptr;
1363 
1364  nsAutoString tempPath;
1365  rv = file->GetPath(tempPath);
1366  if (NS_WARN_IF(rv.Failed())NS_warn_if_impl(rv.Failed(), "rv.Failed()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1366)) return nullptr;
1367 
1368  auto ms = msSinceProcessCreation(now);
1369  rv = file->AppendNative(nsPrintfCString("%lu.fxsnapshot", ms));
1370  if (NS_WARN_IF(rv.Failed())NS_warn_if_impl(rv.Failed(), "rv.Failed()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1370)) return nullptr;
1371 
1372  rv = file->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0666);
1373  if (NS_WARN_IF(rv.Failed())NS_warn_if_impl(rv.Failed(), "rv.Failed()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1373)) return nullptr;
1374 
1375  rv = file->GetPath(outFilePath);
1376  if (NS_WARN_IF(rv.Failed())NS_warn_if_impl(rv.Failed(), "rv.Failed()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1376)) return nullptr;
1377 
1378  // The snapshot ID must be computed in the process that created the
1379  // temp file, because TmpD may not be the same in all processes.
1380  outSnapshotId.Assign(Substring(
1381      outFilePath, tempPath.Length() + 1,
1382      outFilePath.Length() - tempPath.Length() - sizeof(".fxsnapshot")));
1383 
1384  return file.forget();
1385}
1386 
1387// Deletion policy for cleaning up PHeapSnapshotTempFileHelperChild pointers.
1388class DeleteHeapSnapshotTempFileHelperChild {
1389 public:
1390  constexpr DeleteHeapSnapshotTempFileHelperChild() {}
1391 
1392  void operator()(PHeapSnapshotTempFileHelperChild* ptr) const {
1393    Unused << NS_WARN_IF(!HeapSnapshotTempFileHelperChild::Send__delete__(ptr))NS_warn_if_impl(!HeapSnapshotTempFileHelperChild::Send__delete__
(ptr), "!HeapSnapshotTempFileHelperChild::Send__delete__(ptr)"
, "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1393);
1394  }
1395};
1396 
1397// A UniquePtr alias to automatically manage PHeapSnapshotTempFileHelperChild
1398// pointers.
1399using UniqueHeapSnapshotTempFileHelperChild =
1400    UniquePtr<PHeapSnapshotTempFileHelperChild,
1401              DeleteHeapSnapshotTempFileHelperChild>;
1402 
1403// Get an nsIOutputStream that we can write the heap snapshot to. In non-e10s
1404// and in the e10s parent process, open a file directly and create an output
1405// stream for it. In e10s child processes, we are sandboxed without access to
1406// the filesystem. Use IPDL to request a file descriptor from the parent
1407// process.
1408static already_AddRefed<nsIOutputStream> getCoreDumpOutputStream(
1409    ErrorResult& rv, TimeStamp& start, nsAString& outFilePath,
1410    nsAString& outSnapshotId) {
1411  if (XRE_IsParentProcess()) {
1412    // Create the file and open the output stream directly.
1413 
1414    nsCOMPtr<nsIFile> file = HeapSnapshot::CreateUniqueCoreDumpFile(
1415        rv, start, outFilePath, outSnapshotId);
1416    if (NS_WARN_IF(rv.Failed())NS_warn_if_impl(rv.Failed(), "rv.Failed()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1416)) return nullptr;
1417 
1418    nsCOMPtr<nsIOutputStream> outputStream;
1419    rv = NS_NewLocalFileOutputStream(getter_AddRefs(outputStream), file,
1420                                     PR_WRONLY0x02, -1, 0);
1421    if (NS_WARN_IF(rv.Failed())NS_warn_if_impl(rv.Failed(), "rv.Failed()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1421)) return nullptr;
1422 
1423    return outputStream.forget();
1424  }
1425  // Request a file descriptor from the parent process over IPDL.
1426 
1427  auto cc = ContentChild::GetSingleton();
1428  if (!cc) {
1429    rv.Throw(NS_ERROR_UNEXPECTED);
1430    return nullptr;
1431  }
1432 
1433  UniqueHeapSnapshotTempFileHelperChild helper(
1434      cc->SendPHeapSnapshotTempFileHelperConstructor());
1435  if (NS_WARN_IF(!helper)NS_warn_if_impl(!helper, "!helper", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1435)) {
1436    rv.Throw(NS_ERROR_UNEXPECTED);
1437    return nullptr;
1438  }
1439 
1440  OpenHeapSnapshotTempFileResponse response;
1441  if (!helper->SendOpenHeapSnapshotTempFile(&response)) {
1442    rv.Throw(NS_ERROR_UNEXPECTED);
1443    return nullptr;
1444  }
1445  if (response.type() == OpenHeapSnapshotTempFileResponse::Tnsresult) {
1446    rv.Throw(response.get_nsresult());
1447    return nullptr;
1448  }
1449 
1450  auto opened = response.get_OpenedFile();
1451  outFilePath = opened.path();
1452  outSnapshotId = opened.snapshotId();
1453  nsCOMPtr<nsIOutputStream> outputStream =
1454      FileDescriptorOutputStream::Create(opened.descriptor());
1455  if (NS_WARN_IF(!outputStream)NS_warn_if_impl(!outputStream, "!outputStream", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1455)) {
1456    rv.Throw(NS_ERROR_UNEXPECTED);
1457    return nullptr;
1458  }
1459 
1460  return outputStream.forget();
1461}
1462 
1463}  // namespace devtools
1464 
1465namespace dom {
1466 
1467using namespace JS;
1468using namespace devtools;
1469 
1470/* static */
1471void ChromeUtils::SaveHeapSnapshotShared(
1472    GlobalObject& global, const HeapSnapshotBoundaries& boundaries,
1473    nsAString& outFilePath, nsAString& outSnapshotId, ErrorResult& rv) {
1474  auto start = TimeStamp::Now();
1475 
1476  bool wantNames = true;
1477  CompartmentSet compartments;
1478  uint32_t nodeCount = 0;
1479  uint32_t edgeCount = 0;
1480 
1481  nsCOMPtr<nsIOutputStream> outputStream =
1482      getCoreDumpOutputStream(rv, start, outFilePath, outSnapshotId);
1483  if (NS_WARN_IF(rv.Failed())NS_warn_if_impl(rv.Failed(), "rv.Failed()", "/var/lib/jenkins/workspace/firefox-scan-build/devtools/shared/heapsnapshot/HeapSnapshot.cpp"
, 1483)) return;
1484 
1485  ZeroCopyNSIOutputStream zeroCopyStream(outputStream);
1486  ::google::protobuf::io::GzipOutputStream gzipStream(&zeroCopyStream);
1487 
1488  JSContext* cx = global.Context();
1489 
1490  {
1491    ubi::RootList rootList(cx, wantNames);
1492    auto [ok, nogc] =
1493        EstablishBoundaries(cx, rv, boundaries, rootList, compartments);
1494    if (!ok) {
1495      return;
1496    }
1497 
1498    StreamWriter writer(cx, gzipStream, wantNames,
1499                        !compartments.empty() ? &compartments : nullptr);
1500 
1501    ubi::Node roots(&rootList);
1502 
1503    // Serialize the initial heap snapshot metadata to the core dump.
1504    if (!writer.writeMetadata(PR_Now()) ||
1505        // Serialize the heap graph to the core dump, starting from our list of
1506        // roots.
1507        !WriteHeapGraph(cx, roots, writer, wantNames,
1508                        !compartments.empty() ? &compartments : nullptr, nogc,
1509                        nodeCount, edgeCount)) {
1510      rv.Throw(zeroCopyStream.failed() ? zeroCopyStream.result()
1511                                       : NS_ERROR_UNEXPECTED);
1512      return;
1513    }
1514  }
1515 
1516  Telemetry::AccumulateTimeDelta(Telemetry::DEVTOOLS_SAVE_HEAP_SNAPSHOT_MS,
1517                                 start);
1518  Telemetry::Accumulate(Telemetry::DEVTOOLS_HEAP_SNAPSHOT_NODE_COUNT,
1519                        nodeCount);
1520  Telemetry::Accumulate(Telemetry::DEVTOOLS_HEAP_SNAPSHOT_EDGE_COUNT,
1521                        edgeCount);
1522}
1523 
1524/* static */
1525uint64_t ChromeUtils::GetObjectNodeId(GlobalObject& global,
1526                                      JS::Handle<JSObject*> val) {
1527  JS::Rooted<JSObject*> obj(global.Context(), val);
1528 
1529  JS::ubi::Node node(obj);
1530  return node.identifier();
1531}
1532 
1533/* static */
1534void ChromeUtils::SaveHeapSnapshot(GlobalObject& global,
1535                                   const HeapSnapshotBoundaries& boundaries,
1536                                   nsAString& outFilePath, ErrorResult& rv) {
1537  nsAutoString snapshotId;
1538  SaveHeapSnapshotShared(global, boundaries, outFilePath, snapshotId, rv);
1539}
1540 
1541/* static */
1542void ChromeUtils::SaveHeapSnapshotGetId(
1543    GlobalObject& global, const HeapSnapshotBoundaries& boundaries,
1544    nsAString& outSnapshotId, ErrorResult& rv) {
1545  nsAutoString filePath;
1546  SaveHeapSnapshotShared(global, boundaries, filePath, outSnapshotId, rv);
1547}
1548 
1549/* static */
1550already_AddRefed<HeapSnapshot> ChromeUtils::ReadHeapSnapshot(
1551    GlobalObject& global, const nsAString& filePath, ErrorResult& rv) {
1552  auto start = TimeStamp::Now();
1553 
1554  nsresult nsrv;
1555  nsCOMPtr<nsIFile> snapshotFile =
1556      do_CreateInstance("@mozilla.org/file/local;1", &nsrv);
1557 
1558  if (NS_FAILED(nsrv)((bool)(__builtin_expect(!!(NS_FAILED_impl(nsrv)), 0)))) {
1559    rv = nsrv;
1560    return nullptr;
1561  }
1562 
1563  rv = snapshotFile->InitWithPath(filePath);
1564  if (rv.Failed()) {
1565    return nullptr;
1566  }
1567 
1568  AutoMemMap mm;
1569  rv = mm.init(snapshotFile);
1570  if (rv.Failed()) return nullptr;
1571 
1572  RefPtr<HeapSnapshot> snapshot = HeapSnapshot::Create(
1573      global.Context(), global, reinterpret_cast<const uint8_t*>(mm.address()),
1574      mm.size(), rv);
1575 
1576  if (!rv.Failed())
1577    Telemetry::AccumulateTimeDelta(Telemetry::DEVTOOLS_READ_HEAP_SNAPSHOT_MS,
1578                                   start);
1579 
1580  return snapshot.forget();
1581}
1582 
1583}  // namespace dom
1584}  // namespace mozilla

←

/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h

→

1/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2/* vim: set ts=8 sts=2 et sw=2 tw=80: */
3/* 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/. */

7/* A class for optional values and in-place lazy construction. */

9#ifndef mozilla_Maybe_h
10#define mozilla_Maybe_h

12#include <functional>
13#include <new>  // for placement new
14#include <ostream>
15#include <type_traits>
16#include <utility>

18#include "mozilla/Alignment.h"
19#include "mozilla/Assertions.h"
20#include "mozilla/Attributes.h"
21#include "mozilla/MaybeStorageBase.h"
22#include "mozilla/MemoryChecking.h"
23#include "mozilla/OperatorNewExtensions.h"
24#include "mozilla/Poison.h"
25#include "mozilla/ThreadSafety.h"

27class nsCycleCollectionTraversalCallback;

29template <typename T>
30inline void CycleCollectionNoteChild(
  nsCycleCollectionTraversalCallback& aCallback, T* aChild, const char* aName,
  uint32_t aFlags);

34namespace mozilla {

36struct Nothing {};

38inline constexpr bool operator==(const Nothing&, const Nothing&) {
return true;
40}

42template <class T>
43class Maybe;

45namespace detail {

47// You would think that poisoning Maybe instances could just be a call
48// to mozWritePoison.  Unfortunately, using a simple call to
49// mozWritePoison generates poor code on MSVC for small structures.  The
50// generated code contains (always not-taken) branches and does a bunch
51// of setup for `rep stos{l,q}`, even though we know at compile time
52// exactly how many words we're poisoning.  Instead, we're going to
53// force MSVC to generate the code we want via recursive templates.

55// Write the given poisonValue into p at offset*sizeof(uintptr_t).
56template <size_t offset>
57inline void WritePoisonAtOffset(void* p, const uintptr_t poisonValue) {
memcpy(static_cast<char*>(p) + offset * sizeof(poisonValue), &poisonValue,
       sizeof(poisonValue));
60}

62template <size_t Offset, size_t NOffsets>
63struct InlinePoisoner {
static void poison(void* p, const uintptr_t poisonValue) {
  WritePoisonAtOffset<Offset>(p, poisonValue);
  InlinePoisoner<Offset + 1, NOffsets>::poison(p, poisonValue);
}
68};

70template <size_t N>
71struct InlinePoisoner<N, N> {
static void poison(void*, const uintptr_t) {
  // All done!
}
75};

77// We can't generate inline code for large structures, though, because we'll
78// blow out recursive template instantiation limits, and the code would be
79// bloated to boot.  So provide a fallback to the out-of-line poisoner.
80template <size_t ObjectSize>
81struct OutOfLinePoisoner {
static MOZ_NEVER_INLINE__attribute__((noinline)) void poison(void* p, const uintptr_t) {
  mozWritePoison(p, ObjectSize);
}
85};

87template <typename T>
88inline void PoisonObject(T* p) {
const uintptr_t POISON = mozPoisonValue();
std::conditional_t<(sizeof(T) <= 8 * sizeof(POISON)),
                   InlinePoisoner<0, sizeof(T) / sizeof(POISON)>,
                   OutOfLinePoisoner<sizeof(T)>>::poison(p, POISON);
93}

95template <typename T>
96struct MaybePoisoner {
static const size_t N = sizeof(T);

static void poison(void* aPtr) {
100#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED1
  if (N >= sizeof(uintptr_t)) {
    PoisonObject(static_cast<std::remove_cv_t<T>*>(aPtr));
  }
104#endif
  MOZ_MAKE_MEM_UNDEFINED(aPtr, N)do { } while (0);
}
107};

109template <typename T,
        bool TriviallyDestructibleAndCopyable =
            IsTriviallyDestructibleAndCopyable<T>,
        bool Copyable = std::is_copy_constructible_v<T>,
        bool Movable = std::is_move_constructible_v<T>>
114class Maybe_CopyMove_Enabler;

116#define MOZ_MAYBE_COPY_OPS()                                                \
Maybe_CopyMove_Enabler(const Maybe_CopyMove_Enabler& aOther) {            \
  if (downcast(aOther).isSome()) {                                        \
    downcast(*this).emplace(*downcast(aOther));                           \
  }                                                                       \
}                                                                         \
                                                                          \
Maybe_CopyMove_Enabler& operator=(const Maybe_CopyMove_Enabler& aOther) { \
  return downcast(*this).template operator= <T>(downcast(aOther));        \
}

127#define MOZ_MAYBE_MOVE_OPS()                                             \
constexpr Maybe_CopyMove_Enabler(Maybe_CopyMove_Enabler&& aOther) {    \
  if (downcast(aOther).isSome()) {                                     \
    downcast(*this).emplace(std::move(*downcast(aOther)));             \
    downcast(aOther).reset();                                          \
  }                                                                    \
}                                                                      \
                                                                       \
constexpr Maybe_CopyMove_Enabler& operator=(                           \
    Maybe_CopyMove_Enabler&& aOther) {                                 \
  downcast(*this).template operator= <T>(std::move(downcast(aOther))); \
                                                                       \
  return *this;                                                        \
}

142#define MOZ_MAYBE_DOWNCAST()                                          \
static constexpr Maybe<T>& downcast(Maybe_CopyMove_Enabler& aObj) { \
  return static_cast<Maybe<T>&>(aObj);                              \
}                                                                   \
static constexpr const Maybe<T>& downcast(                          \
    const Maybe_CopyMove_Enabler& aObj) {                           \
  return static_cast<const Maybe<T>&>(aObj);                        \
}

151template <typename T>
152class Maybe_CopyMove_Enabler<T, true, true, true> {
public:
Maybe_CopyMove_Enabler() = default;

Maybe_CopyMove_Enabler(const Maybe_CopyMove_Enabler&) = default;
Maybe_CopyMove_Enabler& operator=(const Maybe_CopyMove_Enabler&) = default;
constexpr Maybe_CopyMove_Enabler(Maybe_CopyMove_Enabler&& aOther) {
  downcast(aOther).reset();
}
constexpr Maybe_CopyMove_Enabler& operator=(Maybe_CopyMove_Enabler&& aOther) {
  downcast(aOther).reset();
  return *this;
}

private:
MOZ_MAYBE_DOWNCAST()
168};

170template <typename T>
171class Maybe_CopyMove_Enabler<T, true, false, true> {
public:
Maybe_CopyMove_Enabler() = default;

Maybe_CopyMove_Enabler(const Maybe_CopyMove_Enabler&) = delete;
Maybe_CopyMove_Enabler& operator=(const Maybe_CopyMove_Enabler&) = delete;
constexpr Maybe_CopyMove_Enabler(Maybe_CopyMove_Enabler&& aOther) {
  downcast(aOther).reset();
}
constexpr Maybe_CopyMove_Enabler& operator=(Maybe_CopyMove_Enabler&& aOther) {
  downcast(aOther).reset();
  return *this;
}

private:
MOZ_MAYBE_DOWNCAST()
187};

189template <typename T>
190class Maybe_CopyMove_Enabler<T, false, true, true> {
public:
Maybe_CopyMove_Enabler() = default;

MOZ_MAYBE_COPY_OPS()
MOZ_MAYBE_MOVE_OPS()

private:
MOZ_MAYBE_DOWNCAST()
199};

201template <typename T>
202class Maybe_CopyMove_Enabler<T, false, false, true> {
public:
Maybe_CopyMove_Enabler() = default;

Maybe_CopyMove_Enabler(const Maybe_CopyMove_Enabler&) = delete;
Maybe_CopyMove_Enabler& operator=(const Maybe_CopyMove_Enabler&) = delete;
MOZ_MAYBE_MOVE_OPS()

private:
MOZ_MAYBE_DOWNCAST()
212};

214template <typename T>
215class Maybe_CopyMove_Enabler<T, false, true, false> {
public:
Maybe_CopyMove_Enabler() = default;

MOZ_MAYBE_COPY_OPS()
Maybe_CopyMove_Enabler(Maybe_CopyMove_Enabler&&) = delete;
Maybe_CopyMove_Enabler& operator=(Maybe_CopyMove_Enabler&&) = delete;

private:
MOZ_MAYBE_DOWNCAST()
225};

227template <typename T, bool TriviallyDestructibleAndCopyable>
228class Maybe_CopyMove_Enabler<T, TriviallyDestructibleAndCopyable, false,
                           false> {
public:
Maybe_CopyMove_Enabler() = default;

Maybe_CopyMove_Enabler(const Maybe_CopyMove_Enabler&) = delete;
Maybe_CopyMove_Enabler& operator=(const Maybe_CopyMove_Enabler&) = delete;
Maybe_CopyMove_Enabler(Maybe_CopyMove_Enabler&&) = delete;
Maybe_CopyMove_Enabler& operator=(Maybe_CopyMove_Enabler&&) = delete;
237};

239#undef MOZ_MAYBE_COPY_OPS
240#undef MOZ_MAYBE_MOVE_OPS
241#undef MOZ_MAYBE_DOWNCAST

243template <typename T, bool TriviallyDestructibleAndCopyable =
                        IsTriviallyDestructibleAndCopyable<T>>
245struct MaybeStorage;

247template <typename T>
248struct MaybeStorage<T, false> : MaybeStorageBase<T> {
protected:
char mIsSome = false;  // not bool -- guarantees minimal space consumption

MaybeStorage() = default;
explicit MaybeStorage(const T& aVal)
    : MaybeStorageBase<T>{aVal}, mIsSome{true} {}
explicit MaybeStorage(T&& aVal)
    : MaybeStorageBase<T>{std::move(aVal)}, mIsSome{true} {}

template <typename... Args>
explicit MaybeStorage(std::in_place_t, Args&&... aArgs)
    : MaybeStorageBase<T>{std::in_place, std::forward<Args>(aArgs)...},
      mIsSome{true} {}

public:
// Copy and move operations are no-ops, since copying is moving is implemented
// by Maybe_CopyMove_Enabler.

MaybeStorage(const MaybeStorage&) : MaybeStorageBase<T>{} {}
MaybeStorage& operator=(const MaybeStorage&) { return *this; }
MaybeStorage(MaybeStorage&&) : MaybeStorageBase<T>{} {}
MaybeStorage& operator=(MaybeStorage&&) { return *this; }

~MaybeStorage() {
  if (mIsSome12.1
Field 'mIsSome' is 1
1
Field 'mIsSome' is 1
1
Field 'mIsSome' is 1
1
Field 'mIsSome' is 1
1
Field 'mIsSome' is 1
1
Field 'mIsSome' is 1
1
Field 'mIsSome' is 1
) {
13
←
Taking true branch→
    this->addr()->T::~T();
14
←
Calling implicit destructor for 'ShortestPaths'→
15
←
Calling implicit destructor for 'HashMap<JS::ubi::Node, mozilla::Vector<mozilla::UniquePtr<JS::ubi::BackEdge, JS::DeletePolicy<JS::ubi::BackEdge>>, 0, js::SystemAllocPolicy>, mozilla::DefaultHasher<JS::ubi::Node>, js::SystemAllocPolicy>'→
16
←
Calling '~HashTable'→
28
←
Returning from '~HashTable'→
29
←
Returning from destructor for 'HashMap<JS::ubi::Node, mozilla::Vector<mozilla::UniquePtr<JS::ubi::BackEdge, JS::DeletePolicy<JS::ubi::BackEdge>>, 0, js::SystemAllocPolicy>, mozilla::DefaultHasher<JS::ubi::Node>, js::SystemAllocPolicy>'→
30
←
Returning; memory was released→
  }
}
31
←
Calling implicit destructor for 'MaybeStorageBase<JS::ubi::ShortestPaths, false>'→
32
←
Calling '~Union'→
277};

279template <typename T>
280struct MaybeStorage<T, true> : MaybeStorageBase<T> {
protected:
char mIsSome = false;  // not bool -- guarantees minimal space consumption

constexpr MaybeStorage() = default;
constexpr explicit MaybeStorage(const T& aVal)
    : MaybeStorageBase<T>{aVal}, mIsSome{true} {}
constexpr explicit MaybeStorage(T&& aVal)
    : MaybeStorageBase<T>{std::move(aVal)}, mIsSome{true} {}

template <typename... Args>
constexpr explicit MaybeStorage(std::in_place_t, Args&&... aArgs)
    : MaybeStorageBase<T>{std::in_place, std::forward<Args>(aArgs)...},
      mIsSome{true} {}
294};

296template <typename T>
297struct IsMaybeImpl : std::false_type {};

299template <typename T>
300struct IsMaybeImpl<Maybe<T>> : std::true_type {};

302template <typename T>
303using IsMaybe = IsMaybeImpl<std::decay_t<T>>;

305}  // namespace detail

307template <typename T, typename U = typename std::remove_cv<
                        typename std::remove_reference<T>::type>::type>
309constexpr Maybe<U> Some(T&& aValue);

311/*
* Maybe is a container class which contains either zero or one elements. It
* serves two roles. It can represent values which are *semantically* optional,
* augmenting a type with an explicit 'Nothing' value. In this role, it provides
* methods that make it easy to work with values that may be missing, along with
* equality and comparison operators so that Maybe values can be stored in
* containers. Maybe values can be constructed conveniently in expressions using
* type inference, as follows:
*
*   void doSomething(Maybe<Foo> aFoo) {
*     if (aFoo)                  // Make sure that aFoo contains a value...
*       aFoo->takeAction();      // and then use |aFoo->| to access it.
*   }                            // |*aFoo| also works!
*
*   doSomething(Nothing());      // Passes a Maybe<Foo> containing no value.
*   doSomething(Some(Foo(100))); // Passes a Maybe<Foo> containing |Foo(100)|.
*
* You'll note that it's important to check whether a Maybe contains a value
* before using it, using conversion to bool, |isSome()|, or |isNothing()|. You
* can avoid these checks, and sometimes write more readable code, using
* |valueOr()|, |ptrOr()|, and |refOr()|, which allow you to retrieve the value
* in the Maybe and provide a default for the 'Nothing' case.  You can also use
* |apply()| to call a function only if the Maybe holds a value, and |map()| to
* transform the value in the Maybe, returning another Maybe with a possibly
* different type.
*
* Maybe's other role is to support lazily constructing objects without using
* dynamic storage. A Maybe directly contains storage for a value, but it's
* empty by default. |emplace()|, as mentioned above, can be used to construct a
* value in Maybe's storage.  The value a Maybe contains can be destroyed by
* calling |reset()|; this will happen automatically if a Maybe is destroyed
* while holding a value.
*
* It's a common idiom in C++ to use a pointer as a 'Maybe' type, with a null
* value meaning 'Nothing' and any other value meaning 'Some'. You can convert
* from such a pointer to a Maybe value using 'ToMaybe()'.
*
* Maybe is inspired by similar types in the standard library of many other
* languages (e.g. Haskell's Maybe and Rust's Option). In the C++ world it's
* very similar to std::optional, which was proposed for C++14 and originated in
* Boost. The most important differences between Maybe and std::optional are:
*
*   - std::optional<T> may be compared with T. We deliberately forbid that.
*   - std::optional has |valueOr()|, equivalent to Maybe's |valueOr()|, but
*     lacks corresponding methods for |refOr()| and |ptrOr()|.
*   - std::optional lacks |map()| and |apply()|, making it less suitable for
*     functional-style code.
*   - std::optional lacks many convenience functions that Maybe has. Most
*     unfortunately, it lacks equivalents of the type-inferred constructor
*     functions |Some()| and |Nothing()|.
*/
362template <class T>
363class MOZ_INHERIT_TYPE_ANNOTATIONS_FROM_TEMPLATE_ARGS Maybe
  : private detail::MaybeStorage<T>,
    public detail::Maybe_CopyMove_Enabler<T> {
template <typename, bool, bool, bool>
friend class detail::Maybe_CopyMove_Enabler;

template <typename U, typename V>
friend constexpr Maybe<V> Some(U&& aValue);

struct SomeGuard {};

template <typename U>
constexpr Maybe(U&& aValue, SomeGuard)
    : detail::MaybeStorage<T>{std::forward<U>(aValue)} {}

using detail::MaybeStorage<T>::mIsSome;
using detail::MaybeStorage<T>::mStorage;

void poisonData() { detail::MaybePoisoner<T>::poison(&mStorage.val); }

public:
using ValueType = T;

MOZ_ALLOW_TEMPORARY constexpr Maybe() = default;

MOZ_ALLOW_TEMPORARY MOZ_IMPLICIT constexpr Maybe(Nothing) : Maybe{} {}

template <typename... Args>
constexpr explicit Maybe(std::in_place_t, Args&&... aArgs)
    : detail::MaybeStorage<T>{std::in_place, std::forward<Args>(aArgs)...} {}

/**
 * Maybe<T> can be copy-constructed from a Maybe<U> if T is constructible from
 * a const U&.
 */
template <typename U,
          std::enable_if_t<std::is_constructible_v<T, const U&>, bool> = true>
MOZ_IMPLICIT Maybe(const Maybe<U>& aOther) {
  if (aOther.isSome()) {
    emplace(*aOther);
  }
}

template <typename U, std::enable_if_t<!std::is_constructible_v<T, const U&>,
                                       bool> = true>
explicit Maybe(const Maybe<U>& aOther) = delete;

/**
 * Maybe<T> can be move-constructed from a Maybe<U> if T is constructible from
 * a U&&.
 */
template <typename U,
          std::enable_if_t<std::is_constructible_v<T, U&&>, bool> = true>
MOZ_IMPLICIT Maybe(Maybe<U>&& aOther) {
  if (aOther.isSome()) {
    emplace(std::move(*aOther));
    aOther.reset();
  }
}
template <typename U,
          std::enable_if_t<!std::is_constructible_v<T, U&&>, bool> = true>
explicit Maybe(Maybe<U>&& aOther) = delete;

template <typename U,
          std::enable_if_t<std::is_constructible_v<T, const U&>, bool> = true>
Maybe& operator=(const Maybe<U>& aOther) {
  if (aOther.isSome()) {
    if (mIsSome) {
      ref() = aOther.ref();
    } else {
      emplace(*aOther);
    }
  } else {
    reset();
  }
  return *this;
}

template <typename U, std::enable_if_t<!std::is_constructible_v<T, const U&>,
                                       bool> = true>
Maybe& operator=(const Maybe<U>& aOther) = delete;

template <typename U,
          std::enable_if_t<std::is_constructible_v<T, U&&>, bool> = true>
Maybe& operator=(Maybe<U>&& aOther) {
  if (aOther.isSome()) {
    if (mIsSome) {
      ref() = std::move(aOther.ref());
    } else {
      emplace(std::move(*aOther));
    }
    aOther.reset();
  } else {
    reset();
  }

  return *this;
}

template <typename U,
          std::enable_if_t<!std::is_constructible_v<T, U&&>, bool> = true>
Maybe& operator=(Maybe<U>&& aOther) = delete;

constexpr Maybe& operator=(Nothing) {
  reset();
  return *this;
}

/* Methods that check whether this Maybe contains a value */
constexpr explicit operator bool() const { return isSome(); }
constexpr bool isSome() const { return mIsSome; }
constexpr bool isNothing() const { return !mIsSome; }

/* Returns the contents of this Maybe<T> by value. Unsafe unless |isSome()|.
 */
constexpr T value() const&;
constexpr T value() &&;
constexpr T value() const&&;

/**
 * Move the contents of this Maybe<T> out of internal storage and return it
 * without calling the destructor. The internal storage is also reset to
 * avoid multiple calls. Unsafe unless |isSome()|.
 */
constexpr T extract() {
  MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 488); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 488; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  T v = std::move(mStorage.val);
  reset();
  return v;
}

/**
 * Returns the value (possibly |Nothing()|) by moving it out of this Maybe<T>
 * and leaving |Nothing()| in its place.
 */
Maybe<T> take() { return std::exchange(*this, Nothing()); }

/*
 * Returns the contents of this Maybe<T> by value. If |isNothing()|, returns
 * the default value provided.
 *
 * Note: If the value passed to aDefault is not the result of a trivial
 * expression, but expensive to evaluate, e.g. |valueOr(ExpensiveFunction())|,
 * use |valueOrFrom| instead, e.g.
 * |valueOrFrom([arg] { return ExpensiveFunction(arg); })|. This ensures
 * that the expensive expression is only evaluated when its result will
 * actually be used.
 */
template <typename V>
constexpr T valueOr(V&& aDefault) const {
  if (isSome()) {
    return ref();
  }
  return std::forward<V>(aDefault);
}

/*
 * Returns the contents of this Maybe<T> by value. If |isNothing()|, returns
 * the value returned from the function or functor provided.
 */
template <typename F>
constexpr T valueOrFrom(F&& aFunc) const {
  if (isSome()) {
    return ref();
  }
  return aFunc();
}

/* Returns the contents of this Maybe<T> by pointer. Unsafe unless |isSome()|.
 */
T* ptr();
constexpr const T* ptr() const;

/*
 * Returns the contents of this Maybe<T> by pointer. If |isNothing()|,
 * returns the default value provided.
 */
T* ptrOr(T* aDefault) {
  if (isSome()) {
    return ptr();
  }
  return aDefault;
}

constexpr const T* ptrOr(const T* aDefault) const {
  if (isSome()) {
    return ptr();
  }
  return aDefault;
}

/*
 * Returns the contents of this Maybe<T> by pointer. If |isNothing()|,
 * returns the value returned from the function or functor provided.
 */
template <typename F>
T* ptrOrFrom(F&& aFunc) {
  if (isSome()) {
    return ptr();
  }
  return aFunc();
}

template <typename F>
const T* ptrOrFrom(F&& aFunc) const {
  if (isSome()) {
    return ptr();
  }
  return aFunc();
}

constexpr T* operator->();
constexpr const T* operator->() const;

/* Returns the contents of this Maybe<T> by ref. Unsafe unless |isSome()|. */
constexpr T& ref() &;
constexpr const T& ref() const&;
constexpr T&& ref() &&;
constexpr const T&& ref() const&&;

/*
 * Returns the contents of this Maybe<T> by ref. If |isNothing()|, returns
 * the default value provided.
 */
constexpr T& refOr(T& aDefault) {
  if (isSome()) {
    return ref();
  }
  return aDefault;
}

constexpr const T& refOr(const T& aDefault) const {
  if (isSome()) {
    return ref();
  }
  return aDefault;
}

/*
 * Returns the contents of this Maybe<T> by ref. If |isNothing()|, returns the
 * value returned from the function or functor provided.
 */
template <typename F>
constexpr T& refOrFrom(F&& aFunc) {
  if (isSome()) {
    return ref();
  }
  return aFunc();
}

template <typename F>
constexpr const T& refOrFrom(F&& aFunc) const {
  if (isSome()) {
    return ref();
  }
  return aFunc();
}

constexpr T& operator*() &;
constexpr const T& operator*() const&;
constexpr T&& operator*() &&;
constexpr const T&& operator*() const&&;

/* If |isSome()|, runs the provided function or functor on the contents of
 * this Maybe. */
template <typename Func>
constexpr Maybe& apply(Func&& aFunc) & {
  if (isSome()) {
    std::forward<Func>(aFunc)(ref());
  }
  return *this;
}

template <typename Func>
constexpr const Maybe& apply(Func&& aFunc) const& {
  if (isSome()) {
    std::forward<Func>(aFunc)(ref());
  }
  return *this;
}

template <typename Func>
constexpr Maybe& apply(Func&& aFunc) && {
  if (isSome()) {
    std::forward<Func>(aFunc)(extract());
  }
  return *this;
}

template <typename Func>
constexpr Maybe& apply(Func&& aFunc) const&& {
  if (isSome()) {
    std::forward<Func>(aFunc)(extract());
  }
  return *this;
}

/*
 * If |isSome()|, runs the provided function and returns the result wrapped
 * in a Maybe. If |isNothing()|, returns an empty Maybe value with the same
 * value type as what the provided function would have returned.
 */
template <typename Func>
constexpr auto map(Func&& aFunc) & {
  if (isSome()) {
    return Some(std::forward<Func>(aFunc)(ref()));
  }
  return Maybe<decltype(std::forward<Func>(aFunc)(ref()))>{};
}

template <typename Func>
constexpr auto map(Func&& aFunc) const& {
  if (isSome()) {
    return Some(std::forward<Func>(aFunc)(ref()));
  }
  return Maybe<decltype(std::forward<Func>(aFunc)(ref()))>{};
}

template <typename Func>
constexpr auto map(Func&& aFunc) && {
  if (isSome()) {
    return Some(std::forward<Func>(aFunc)(extract()));
  }
  return Maybe<decltype(std::forward<Func>(aFunc)(extract()))>{};
}

template <typename Func>
constexpr auto map(Func&& aFunc) const&& {
  if (isSome()) {
    return Some(std::forward<Func>(aFunc)(extract()));
  }
  return Maybe<decltype(std::forward<Func>(aFunc)(extract()))>{};
}

/*
 * If |isSome()|, runs the provided function or functor on the contents of
 * this Maybe and returns the result. Note that the provided function or
 * functor must return a Maybe<U> of any type U.
 * If |isNothing()|, returns an empty Maybe value with the same type as what
 * the provided function would have returned.
 */
template <typename Func>
constexpr auto andThen(Func&& aFunc) & {
  static_assert(std::is_invocable_v<Func, T&>);
  using U = std::invoke_result_t<Func, T&>;
  static_assert(detail::IsMaybe<U>::value);
  if (isSome()) {
    return std::invoke(std::forward<Func>(aFunc), ref());
  }
  return std::remove_cv_t<std::remove_reference_t<U>>{};
}

template <typename Func>
constexpr auto andThen(Func&& aFunc) const& {
  static_assert(std::is_invocable_v<Func, const T&>);
  using U = std::invoke_result_t<Func, const T&>;
  static_assert(detail::IsMaybe<U>::value);
  if (isSome()) {
    return std::invoke(std::forward<Func>(aFunc), ref());
  }
  return std::remove_cv_t<std::remove_reference_t<U>>{};
}

template <typename Func>
constexpr auto andThen(Func&& aFunc) && {
  static_assert(std::is_invocable_v<Func, T&&>);
  using U = std::invoke_result_t<Func, T&&>;
  static_assert(detail::IsMaybe<U>::value);
  if (isSome()) {
    return std::invoke(std::forward<Func>(aFunc), extract());
  }
  return std::remove_cv_t<std::remove_reference_t<U>>{};
}

template <typename Func>
constexpr auto andThen(Func&& aFunc) const&& {
  static_assert(std::is_invocable_v<Func, const T&&>);
  using U = std::invoke_result_t<Func, const T&&>;
  static_assert(detail::IsMaybe<U>::value);
  if (isSome()) {
    return std::invoke(std::forward<Func>(aFunc), extract());
  }
  return std::remove_cv_t<std::remove_reference_t<U>>{};
}

/*
 * If |isNothing()|, runs the provided function or functor and returns its
 * result. If |isSome()|, returns the contained value wrapped in a Maybe.
 */
template <typename Func>
constexpr Maybe orElse(Func&& aFunc) & {
  static_assert(std::is_invocable_v<Func>);
  using U = std::invoke_result_t<Func>;
  static_assert(
      std::is_same_v<Maybe, std::remove_cv_t<std::remove_reference_t<U>>>);
  if (isSome()) {
    return *this;
  }
  return std::invoke(std::forward<Func>(aFunc));
}

template <typename Func>
constexpr Maybe orElse(Func&& aFunc) const& {
  static_assert(std::is_invocable_v<Func>);
  using U = std::invoke_result_t<Func>;
  static_assert(
      std::is_same_v<Maybe, std::remove_cv_t<std::remove_reference_t<U>>>);
  if (isSome()) {
    return *this;
  }
  return std::invoke(std::forward<Func>(aFunc));
}

template <typename Func>
constexpr Maybe orElse(Func&& aFunc) && {
  static_assert(std::is_invocable_v<Func>);
  using U = std::invoke_result_t<Func>;
  static_assert(
      std::is_same_v<Maybe, std::remove_cv_t<std::remove_reference_t<U>>>);
  if (isSome()) {
    return std::move(*this);
  }
  return std::invoke(std::forward<Func>(aFunc));
}

template <typename Func>
constexpr Maybe orElse(Func&& aFunc) const&& {
  static_assert(std::is_invocable_v<Func>);
  using U = std::invoke_result_t<Func>;
  static_assert(
      std::is_same_v<Maybe, std::remove_cv_t<std::remove_reference_t<U>>>);
  if (isSome()) {
    return std::move(*this);
  }
  return std::invoke(std::forward<Func>(aFunc));
}

/* If |isSome()|, empties this Maybe and destroys its contents. */
constexpr void reset() {
  if (isSome()) {
    if constexpr (!std::is_trivially_destructible_v<T>) {
      /*
       * Static analyzer gets confused if we have Maybe<MutexAutoLock>,
       * so we suppress thread-safety warnings here
       */
      MOZ_PUSH_IGNORE_THREAD_SAFETYGCC diagnostic push
 GCC diagnostic ignored "-Wthread-safety"

      ref().T::~T();
      MOZ_POP_THREAD_SAFETYGCC diagnostic pop
      poisonData();
    }
    mIsSome = false;
  }
}

/*
 * Constructs a T value in-place in this empty Maybe<T>'s storage. The
 * arguments to |emplace()| are the parameters to T's constructor.
 */
template <typename... Args>
constexpr void emplace(Args&&... aArgs);

template <typename U>
constexpr std::enable_if_t<std::is_same_v<T, U> &&
                           std::is_copy_constructible_v<U> &&
                           !std::is_move_constructible_v<U>>
emplace(U&& aArgs) {
  emplace(aArgs);
}

friend std::ostream& operator<<(std::ostream& aStream,
                                const Maybe<T>& aMaybe) {
  if (aMaybe) {
    aStream << aMaybe.ref();
  } else {
    aStream << "<Nothing>";
  }
  return aStream;
}
841};

843template <typename T>
844class Maybe<T&> {
public:
constexpr Maybe() = default;
constexpr MOZ_IMPLICIT Maybe(Nothing) {}

void emplace(T& aRef) { mValue = &aRef; }

/* Methods that check whether this Maybe contains a value */
constexpr explicit operator bool() const { return isSome(); }
constexpr bool isSome() const { return mValue; }
constexpr bool isNothing() const { return !mValue; }

T& ref() const {
  MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 857); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 857; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  return *mValue;
}

T* operator->() const { return &ref(); }
T& operator*() const { return ref(); }

// Deliberately not defining value and ptr accessors, as these may be
// confusing on a reference-typed Maybe.

// XXX Should we define refOr?

void reset() { mValue = nullptr; }

template <typename Func>
const Maybe& apply(Func&& aFunc) const {
  if (isSome()) {
    std::forward<Func>(aFunc)(ref());
  }
  return *this;
}

template <typename Func>
auto map(Func&& aFunc) const {
  Maybe<decltype(std::forward<Func>(aFunc)(ref()))> val;
  if (isSome()) {
    val.emplace(std::forward<Func>(aFunc)(ref()));
  }
  return val;
}

template <typename Func>
constexpr auto andThen(Func&& aFunc) const {
  static_assert(std::is_invocable_v<Func, T&>);
  using U = std::invoke_result_t<Func, T&>;
  static_assert(detail::IsMaybe<U>::value);
  if (isSome()) {
    return std::invoke(std::forward<Func>(aFunc), ref());
  }
  return std::remove_cv_t<std::remove_reference_t<U>>{};
}

template <typename Func>
constexpr Maybe orElse(Func&& aFunc) const {
  static_assert(std::is_invocable_v<Func>);
  using U = std::invoke_result_t<Func>;
  static_assert(
      std::is_same_v<Maybe, std::remove_cv_t<std::remove_reference_t<U>>>);
  if (isSome()) {
    return *this;
  }
  return std::invoke(std::forward<Func>(aFunc));
}

bool refEquals(const Maybe<T&>& aOther) const {
  return mValue == aOther.mValue;
}

bool refEquals(const T& aOther) const { return mValue == &aOther; }

private:
T* mValue = nullptr;
919};

921template <typename T>
922constexpr T Maybe<T>::value() const& {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 923); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 923; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return ref();
925}

927template <typename T>
928constexpr T Maybe<T>::value() && {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 929); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 929; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return std::move(ref());
931}

933template <typename T>
934constexpr T Maybe<T>::value() const&& {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 935); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 935; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return std::move(ref());
937}

939template <typename T>
940T* Maybe<T>::ptr() {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 941); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 941; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return &ref();
943}

945template <typename T>
946constexpr const T* Maybe<T>::ptr() const {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 947); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 947; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return &ref();
949}

951template <typename T>
952constexpr T* Maybe<T>::operator->() {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 953); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 953; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return ptr();
955}

957template <typename T>
958constexpr const T* Maybe<T>::operator->() const {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 959); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 959; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return ptr();
961}

963template <typename T>
964constexpr T& Maybe<T>::ref() & {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 965); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 965; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return mStorage.val;
967}

969template <typename T>
970constexpr const T& Maybe<T>::ref() const& {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 971); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 971; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return mStorage.val;
973}

975template <typename T>
976constexpr T&& Maybe<T>::ref() && {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 977); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 977; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return std::move(mStorage.val);
979}

981template <typename T>
982constexpr const T&& Maybe<T>::ref() const&& {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 983); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 983; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return std::move(mStorage.val);
985}

987template <typename T>
988constexpr T& Maybe<T>::operator*() & {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 989); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 989; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return ref();
991}

993template <typename T>
994constexpr const T& Maybe<T>::operator*() const& {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 995); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 995; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return ref();
997}

999template <typename T>
1000constexpr T&& Maybe<T>::operator*() && {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 1001); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 1001; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return std::move(ref());
1003}

1005template <typename T>
1006constexpr const T&& Maybe<T>::operator*() const&& {
MOZ_RELEASE_ASSERT(isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 1007); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "isSome()"
 ")"); do { *((volatile int*)__null) = 1007; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
return std::move(ref());
1009}

1011template <typename T>
1012template <typename... Args>
1013constexpr void Maybe<T>::emplace(Args&&... aArgs) {
MOZ_RELEASE_ASSERT(!isSome())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!isSome())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!isSome()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("!isSome()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/Maybe.h"
, 1014); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "!isSome()"
 ")"); do { *((volatile int*)__null) = 1014; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
::new (KnownNotNull, &mStorage.val) T(std::forward<Args>(aArgs)...);
mIsSome = true;
1017}

1019/*
* Some() creates a Maybe<T> value containing the provided T value. If T has a
* move constructor, it's used to make this as efficient as possible.
*
* Some() selects the type of Maybe it returns by removing any const, volatile,
* or reference qualifiers from the type of the value you pass to it. This gives
* it more intuitive behavior when used in expressions, but it also means that
* if you need to construct a Maybe value that holds a const, volatile, or
* reference value, you need to use emplace() instead.
*/
1029template <typename T, typename U>
1030constexpr Maybe<U> Some(T&& aValue) {
return {std::forward<T>(aValue), typename Maybe<U>::SomeGuard{}};
1032}

1034template <typename T>
1035constexpr Maybe<T&> SomeRef(T& aValue) {
Maybe<T&> value;
value.emplace(aValue);
return value;
1039}

1041template <typename T>
1042constexpr Maybe<T&> ToMaybeRef(T* const aPtr) {
return aPtr ? SomeRef(*aPtr) : Nothing{};
1044}

1046template <typename T>
1047Maybe<std::remove_cv_t<std::remove_reference_t<T>>> ToMaybe(T* aPtr) {
if (aPtr) {
  return Some(*aPtr);
}
return Nothing();
1052}

1054/*
* Two Maybe<T> values are equal if
* - both are Nothing, or
* - both are Some, and the values they contain are equal.
*/
1059template <typename T>
1060constexpr bool operator==(const Maybe<T>& aLHS, const Maybe<T>& aRHS) {
static_assert(!std::is_reference_v<T>,
              "operator== is not defined for Maybe<T&>, compare values or "
              "addresses explicitly instead");
if (aLHS.isNothing() != aRHS.isNothing()) {
  return false;
}
return aLHS.isNothing() || *aLHS == *aRHS;
1068}

1070template <typename T>
1071constexpr bool operator!=(const Maybe<T>& aLHS, const Maybe<T>& aRHS) {
return !(aLHS == aRHS);
1073}

1075/*
* We support comparison to Nothing to allow reasonable expressions like:
*   if (maybeValue == Nothing()) { ... }
*/
1079template <typename T>
1080constexpr bool operator==(const Maybe<T>& aLHS, const Nothing& aRHS) {
return aLHS.isNothing();
1082}

1084template <typename T>
1085constexpr bool operator!=(const Maybe<T>& aLHS, const Nothing& aRHS) {
return !(aLHS == aRHS);
1087}

1089template <typename T>
1090constexpr bool operator==(const Nothing& aLHS, const Maybe<T>& aRHS) {
return aRHS.isNothing();
1092}

1094template <typename T>
1095constexpr bool operator!=(const Nothing& aLHS, const Maybe<T>& aRHS) {
return !(aLHS == aRHS);
1097}

1099/*
* Maybe<T> values are ordered in the same way T values are ordered, except that
* Nothing comes before anything else.
*/
1103template <typename T>
1104constexpr bool operator<(const Maybe<T>& aLHS, const Maybe<T>& aRHS) {
if (aLHS.isNothing()) {
  return aRHS.isSome();
}
if (aRHS.isNothing()) {
  return false;
}
return *aLHS < *aRHS;
1112}

1114template <typename T>
1115constexpr bool operator>(const Maybe<T>& aLHS, const Maybe<T>& aRHS) {
return !(aLHS < aRHS || aLHS == aRHS);
1117}

1119template <typename T>
1120constexpr bool operator<=(const Maybe<T>& aLHS, const Maybe<T>& aRHS) {
return aLHS < aRHS || aLHS == aRHS;
1122}

1124template <typename T>
1125constexpr bool operator>=(const Maybe<T>& aLHS, const Maybe<T>& aRHS) {
return !(aLHS < aRHS);
1127}

1129template <typename T>
1130inline void ImplCycleCollectionTraverse(
  nsCycleCollectionTraversalCallback& aCallback, mozilla::Maybe<T>& aField,
  const char* aName, uint32_t aFlags = 0) {
if (aField) {
  ImplCycleCollectionTraverse(aCallback, aField.ref(), aName, aFlags);
}
1136}

1138template <typename T>
1139inline void ImplCycleCollectionUnlink(mozilla::Maybe<T>& aField) {
if (aField) {
  ImplCycleCollectionUnlink(aField.ref());
}
1143}

1145}  // namespace mozilla

1147#endif /* mozilla_Maybe_h */

←

/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h

→

1	/* -- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 --
2	* vim: set ts=8 sts=2 et sw=2 tw=80:
3	* This Source Code Form is subject to the terms of the Mozilla Public
4	* License, v. 2.0. If a copy of the MPL was not distributed with this
5	* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6
7	#ifndef js_UbiNodeShortestPaths_h
8	#define js_UbiNodeShortestPaths_h
9
10	#include "mozilla/CheckedInt.h"
11	#include "mozilla/Maybe.h"
12
13	#include <utility>
14
15	#include "js/AllocPolicy.h"
16	#include "js/GCAPI.h"
17	#include "js/UbiNode.h"
18	#include "js/UbiNodeBreadthFirst.h"
19	#include "js/UniquePtr.h"
20
21	namespace JS {
22	namespace ubi {
23
24	/**
25	* A back edge along a path in the heap graph.
26	*/
27	struct JS_PUBLIC_API BackEdge {
28	private:
29	Node predecessor_;
30	EdgeName name_;
31
32	public:
33	using Ptr = js::UniquePtr<BackEdge>;
34
35	BackEdge() : predecessor_(), name_(nullptr) {}
36
37	[[nodiscard]] bool init(const Node& predecessor, Edge& edge) {
38	MOZ_ASSERT(!predecessor_)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!predecessor_)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!predecessor_))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!predecessor_", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 38); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!predecessor_" ")"); do { ((volatile int)__null) = 38; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
39	MOZ_ASSERT(!name_)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!name_)>::isValid, "invalid assertion condition") ; if ((__builtin_expect(!!(!(!!(!name_))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!name_", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 39); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!name_" ")"); do { ((volatile int)__null) = 39; __attribute__((nomerge)) ::abort(); } while (false); } } while (false);
40
41	predecessor_ = predecessor;
42	name_ = std::move(edge.name);
43	return true;
44	}
45
46	BackEdge(const BackEdge&) = delete;
47	BackEdge& operator=(const BackEdge&) = delete;
48
49	BackEdge(BackEdge&& rhs)
50	: predecessor_(rhs.predecessor_), name_(std::move(rhs.name_)) {
51	MOZ_ASSERT(&rhs != this)do { static_assert( mozilla::detail::AssertionConditionType< decltype(&rhs != this)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(&rhs != this))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("&rhs != this" , "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 51); AnnotateMozCrashReason("MOZ_ASSERT" "(" "&rhs != this" ")"); do { ((volatile int)__null) = 51; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
52	}
53
54	BackEdge& operator=(BackEdge&& rhs) {
55	this->~BackEdge();
56	new (this) BackEdge(std::move(rhs));
57	return *this;
58	}
59
60	Ptr clone() const;
61
62	const EdgeName& name() const { return name_; }
63	EdgeName& name() { return name_; }
64
65	const JS::ubi::Node& predecessor() const { return predecessor_; }
66	};
67
68	/**
69	* A path is a series of back edges from which we discovered a target node.
70	*/
71	using Path = JS::ubi::Vector<BackEdge*>;
72
73	/**
74	* The `JS::ubi::ShortestPaths` type represents a collection of up to N shortest
75	* retaining paths for each of a target set of nodes, starting from the same
76	* root node.
77	*/
78	struct JS_PUBLIC_API ShortestPaths {
79	private:
80	// Types, type aliases, and data members.
81
82	using BackEdgeVector = JS::ubi::Vector<BackEdge::Ptr>;
83	using NodeToBackEdgeVectorMap =
84	js::HashMap<Node, BackEdgeVector, js::DefaultHasher<Node>,
85	js::SystemAllocPolicy>;
86
87	struct Handler;
88	using Traversal = BreadthFirst<Handler>;
89
90	/**
91	* A `JS::ubi::BreadthFirst` traversal handler that records back edges for
92	* how we reached each node, allowing us to reconstruct the shortest
93	* retaining paths after the traversal.
94	*/
95	struct Handler {
96	using NodeData = BackEdge;
97
98	ShortestPaths& shortestPaths;
99	size_t totalMaxPathsToRecord;
100	size_t totalPathsRecorded;
101
102	explicit Handler(ShortestPaths& shortestPaths)
103	: shortestPaths(shortestPaths),
104	totalMaxPathsToRecord(shortestPaths.targets_.count() *
105	shortestPaths.maxNumPaths_),
106	totalPathsRecorded(0) {}
107
108	bool operator()(Traversal& traversal, const JS::ubi::Node& origin,
109	JS::ubi::Edge& edge, BackEdge* back, bool first) {
110	MOZ_ASSERT(back)do { static_assert( mozilla::detail::AssertionConditionType< decltype(back)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(back))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("back", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 110); AnnotateMozCrashReason("MOZ_ASSERT" "(" "back" ")"); do { ((volatile int)__null) = 110; __attribute__((nomerge)) :: abort(); } while (false); } } while (false);
111	MOZ_ASSERT(origin == shortestPaths.root_ \|\|do { static_assert( mozilla::detail::AssertionConditionType< decltype(origin == shortestPaths.root_ \|\| traversal.visited.has (origin))>::isValid, "invalid assertion condition"); if (( __builtin_expect(!!(!(!!(origin == shortestPaths.root_ \|\| traversal .visited.has(origin)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("origin == shortestPaths.root_ \|\| traversal.visited.has(origin)" , "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 112); AnnotateMozCrashReason("MOZ_ASSERT" "(" "origin == shortestPaths.root_ \|\| traversal.visited.has(origin)" ")"); do { ((volatile int)__null) = 112; __attribute__((nomerge )) ::abort(); } while (false); } } while (false)
112	traversal.visited.has(origin))do { static_assert( mozilla::detail::AssertionConditionType< decltype(origin == shortestPaths.root_ \|\| traversal.visited.has (origin))>::isValid, "invalid assertion condition"); if (( __builtin_expect(!!(!(!!(origin == shortestPaths.root_ \|\| traversal .visited.has(origin)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("origin == shortestPaths.root_ \|\| traversal.visited.has(origin)" , "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 112); AnnotateMozCrashReason("MOZ_ASSERT" "(" "origin == shortestPaths.root_ \|\| traversal.visited.has(origin)" ")"); do { ((volatile int)__null) = 112; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
113	MOZ_ASSERT(totalPathsRecorded < totalMaxPathsToRecord)do { static_assert( mozilla::detail::AssertionConditionType< decltype(totalPathsRecorded < totalMaxPathsToRecord)>:: isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!(totalPathsRecorded < totalMaxPathsToRecord))), 0) )) { do { } while (false); MOZ_ReportAssertionFailure("totalPathsRecorded < totalMaxPathsToRecord" , "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 113); AnnotateMozCrashReason("MOZ_ASSERT" "(" "totalPathsRecorded < totalMaxPathsToRecord" ")"); do { ((volatile int)__null) = 113; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
114
115	if (first && !back->init(origin, edge)) {
116	return false;
117	}
118
119	if (!shortestPaths.targets_.has(edge.referent)) {
120	return true;
121	}
122
123	// If `first` is true, then we moved the edge's name into `back` in
124	// the above call to `init`. So clone that back edge to get the
125	// correct edge name. If `first` is not true, then our edge name is
126	// still in `edge`. This accounts for the asymmetry between
127	// `back->clone()` in the first branch, and the `init` call in the
128	// second branch.
129
130	if (first) {
131	BackEdgeVector paths;
132	if (!paths.reserve(shortestPaths.maxNumPaths_)) {
133	return false;
134	}
135	auto cloned = back->clone();
136	if (!cloned) {
137	return false;
138	}
139	paths.infallibleAppend(std::move(cloned));
140	if (!shortestPaths.paths_.putNew(edge.referent, std::move(paths))) {
141	return false;
142	}
143	totalPathsRecorded++;
144	} else {
145	auto ptr = shortestPaths.paths_.lookup(edge.referent);
146	MOZ_ASSERT(ptr,do { static_assert( mozilla::detail::AssertionConditionType< decltype(ptr)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(ptr))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("ptr" " (" "This isn't the first time we have seen the target node " "`edge.referent`. " "We should have inserted it into shortestPaths.paths_ the " "first time we " "saw it." ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 151); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ptr" ") (" "This isn't the first time we have seen the target node " "`edge.referent`. " "We should have inserted it into shortestPaths.paths_ the " "first time we " "saw it." ")"); do { ((volatile int)__null ) = 151; __attribute__((nomerge)) ::abort(); } while (false); } } while (false)
147	"This isn't the first time we have seen the target node "do { static_assert( mozilla::detail::AssertionConditionType< decltype(ptr)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(ptr))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("ptr" " (" "This isn't the first time we have seen the target node " "`edge.referent`. " "We should have inserted it into shortestPaths.paths_ the " "first time we " "saw it." ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 151); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ptr" ") (" "This isn't the first time we have seen the target node " "`edge.referent`. " "We should have inserted it into shortestPaths.paths_ the " "first time we " "saw it." ")"); do { ((volatile int)__null ) = 151; __attribute__((nomerge)) ::abort(); } while (false); } } while (false)
148	"`edge.referent`. "do { static_assert( mozilla::detail::AssertionConditionType< decltype(ptr)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(ptr))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("ptr" " (" "This isn't the first time we have seen the target node " "`edge.referent`. " "We should have inserted it into shortestPaths.paths_ the " "first time we " "saw it." ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 151); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ptr" ") (" "This isn't the first time we have seen the target node " "`edge.referent`. " "We should have inserted it into shortestPaths.paths_ the " "first time we " "saw it." ")"); do { ((volatile int)__null ) = 151; __attribute__((nomerge)) ::abort(); } while (false); } } while (false)
149	"We should have inserted it into shortestPaths.paths_ the "do { static_assert( mozilla::detail::AssertionConditionType< decltype(ptr)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(ptr))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("ptr" " (" "This isn't the first time we have seen the target node " "`edge.referent`. " "We should have inserted it into shortestPaths.paths_ the " "first time we " "saw it." ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 151); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ptr" ") (" "This isn't the first time we have seen the target node " "`edge.referent`. " "We should have inserted it into shortestPaths.paths_ the " "first time we " "saw it." ")"); do { ((volatile int)__null ) = 151; __attribute__((nomerge)) ::abort(); } while (false); } } while (false)
150	"first time we "do { static_assert( mozilla::detail::AssertionConditionType< decltype(ptr)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(ptr))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("ptr" " (" "This isn't the first time we have seen the target node " "`edge.referent`. " "We should have inserted it into shortestPaths.paths_ the " "first time we " "saw it." ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 151); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ptr" ") (" "This isn't the first time we have seen the target node " "`edge.referent`. " "We should have inserted it into shortestPaths.paths_ the " "first time we " "saw it." ")"); do { ((volatile int)__null ) = 151; __attribute__((nomerge)) ::abort(); } while (false); } } while (false)
151	"saw it.")do { static_assert( mozilla::detail::AssertionConditionType< decltype(ptr)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(ptr))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("ptr" " (" "This isn't the first time we have seen the target node " "`edge.referent`. " "We should have inserted it into shortestPaths.paths_ the " "first time we " "saw it." ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 151); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ptr" ") (" "This isn't the first time we have seen the target node " "`edge.referent`. " "We should have inserted it into shortestPaths.paths_ the " "first time we " "saw it." ")"); do { ((volatile int)__null ) = 151; __attribute__((nomerge)) ::abort(); } while (false); } } while (false);
152
153	if (ptr->value().length() < shortestPaths.maxNumPaths_) {
154	auto thisBackEdge = js::MakeUnique<BackEdge>();
155	if (!thisBackEdge \|\| !thisBackEdge->init(origin, edge)) {
156	return false;
157	}
158	ptr->value().infallibleAppend(std::move(thisBackEdge));
159	totalPathsRecorded++;
160	}
161	}
162
163	MOZ_ASSERT(totalPathsRecorded <= totalMaxPathsToRecord)do { static_assert( mozilla::detail::AssertionConditionType< decltype(totalPathsRecorded <= totalMaxPathsToRecord)>:: isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!(totalPathsRecorded <= totalMaxPathsToRecord))), 0 ))) { do { } while (false); MOZ_ReportAssertionFailure("totalPathsRecorded <= totalMaxPathsToRecord" , "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 163); AnnotateMozCrashReason("MOZ_ASSERT" "(" "totalPathsRecorded <= totalMaxPathsToRecord" ")"); do { ((volatile int)__null) = 163; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
164	if (totalPathsRecorded == totalMaxPathsToRecord) {
165	traversal.stop();
166	}
167
168	return true;
169	}
170	};
171
172	// The maximum number of paths to record for each node.
173	uint32_t maxNumPaths_;
174
175	// The root node we are starting the search from.
176	Node root_;
177
178	// The set of nodes we are searching for paths to.
179	NodeSet targets_;
180
181	// The resulting paths.
182	NodeToBackEdgeVectorMap paths_;
183
184	// Need to keep alive the traversal's back edges so we can walk them later
185	// when the traversal is over when recreating the shortest paths.
186	Traversal::NodeMap backEdges_;
187
188	private:
189	// Private methods.
190
191	ShortestPaths(uint32_t maxNumPaths, const Node& root, NodeSet&& targets)
192	: maxNumPaths_(maxNumPaths),
193	root_(root),
194	targets_(std::move(targets)),
195	paths_(targets_.count()),
196	backEdges_() {
197	MOZ_ASSERT(maxNumPaths_ > 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(maxNumPaths_ > 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(maxNumPaths_ > 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("maxNumPaths_ > 0" , "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 197); AnnotateMozCrashReason("MOZ_ASSERT" "(" "maxNumPaths_ > 0" ")"); do { ((volatile int)__null) = 197; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
198	MOZ_ASSERT(root_)do { static_assert( mozilla::detail::AssertionConditionType< decltype(root_)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(root_))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("root_", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 198); AnnotateMozCrashReason("MOZ_ASSERT" "(" "root_" ")"); do { ((volatile int)__null) = 198; __attribute__((nomerge) ) ::abort(); } while (false); } } while (false);
199	}
200
201	public:
202	// Public methods.
203
204	ShortestPaths(ShortestPaths&& rhs)
205	: maxNumPaths_(rhs.maxNumPaths_),
206	root_(rhs.root_),
207	targets_(std::move(rhs.targets_)),
208	paths_(std::move(rhs.paths_)),
209	backEdges_(std::move(rhs.backEdges_)) {
210	MOZ_ASSERT(this != &rhs, "self-move is not allowed")do { static_assert( mozilla::detail::AssertionConditionType< decltype(this != &rhs)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(this != &rhs))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("this != &rhs" " (" "self-move is not allowed" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 210); AnnotateMozCrashReason("MOZ_ASSERT" "(" "this != &rhs" ") (" "self-move is not allowed" ")"); do { ((volatile int )__null) = 210; __attribute__((nomerge)) ::abort(); } while ( false); } } while (false);
211	}
212
213	ShortestPaths& operator=(ShortestPaths&& rhs) {
214	this->~ShortestPaths();
215	new (this) ShortestPaths(std::move(rhs));
216	return *this;
217	}
218
219	ShortestPaths(const ShortestPaths&) = delete;
220	ShortestPaths& operator=(const ShortestPaths&) = delete;
221
222	/**
223	* Construct a new `JS::ubi::ShortestPaths`, finding up to `maxNumPaths`
224	* shortest retaining paths for each target node in `targets` starting from
225	* `root`.
226	*
227	* The resulting `ShortestPaths` instance must not outlive the
228	* `JS::ubi::Node` graph it was constructed from.
229	*
230	* - For `JS::ubi::Node` graphs backed by the live heap graph, this means
231	* that the `ShortestPaths`'s lifetime _must_ be contained within the
232	* scope of the provided `AutoCheckCannotGC` reference because a GC will
233	* invalidate the nodes.
234	*
235	* - For `JS::ubi::Node` graphs backed by some other offline structure
236	* provided by the embedder, the resulting `ShortestPaths`'s lifetime is
237	* bounded by that offline structure's lifetime.
238	*
239	* Returns `mozilla::Nothing()` on OOM failure. It is the caller's
240	* responsibility to handle and report the OOM.
241	*/
242	static mozilla::Maybe<ShortestPaths> Create(JSContext* cx,
243	AutoCheckCannotGC& noGC,
244	uint32_t maxNumPaths,
245	const Node& root,
246	NodeSet&& targets) {
247	MOZ_ASSERT(targets.count() > 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(targets.count() > 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(targets.count() > 0))), 0 ))) { do { } while (false); MOZ_ReportAssertionFailure("targets.count() > 0" , "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 247); AnnotateMozCrashReason("MOZ_ASSERT" "(" "targets.count() > 0" ")"); do { ((volatile int)__null) = 247; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
248	MOZ_ASSERT(maxNumPaths > 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(maxNumPaths > 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(maxNumPaths > 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("maxNumPaths > 0" , "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 248); AnnotateMozCrashReason("MOZ_ASSERT" "(" "maxNumPaths > 0" ")"); do { ((volatile int)__null) = 248; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
249
250	mozilla::CheckedInt<uint32_t> max = maxNumPaths;
251	max *= targets.count();
252	if (!max.isValid()) {
253	return mozilla::Nothing();
254	}
255
256	ShortestPaths paths(maxNumPaths, root, std::move(targets));
257
258	Handler handler(paths);
259	Traversal traversal(cx, handler, noGC);
260	traversal.wantNames = true;
261	if (!traversal.addStart(root) \|\| !traversal.traverse()) {
262	return mozilla::Nothing();
263	}
264
265	// Take ownership of the back edges we created while traversing the
266	// graph so that we can follow them from `paths_` and don't
267	// use-after-free.
268	paths.backEdges_ = std::move(traversal.visited);
269
270	return mozilla::Some(std::move(paths));
271	}
272
273	/**
274	* Get an iterator over each target node we searched for retaining paths
275	* for. The returned iterator must not outlive the `ShortestPaths`
276	* instance.
277	*/
278	NodeSet::Iterator targetIter() const { return targets_.iter(); }
279
280	/**
281	* Invoke the provided functor/lambda/callable once for each retaining path
282	* discovered for `target`. The `func` is passed a single `JS::ubi::Path&`
283	* argument, which contains each edge along the path ordered starting from
284	* the root and ending at the target, and must not outlive the scope of the
285	* call.
286	*
287	* Note that it is possible that we did not find any paths from the root to
288	* the given target, in which case `func` will not be invoked.
289	*/
290	template <class Func>
291	[[nodiscard]] bool forEachPath(const Node& target, Func func) {
292	MOZ_ASSERT(targets_.has(target))do { static_assert( mozilla::detail::AssertionConditionType< decltype(targets_.has(target))>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(targets_.has(target)))), 0)) ) { do { } while (false); MOZ_ReportAssertionFailure("targets_.has(target)" , "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 292); AnnotateMozCrashReason("MOZ_ASSERT" "(" "targets_.has(target)" ")"); do { ((volatile int)__null) = 292; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
293
294	auto ptr = paths_.lookup(target);
295
296	// We didn't find any paths to this target, so nothing to do here.
297	if (!ptr) {
298	return true;
299	}
300
301	MOZ_ASSERT(ptr->value().length() <= maxNumPaths_)do { static_assert( mozilla::detail::AssertionConditionType< decltype(ptr->value().length() <= maxNumPaths_)>::isValid , "invalid assertion condition"); if ((__builtin_expect(!!(!( !!(ptr->value().length() <= maxNumPaths_))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("ptr->value().length() <= maxNumPaths_" , "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 301); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ptr->value().length() <= maxNumPaths_" ")"); do { ((volatile int)__null) = 301; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
302
303	Path path;
304	for (const auto& backEdge : ptr->value()) {
305	path.clear();
306
307	if (!path.append(backEdge.get())) {
308	return false;
309	}
310
311	Node here = backEdge->predecessor();
312	MOZ_ASSERT(here)do { static_assert( mozilla::detail::AssertionConditionType< decltype(here)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(here))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("here", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 312); AnnotateMozCrashReason("MOZ_ASSERT" "(" "here" ")"); do { ((volatile int)__null) = 312; __attribute__((nomerge)) :: abort(); } while (false); } } while (false);
313
314	while (here != root_) {
315	auto p = backEdges_.lookup(here);
316	MOZ_ASSERT(p)do { static_assert( mozilla::detail::AssertionConditionType< decltype(p)>::isValid, "invalid assertion condition"); if ( (__builtin_expect(!!(!(!!(p))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("p", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 316); AnnotateMozCrashReason("MOZ_ASSERT" "(" "p" ")"); do { ((volatile int)__null) = 316; __attribute__((nomerge)) ::abort (); } while (false); } } while (false);
317	if (!path.append(&p->value())) {
318	return false;
319	}
320	here = p->value().predecessor();
321	MOZ_ASSERT(here)do { static_assert( mozilla::detail::AssertionConditionType< decltype(here)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(here))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("here", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/UbiNodeShortestPaths.h" , 321); AnnotateMozCrashReason("MOZ_ASSERT" "(" "here" ")"); do { ((volatile int)__null) = 321; __attribute__((nomerge)) :: abort(); } while (false); } } while (false);
322	}
323
324	path.reverse();
325
326	if (!func(path)) {
327	return false;
328	}
329	}
330
331	return true;
332	}
333	};
334
335	#ifdef DEBUG1
336	// A helper function to dump the first `maxNumPaths` shortest retaining paths to
337	// `node` from the GC roots. Useful when GC things you expect to have been
338	// reclaimed by the collector haven't been!
339	//
340	// Usage:
341	//
342	// JSObject* foo = ...;
343	// JS::ubi::dumpPaths(rt, JS::ubi::Node(foo));
344	JS_PUBLIC_API void dumpPaths(JSRuntime* rt, Node node,
345	uint32_t maxNumPaths = 10);
346	#endif
347
348	} // namespace ubi
349	} // namespace JS
350
351	#endif // js_UbiNodeShortestPaths_h

←

/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h

→

1/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2/* vim: set ts=8 sts=2 et sw=2 tw=80: */
3/* 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/. */

7//---------------------------------------------------------------------------
8// Overview
9//---------------------------------------------------------------------------
10//
11// This file defines HashMap<Key, Value> and HashSet<T>, hash tables that are
12// fast and have a nice API.
13//
14// Both hash tables have two optional template parameters.
15//
16// - HashPolicy. This defines the operations for hashing and matching keys. The
17//   default HashPolicy is appropriate when both of the following two
18//   conditions are true.
19//
20//   - The key type stored in the table (|Key| for |HashMap<Key, Value>|, |T|
21//     for |HashSet<T>|) is an integer, pointer, UniquePtr, float, or double.
22//
23//   - The type used for lookups (|Lookup|) is the same as the key type. This
24//     is usually the case, but not always.
25//
26//   There is also a |CStringHasher| policy for |char*| keys. If your keys
27//   don't match any of the above cases, you must provide your own hash policy;
28//   see the "Hash Policy" section below.
29//
30// - AllocPolicy. This defines how allocations are done by the table.
31//
32//   - |MallocAllocPolicy| is the default and is usually appropriate; note that
33//     operations (such as insertions) that might cause allocations are
34//     fallible and must be checked for OOM. These checks are enforced by the
35//     use of [[nodiscard]].
36//
37//   - |InfallibleAllocPolicy| is another possibility; it allows the
38//     abovementioned OOM checks to be done with MOZ_ALWAYS_TRUE().
39//
40//   Note that entry storage allocation is lazy, and not done until the first
41//   lookupForAdd(), put(), or putNew() is performed.
42//
43//  See AllocPolicy.h for more details.
44//
45// Documentation on how to use HashMap and HashSet, including examples, is
46// present within those classes. Search for "class HashMap" and "class
47// HashSet".
48//
49// Both HashMap and HashSet are implemented on top of a third class, HashTable.
50// You only need to look at HashTable if you want to understand the
51// implementation.
52//
53// How does mozilla::HashTable (this file) compare with PLDHashTable (and its
54// subclasses, such as nsTHashtable)?
55//
56// - mozilla::HashTable is a lot faster, largely because it uses templates
57//   throughout *and* inlines everything. PLDHashTable inlines operations much
58//   less aggressively, and also uses "virtual ops" for operations like hashing
59//   and matching entries that require function calls.
60//
61// - Correspondingly, mozilla::HashTable use is likely to increase executable
62//   size much more than PLDHashTable.
63//
64// - mozilla::HashTable has a nicer API, with a proper HashSet vs. HashMap
65//   distinction.
66//
67// - mozilla::HashTable requires more explicit OOM checking. As mentioned
68//   above, the use of |InfallibleAllocPolicy| can simplify things.
69//
70// - mozilla::HashTable has a default capacity on creation of 32 and a minimum
71//   capacity of 4. PLDHashTable has a default capacity on creation of 8 and a
72//   minimum capacity of 8.

74#ifndef mozilla_HashTable_h
75#define mozilla_HashTable_h

77#include <utility>
78#include <type_traits>

80#include "mozilla/AllocPolicy.h"
81#include "mozilla/Assertions.h"
82#include "mozilla/Attributes.h"
83#include "mozilla/Casting.h"
84#include "mozilla/HashFunctions.h"
85#include "mozilla/MathAlgorithms.h"
86#include "mozilla/Maybe.h"
87#include "mozilla/MemoryChecking.h"
88#include "mozilla/MemoryReporting.h"
89#include "mozilla/Opaque.h"
90#include "mozilla/OperatorNewExtensions.h"
91#include "mozilla/ReentrancyGuard.h"
92#include "mozilla/UniquePtr.h"
93#include "mozilla/WrappingOperations.h"

95namespace mozilla {

97template <class, class = void>
98struct DefaultHasher;

100template <class, class>
101class HashMapEntry;

103namespace detail {

105template <typename T>
106class HashTableEntry;

108template <class T, class HashPolicy, class AllocPolicy>
109class HashTable;

111}  // namespace detail

113// The "generation" of a hash table is an opaque value indicating the state of
114// modification of the hash table through its lifetime.  If the generation of
115// a hash table compares equal at times T1 and T2, then lookups in the hash
116// table, pointers to (or into) hash table entries, etc. at time T1 are valid
117// at time T2.  If the generation compares unequal, these computations are all
118// invalid and must be performed again to be used.
119//
120// Generations are meaningfully comparable only with respect to a single hash
121// table.  It's always nonsensical to compare the generation of distinct hash
122// tables H1 and H2.
123using Generation = Opaque<uint64_t>;

125//---------------------------------------------------------------------------
126// HashMap
127//---------------------------------------------------------------------------

129// HashMap is a fast hash-based map from keys to values.
130//
131// Template parameter requirements:
132// - Key/Value: movable, destructible, assignable.
133// - HashPolicy: see the "Hash Policy" section below.
134// - AllocPolicy: see AllocPolicy.h.
135//
136// Note:
137// - HashMap is not reentrant: Key/Value/HashPolicy/AllocPolicy members
138//   called by HashMap must not call back into the same HashMap object.
139//
140template <class Key, class Value, class HashPolicy = DefaultHasher<Key>,
        class AllocPolicy = MallocAllocPolicy>
142class HashMap {
// -- Implementation details -----------------------------------------------

// HashMap is not copyable or assignable.
HashMap(const HashMap& hm) = delete;
HashMap& operator=(const HashMap& hm) = delete;

using TableEntry = HashMapEntry<Key, Value>;

struct MapHashPolicy : HashPolicy {
  using Base = HashPolicy;
  using KeyType = Key;

  static const Key& getKey(TableEntry& aEntry) { return aEntry.key(); }

  static void setKey(TableEntry& aEntry, Key& aKey) {
    HashPolicy::rekey(aEntry.mutableKey(), aKey);
  }
};

using Impl = detail::HashTable<TableEntry, MapHashPolicy, AllocPolicy>;
Impl mImpl;

friend class Impl::Enum;

public:
using Lookup = typename HashPolicy::Lookup;
using Entry = TableEntry;

// -- Initialization -------------------------------------------------------

explicit HashMap(AllocPolicy aAllocPolicy = AllocPolicy(),
                 uint32_t aLen = Impl::sDefaultLen)
    : mImpl(std::move(aAllocPolicy), aLen) {}

explicit HashMap(uint32_t aLen) : mImpl(AllocPolicy(), aLen) {}

// HashMap is movable.
HashMap(HashMap&& aRhs) = default;
HashMap& operator=(HashMap&& aRhs) = default;

// -- Status and sizing ----------------------------------------------------

// The map's current generation.
Generation generation() const { return mImpl.generation(); }

// Is the map empty?
bool empty() const { return mImpl.empty(); }

// Number of keys/values in the map.
uint32_t count() const { return mImpl.count(); }

// Number of key/value slots in the map. Note: resize will happen well before
// count() == capacity().
uint32_t capacity() const { return mImpl.capacity(); }

// The size of the map's entry storage, in bytes. If the keys/values contain
// pointers to other heap blocks, you must iterate over the map and measure
// them separately; hence the "shallow" prefix.
size_t shallowSizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
  return mImpl.shallowSizeOfExcludingThis(aMallocSizeOf);
}
size_t shallowSizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
  return aMallocSizeOf(this) +
         mImpl.shallowSizeOfExcludingThis(aMallocSizeOf);
}

// Attempt to minimize the capacity(). If the table is empty, this will free
// the empty storage and upon regrowth it will be given the minimum capacity.
void compact() { mImpl.compact(); }

// Attempt to reserve enough space to fit at least |aLen| elements. This is
// total capacity, including elements already present. Does nothing if the
// map already has sufficient capacity.
[[nodiscard]] bool reserve(uint32_t aLen) { return mImpl.reserve(aLen); }

// -- Lookups --------------------------------------------------------------

// Does the map contain a key/value matching |aLookup|?
bool has(const Lookup& aLookup) const {
  return mImpl.lookup(aLookup).found();
}

// Return a Ptr indicating whether a key/value matching |aLookup| is
// present in the map. E.g.:
//
//   using HM = HashMap<int,char>;
//   HM h;
//   if (HM::Ptr p = h.lookup(3)) {
//     assert(p->key() == 3);
//     char val = p->value();
//   }
//
using Ptr = typename Impl::Ptr;
MOZ_ALWAYS_INLINEinline Ptr lookup(const Lookup& aLookup) const {
  return mImpl.lookup(aLookup);
}

// Like lookup(), but does not assert if two threads call it at the same
// time. Only use this method when none of the threads will modify the map.
MOZ_ALWAYS_INLINEinline Ptr readonlyThreadsafeLookup(const Lookup& aLookup) const {
  return mImpl.readonlyThreadsafeLookup(aLookup);
}

// -- Insertions -----------------------------------------------------------

// Overwrite existing value with |aValue|, or add it if not present. Returns
// false on OOM.
template <typename KeyInput, typename ValueInput>
[[nodiscard]] bool put(KeyInput&& aKey, ValueInput&& aValue) {
  return put(aKey, std::forward<KeyInput>(aKey),
             std::forward<ValueInput>(aValue));
}

template <typename KeyInput, typename ValueInput>
[[nodiscard]] bool put(const Lookup& aLookup, KeyInput&& aKey,
                       ValueInput&& aValue) {
  AddPtr p = lookupForAdd(aLookup);
  if (p) {
    p->value() = std::forward<ValueInput>(aValue);
    return true;
  }
  return add(p, std::forward<KeyInput>(aKey),
             std::forward<ValueInput>(aValue));
}

// Like put(), but slightly faster. Must only be used when the given key is
// not already present. (In debug builds, assertions check this.)
template <typename KeyInput, typename ValueInput>
[[nodiscard]] bool putNew(KeyInput&& aKey, ValueInput&& aValue) {
  return mImpl.putNew(aKey, std::forward<KeyInput>(aKey),
                      std::forward<ValueInput>(aValue));
}

template <typename KeyInput, typename ValueInput>
[[nodiscard]] bool putNew(const Lookup& aLookup, KeyInput&& aKey,
                          ValueInput&& aValue) {
  return mImpl.putNew(aLookup, std::forward<KeyInput>(aKey),
                      std::forward<ValueInput>(aValue));
}

// Like putNew(), but should be only used when the table is known to be big
// enough for the insertion, and hashing cannot fail. Typically this is used
// to populate an empty map with known-unique keys after reserving space with
// reserve(), e.g.
//
//   using HM = HashMap<int,char>;
//   HM h;
//   if (!h.reserve(3)) {
//     MOZ_CRASH("OOM");
//   }
//   h.putNewInfallible(1, 'a');    // unique key
//   h.putNewInfallible(2, 'b');    // unique key
//   h.putNewInfallible(3, 'c');    // unique key
//
template <typename KeyInput, typename ValueInput>
void putNewInfallible(KeyInput&& aKey, ValueInput&& aValue) {
  mImpl.putNewInfallible(aKey, std::forward<KeyInput>(aKey),
                         std::forward<ValueInput>(aValue));
}

// Like |lookup(l)|, but on miss, |p = lookupForAdd(l)| allows efficient
// insertion of Key |k| (where |HashPolicy::match(k,l) == true|) using
// |add(p,k,v)|. After |add(p,k,v)|, |p| points to the new key/value. E.g.:
//
//   using HM = HashMap<int,char>;
//   HM h;
//   HM::AddPtr p = h.lookupForAdd(3);
//   if (!p) {
//     if (!h.add(p, 3, 'a')) {
//       return false;
//     }
//   }
//   assert(p->key() == 3);
//   char val = p->value();
//
// N.B. The caller must ensure that no mutating hash table operations occur
// between a pair of lookupForAdd() and add() calls. To avoid looking up the
// key a second time, the caller may use the more efficient relookupOrAdd()
// method. This method reuses part of the hashing computation to more
// efficiently insert the key if it has not been added. For example, a
// mutation-handling version of the previous example:
//
//    HM::AddPtr p = h.lookupForAdd(3);
//    if (!p) {
//      call_that_may_mutate_h();
//      if (!h.relookupOrAdd(p, 3, 'a')) {
//        return false;
//      }
//    }
//    assert(p->key() == 3);
//    char val = p->value();
//
using AddPtr = typename Impl::AddPtr;
MOZ_ALWAYS_INLINEinline AddPtr lookupForAdd(const Lookup& aLookup) {
  return mImpl.lookupForAdd(aLookup);
}

// Add a key/value. Returns false on OOM.
template <typename KeyInput, typename ValueInput>
[[nodiscard]] bool add(AddPtr& aPtr, KeyInput&& aKey, ValueInput&& aValue) {
  return mImpl.add(aPtr, std::forward<KeyInput>(aKey),
                   std::forward<ValueInput>(aValue));
}

// See the comment above lookupForAdd() for details.
template <typename KeyInput, typename ValueInput>
[[nodiscard]] bool relookupOrAdd(AddPtr& aPtr, KeyInput&& aKey,
                                 ValueInput&& aValue) {
  return mImpl.relookupOrAdd(aPtr, aKey, std::forward<KeyInput>(aKey),
                             std::forward<ValueInput>(aValue));
}

// -- Removal --------------------------------------------------------------

// Lookup and remove the key/value matching |aLookup|, if present.
void remove(const Lookup& aLookup) {
  if (Ptr p = lookup(aLookup)) {
    remove(p);
  }
}

// Remove a previously found key/value (assuming aPtr.found()). The map must
// not have been mutated in the interim.
void remove(Ptr aPtr) { mImpl.remove(aPtr); }

// Remove all keys/values without changing the capacity.
void clear() { mImpl.clear(); }

// Like clear() followed by compact().
void clearAndCompact() { mImpl.clearAndCompact(); }

// -- Rekeying -------------------------------------------------------------

// Infallibly rekey one entry, if necessary. Requires that template
// parameters Key and HashPolicy::Lookup are the same type.
void rekeyIfMoved(const Key& aOldKey, const Key& aNewKey) {
  if (aOldKey != aNewKey) {
    rekeyAs(aOldKey, aNewKey, aNewKey);
  }
}

// Infallibly rekey one entry if present, and return whether that happened.
bool rekeyAs(const Lookup& aOldLookup, const Lookup& aNewLookup,
             const Key& aNewKey) {
  if (Ptr p = lookup(aOldLookup)) {
    mImpl.rekeyAndMaybeRehash(p, aNewLookup, aNewKey);
    return true;
  }
  return false;
}

// -- Iteration ------------------------------------------------------------

// |iter()| returns an Iterator:
//
//   HashMap<int, char> h;
//   for (auto iter = h.iter(); !iter.done(); iter.next()) {
//     char c = iter.get().value();
//   }
//
using Iterator = typename Impl::Iterator;
Iterator iter() const { return mImpl.iter(); }

// |modIter()| returns a ModIterator:
//
//   HashMap<int, char> h;
//   for (auto iter = h.modIter(); !iter.done(); iter.next()) {
//     if (iter.get().value() == 'l') {
//       iter.remove();
//     }
//   }
//
// Table resize may occur in ModIterator's destructor.
using ModIterator = typename Impl::ModIterator;
ModIterator modIter() { return mImpl.modIter(); }

// These are similar to Iterator/ModIterator/iter(), but use different
// terminology.
using Range = typename Impl::Range;
using Enum = typename Impl::Enum;
Range all() const { return mImpl.all(); }
424};

426//---------------------------------------------------------------------------
427// HashSet
428//---------------------------------------------------------------------------

430// HashSet is a fast hash-based set of values.
431//
432// Template parameter requirements:
433// - T: movable, destructible, assignable.
434// - HashPolicy: see the "Hash Policy" section below.
435// - AllocPolicy: see AllocPolicy.h
436//
437// Note:
438// - HashSet is not reentrant: T/HashPolicy/AllocPolicy members called by
439//   HashSet must not call back into the same HashSet object.
440//
441template <class T, class HashPolicy = DefaultHasher<T>,
        class AllocPolicy = MallocAllocPolicy>
443class HashSet {
// -- Implementation details -----------------------------------------------

// HashSet is not copyable or assignable.
HashSet(const HashSet& hs) = delete;
HashSet& operator=(const HashSet& hs) = delete;

struct SetHashPolicy : HashPolicy {
  using Base = HashPolicy;
  using KeyType = T;

  static const KeyType& getKey(const T& aT) { return aT; }

  static void setKey(T& aT, KeyType& aKey) { HashPolicy::rekey(aT, aKey); }
};

using Impl = detail::HashTable<const T, SetHashPolicy, AllocPolicy>;
Impl mImpl;

friend class Impl::Enum;

public:
using Lookup = typename HashPolicy::Lookup;
using Entry = T;

// -- Initialization -------------------------------------------------------

explicit HashSet(AllocPolicy aAllocPolicy = AllocPolicy(),
                 uint32_t aLen = Impl::sDefaultLen)
    : mImpl(std::move(aAllocPolicy), aLen) {}

explicit HashSet(uint32_t aLen) : mImpl(AllocPolicy(), aLen) {}

// HashSet is movable.
HashSet(HashSet&& aRhs) = default;
HashSet& operator=(HashSet&& aRhs) = default;

// -- Status and sizing ----------------------------------------------------

// The set's current generation.
Generation generation() const { return mImpl.generation(); }

// Is the set empty?
bool empty() const { return mImpl.empty(); }

// Number of elements in the set.
uint32_t count() const { return mImpl.count(); }

// Number of element slots in the set. Note: resize will happen well before
// count() == capacity().
uint32_t capacity() const { return mImpl.capacity(); }

// The size of the set's entry storage, in bytes. If the elements contain
// pointers to other heap blocks, you must iterate over the set and measure
// them separately; hence the "shallow" prefix.
size_t shallowSizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
  return mImpl.shallowSizeOfExcludingThis(aMallocSizeOf);
}
size_t shallowSizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
  return aMallocSizeOf(this) +
         mImpl.shallowSizeOfExcludingThis(aMallocSizeOf);
}

// Attempt to minimize the capacity(). If the table is empty, this will free
// the empty storage and upon regrowth it will be given the minimum capacity.
void compact() { mImpl.compact(); }

// Attempt to reserve enough space to fit at least |aLen| elements. This is
// total capacity, including elements already present. Does nothing if the
// map already has sufficient capacity.
[[nodiscard]] bool reserve(uint32_t aLen) { return mImpl.reserve(aLen); }

// -- Lookups --------------------------------------------------------------

// Does the set contain an element matching |aLookup|?
bool has(const Lookup& aLookup) const {
  return mImpl.lookup(aLookup).found();
}

// Return a Ptr indicating whether an element matching |aLookup| is present
// in the set. E.g.:
//
//   using HS = HashSet<int>;
//   HS h;
//   if (HS::Ptr p = h.lookup(3)) {
//     assert(*p == 3);   // p acts like a pointer to int
//   }
//
using Ptr = typename Impl::Ptr;
MOZ_ALWAYS_INLINEinline Ptr lookup(const Lookup& aLookup) const {
  return mImpl.lookup(aLookup);
}

// Like lookup(), but does not assert if two threads call it at the same
// time. Only use this method when none of the threads will modify the set.
MOZ_ALWAYS_INLINEinline Ptr readonlyThreadsafeLookup(const Lookup& aLookup) const {
  return mImpl.readonlyThreadsafeLookup(aLookup);
}

// -- Insertions -----------------------------------------------------------

// Add |aU| if it is not present already. Returns false on OOM.
template <typename U>
[[nodiscard]] bool put(U&& aU) {
  AddPtr p = lookupForAdd(aU);
  return p ? true : add(p, std::forward<U>(aU));
}

// Like put(), but slightly faster. Must only be used when the given element
// is not already present. (In debug builds, assertions check this.)
template <typename U>
[[nodiscard]] bool putNew(U&& aU) {
  return mImpl.putNew(aU, std::forward<U>(aU));
}

// Like the other putNew(), but for when |Lookup| is different to |T|.
template <typename U>
[[nodiscard]] bool putNew(const Lookup& aLookup, U&& aU) {
  return mImpl.putNew(aLookup, std::forward<U>(aU));
}

// Like putNew(), but should be only used when the table is known to be big
// enough for the insertion, and hashing cannot fail. Typically this is used
// to populate an empty set with known-unique elements after reserving space
// with reserve(), e.g.
//
//   using HS = HashMap<int>;
//   HS h;
//   if (!h.reserve(3)) {
//     MOZ_CRASH("OOM");
//   }
//   h.putNewInfallible(1);     // unique element
//   h.putNewInfallible(2);     // unique element
//   h.putNewInfallible(3);     // unique element
//
template <typename U>
void putNewInfallible(const Lookup& aLookup, U&& aU) {
  mImpl.putNewInfallible(aLookup, std::forward<U>(aU));
}

// Like |lookup(l)|, but on miss, |p = lookupForAdd(l)| allows efficient
// insertion of T value |t| (where |HashPolicy::match(t,l) == true|) using
// |add(p,t)|. After |add(p,t)|, |p| points to the new element. E.g.:
//
//   using HS = HashSet<int>;
//   HS h;
//   HS::AddPtr p = h.lookupForAdd(3);
//   if (!p) {
//     if (!h.add(p, 3)) {
//       return false;
//     }
//   }
//   assert(*p == 3);   // p acts like a pointer to int
//
// N.B. The caller must ensure that no mutating hash table operations occur
// between a pair of lookupForAdd() and add() calls. To avoid looking up the
// key a second time, the caller may use the more efficient relookupOrAdd()
// method. This method reuses part of the hashing computation to more
// efficiently insert the key if it has not been added. For example, a
// mutation-handling version of the previous example:
//
//    HS::AddPtr p = h.lookupForAdd(3);
//    if (!p) {
//      call_that_may_mutate_h();
//      if (!h.relookupOrAdd(p, 3, 3)) {
//        return false;
//      }
//    }
//    assert(*p == 3);
//
// Note that relookupOrAdd(p,l,t) performs Lookup using |l| and adds the
// entry |t|, where the caller ensures match(l,t).
using AddPtr = typename Impl::AddPtr;
MOZ_ALWAYS_INLINEinline AddPtr lookupForAdd(const Lookup& aLookup) {
  return mImpl.lookupForAdd(aLookup);
}

// Add an element. Returns false on OOM.
template <typename U>
[[nodiscard]] bool add(AddPtr& aPtr, U&& aU) {
  return mImpl.add(aPtr, std::forward<U>(aU));
}

// See the comment above lookupForAdd() for details.
template <typename U>
[[nodiscard]] bool relookupOrAdd(AddPtr& aPtr, const Lookup& aLookup,
                                 U&& aU) {
  return mImpl.relookupOrAdd(aPtr, aLookup, std::forward<U>(aU));
}

// -- Removal --------------------------------------------------------------

// Lookup and remove the element matching |aLookup|, if present.
void remove(const Lookup& aLookup) {
  if (Ptr p = lookup(aLookup)) {
    remove(p);
  }
}

// Remove a previously found element (assuming aPtr.found()). The set must
// not have been mutated in the interim.
void remove(Ptr aPtr) { mImpl.remove(aPtr); }

// Remove all keys/values without changing the capacity.
void clear() { mImpl.clear(); }

// Like clear() followed by compact().
void clearAndCompact() { mImpl.clearAndCompact(); }

// -- Rekeying -------------------------------------------------------------

// Infallibly rekey one entry, if present. Requires that template parameters
// T and HashPolicy::Lookup are the same type.
void rekeyIfMoved(const Lookup& aOldValue, const T& aNewValue) {
  if (aOldValue != aNewValue) {
    rekeyAs(aOldValue, aNewValue, aNewValue);
  }
}

// Infallibly rekey one entry if present, and return whether that happened.
bool rekeyAs(const Lookup& aOldLookup, const Lookup& aNewLookup,
             const T& aNewValue) {
  if (Ptr p = lookup(aOldLookup)) {
    mImpl.rekeyAndMaybeRehash(p, aNewLookup, aNewValue);
    return true;
  }
  return false;
}

// Infallibly replace the current key at |aPtr| with an equivalent key.
// Specifically, both HashPolicy::hash and HashPolicy::match must return
// identical results for the new and old key when applied against all
// possible matching values.
void replaceKey(Ptr aPtr, const Lookup& aLookup, const T& aNewValue) {
  MOZ_ASSERT(aPtr.found())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aPtr.found())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aPtr.found()))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("aPtr.found()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 677); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aPtr.found()"
 ")"); do { *((volatile int*)__null) = 677; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(*aPtr != aNewValue)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(*aPtr != aNewValue)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(*aPtr != aNewValue))), 0))) {
 do { } while (false); MOZ_ReportAssertionFailure("*aPtr != aNewValue"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 678); AnnotateMozCrashReason("MOZ_ASSERT" "(" "*aPtr != aNewValue"
 ")"); do { *((volatile int*)__null) = 678; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(HashPolicy::match(*aPtr, aLookup))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(HashPolicy::match(*aPtr, aLookup))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(HashPolicy::match(*aPtr, aLookup
)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("HashPolicy::match(*aPtr, aLookup)", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 679); AnnotateMozCrashReason("MOZ_ASSERT" "(" "HashPolicy::match(*aPtr, aLookup)"
 ")"); do { *((volatile int*)__null) = 679; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(HashPolicy::match(aNewValue, aLookup))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(HashPolicy::match(aNewValue, aLookup))>::isValid,
 "invalid assertion condition"); if ((__builtin_expect(!!(!(!
!(HashPolicy::match(aNewValue, aLookup)))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("HashPolicy::match(aNewValue, aLookup)"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 680); AnnotateMozCrashReason("MOZ_ASSERT" "(" "HashPolicy::match(aNewValue, aLookup)"
 ")"); do { *((volatile int*)__null) = 680; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  const_cast<T&>(*aPtr) = aNewValue;
  MOZ_ASSERT(*lookup(aLookup) == aNewValue)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(*lookup(aLookup) == aNewValue)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(*lookup(aLookup) == aNewValue
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"*lookup(aLookup) == aNewValue", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 682); AnnotateMozCrashReason("MOZ_ASSERT" "(" "*lookup(aLookup) == aNewValue"
 ")"); do { *((volatile int*)__null) = 682; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
}
void replaceKey(Ptr aPtr, const T& aNewValue) {
  replaceKey(aPtr, aNewValue, aNewValue);
}

// -- Iteration ------------------------------------------------------------

// |iter()| returns an Iterator:
//
//   HashSet<int> h;
//   for (auto iter = h.iter(); !iter.done(); iter.next()) {
//     int i = iter.get();
//   }
//
using Iterator = typename Impl::Iterator;
Iterator iter() const { return mImpl.iter(); }

// |modIter()| returns a ModIterator:
//
//   HashSet<int> h;
//   for (auto iter = h.modIter(); !iter.done(); iter.next()) {
//     if (iter.get() == 42) {
//       iter.remove();
//     }
//   }
//
// Table resize may occur in ModIterator's destructor.
using ModIterator = typename Impl::ModIterator;
ModIterator modIter() { return mImpl.modIter(); }

// These are similar to Iterator/ModIterator/iter(), but use different
// terminology.
using Range = typename Impl::Range;
using Enum = typename Impl::Enum;
Range all() const { return mImpl.all(); }
718};

720//---------------------------------------------------------------------------
721// Hash Policy
722//---------------------------------------------------------------------------

724// A hash policy |HP| for a hash table with key-type |Key| must provide:
725//
726//  - a type |HP::Lookup| to use to lookup table entries;
727//
728//  - a static member function |HP::hash| that hashes lookup values:
729//
730//      static mozilla::HashNumber hash(const Lookup&);
731//
732//  - a static member function |HP::match| that tests equality of key and
733//    lookup values:
734//
735//      static bool match(const Key& aKey, const Lookup& aLookup);
736//
737//    |aKey| and |aLookup| can have different hash numbers, only when a
738//    collision happens with |prepareHash| operation, which is less frequent.
739//    Thus, |HP::match| shouldn't assume the hash equality in the comparison,
740//    even if the hash numbers are almost always same between them.
741//
742// Normally, Lookup = Key. In general, though, different values and types of
743// values can be used to lookup and store. If a Lookup value |l| is not equal
744// to the added Key value |k|, the user must ensure that |HP::match(k,l)| is
745// true. E.g.:
746//
747//   mozilla::HashSet<Key, HP>::AddPtr p = h.lookup(l);
748//   if (!p) {
749//     assert(HP::match(k, l));  // must hold
750//     h.add(p, k);
751//   }

753// A pointer hashing policy that uses HashGeneric() to create good hashes for
754// pointers. Note that we don't shift out the lowest k bits because we don't
755// want to assume anything about the alignment of the pointers.
756template <typename Key>
757struct PointerHasher {
using Lookup = Key;

static HashNumber hash(const Lookup& aLookup) { return HashGeneric(aLookup); }

static bool match(const Key& aKey, const Lookup& aLookup) {
  return aKey == aLookup;
}

static void rekey(Key& aKey, const Key& aNewKey) { aKey = aNewKey; }
767};

769// The default hash policy, which only works with integers.
770template <class Key, typename>
771struct DefaultHasher {
using Lookup = Key;

static HashNumber hash(const Lookup& aLookup) {
  // Just convert the integer to a HashNumber and use that as is. (This
  // discards the high 32-bits of 64-bit integers!) ScrambleHashCode() is
  // subsequently called on the value to improve the distribution.
  return aLookup;
}

static bool match(const Key& aKey, const Lookup& aLookup) {
  // Use builtin or overloaded operator==.
  return aKey == aLookup;
}

static void rekey(Key& aKey, const Key& aNewKey) { aKey = aNewKey; }
787};

789// A DefaultHasher specialization for enums.
790template <class T>
791struct DefaultHasher<T, std::enable_if_t<std::is_enum_v<T>>> {
using Key = T;
using Lookup = Key;

static HashNumber hash(const Lookup& aLookup) { return HashGeneric(aLookup); }

static bool match(const Key& aKey, const Lookup& aLookup) {
  // Use builtin or overloaded operator==.
  return aKey == static_cast<Key>(aLookup);
}

static void rekey(Key& aKey, const Key& aNewKey) { aKey = aNewKey; }
803};

805// A DefaultHasher specialization for pointers.
806template <class T>
807struct DefaultHasher<T*> : PointerHasher<T*> {};

809// A DefaultHasher specialization for mozilla::UniquePtr.
810template <class T, class D>
811struct DefaultHasher<UniquePtr<T, D>> {
using Key = UniquePtr<T, D>;
using Lookup = Key;
using PtrHasher = PointerHasher<T*>;

static HashNumber hash(const Lookup& aLookup) {
  return PtrHasher::hash(aLookup.get());
}

static bool match(const Key& aKey, const Lookup& aLookup) {
  return PtrHasher::match(aKey.get(), aLookup.get());
}

static void rekey(UniquePtr<T, D>& aKey, UniquePtr<T, D>&& aNewKey) {
  aKey = std::move(aNewKey);
}
827};

829// A DefaultHasher specialization for doubles.
830template <>
831struct DefaultHasher<double> {
using Key = double;
using Lookup = Key;

static HashNumber hash(const Lookup& aLookup) {
  // Just xor the high bits with the low bits, and then treat the bits of the
  // result as a uint32_t.
  static_assert(sizeof(HashNumber) == 4,
                "subsequent code assumes a four-byte hash");
  uint64_t u = BitwiseCast<uint64_t>(aLookup);
  return HashNumber(u ^ (u >> 32));
}

static bool match(const Key& aKey, const Lookup& aLookup) {
  return BitwiseCast<uint64_t>(aKey) == BitwiseCast<uint64_t>(aLookup);
}
847};

849// A DefaultHasher specialization for floats.
850template <>
851struct DefaultHasher<float> {
using Key = float;
using Lookup = Key;

static HashNumber hash(const Lookup& aLookup) {
  // Just use the value as if its bits form an integer. ScrambleHashCode() is
  // subsequently called on the value to improve the distribution.
  static_assert(sizeof(HashNumber) == 4,
                "subsequent code assumes a four-byte hash");
  return HashNumber(BitwiseCast<uint32_t>(aLookup));
}

static bool match(const Key& aKey, const Lookup& aLookup) {
  return BitwiseCast<uint32_t>(aKey) == BitwiseCast<uint32_t>(aLookup);
}
866};

868// A hash policy for C strings.
869struct CStringHasher {
using Key = const char*;
using Lookup = const char*;

static HashNumber hash(const Lookup& aLookup) { return HashString(aLookup); }

static bool match(const Key& aKey, const Lookup& aLookup) {
  return strcmp(aKey, aLookup) == 0;
}
878};

880//---------------------------------------------------------------------------
881// Fallible Hashing Interface
882//---------------------------------------------------------------------------

884// Most of the time generating a hash code is infallible, but sometimes it is
885// necessary to generate hash codes on demand in a way that can fail. Specialize
886// this class for your own hash policy to provide fallible hashing.
887//
888// This is used by MovableCellHasher to handle the fact that generating a unique
889// ID for cell pointer may fail due to OOM.
890//
891// The default implementations of these methods delegate to the usual HashPolicy
892// implementation and always succeed.
893template <typename HashPolicy>
894struct FallibleHashMethods {
// Return true if a hashcode is already available for its argument, and
// sets |aHashOut|. Once this succeeds for a specific argument it
// must continue to do so.
//
// Return false if a hashcode is not already available. This implies that any
// lookup must fail, as the hash code would have to have been successfully
// created on insertion.
template <typename Lookup>
static bool maybeGetHash(Lookup&& aLookup, HashNumber* aHashOut) {
  *aHashOut = HashPolicy::hash(aLookup);
  return true;
}

// Fallible method to ensure a hashcode exists for its argument and create one
// if not. Sets |aHashOut| to the hashcode and retuns true on success. Returns
// false on error, e.g. out of memory.
template <typename Lookup>
static bool ensureHash(Lookup&& aLookup, HashNumber* aHashOut) {
  *aHashOut = HashPolicy::hash(aLookup);
  return true;
}
916};

918template <typename HashPolicy, typename Lookup>
919static bool MaybeGetHash(Lookup&& aLookup, HashNumber* aHashOut) {
return FallibleHashMethods<typename HashPolicy::Base>::maybeGetHash(
    std::forward<Lookup>(aLookup), aHashOut);
922}

924template <typename HashPolicy, typename Lookup>
925static bool EnsureHash(Lookup&& aLookup, HashNumber* aHashOut) {
return FallibleHashMethods<typename HashPolicy::Base>::ensureHash(
    std::forward<Lookup>(aLookup), aHashOut);
928}

930//---------------------------------------------------------------------------
931// Implementation Details (HashMapEntry, HashTableEntry, HashTable)
932//---------------------------------------------------------------------------

934// Both HashMap and HashSet are implemented by a single HashTable that is even
935// more heavily parameterized than the other two. This leaves HashTable gnarly
936// and extremely coupled to HashMap and HashSet; thus code should not use
937// HashTable directly.

939template <class Key, class Value>
940class HashMapEntry {
Key key_;
Value value_;

template <class, class, class>
friend class detail::HashTable;
template <class>
friend class detail::HashTableEntry;
template <class, class, class, class>
friend class HashMap;

public:
template <typename KeyInput, typename ValueInput>
HashMapEntry(KeyInput&& aKey, ValueInput&& aValue)
    : key_(std::forward<KeyInput>(aKey)),
      value_(std::forward<ValueInput>(aValue)) {}

HashMapEntry(HashMapEntry&& aRhs) = default;
HashMapEntry& operator=(HashMapEntry&& aRhs) = default;

using KeyType = Key;
using ValueType = Value;

const Key& key() const { return key_; }

// Use this method with caution! If the key is changed such that its hash
// value also changes, the map will be left in an invalid state.
Key& mutableKey() { return key_; }

const Value& value() const { return value_; }
Value& value() { return value_; }

private:
HashMapEntry(const HashMapEntry&) = delete;
void operator=(const HashMapEntry&) = delete;
975};

977namespace detail {

979template <class T, class HashPolicy, class AllocPolicy>
980class HashTable;

982template <typename T>
983class EntrySlot;

985template <typename T>
986class HashTableEntry {
private:
using NonConstT = std::remove_const_t<T>;

// Instead of having a hash table entry store that looks like this:
//
// +--------+--------+--------+--------+
// | entry0 | entry1 |  ....  | entryN |
// +--------+--------+--------+--------+
//
// where the entries contained their cached hash code, we're going to lay out
// the entry store thusly:
//
// +-------+-------+-------+-------+--------+--------+--------+--------+
// | hash0 | hash1 |  ...  | hashN | entry0 | entry1 |  ....  | entryN |
// +-------+-------+-------+-------+--------+--------+--------+--------+
//
// with all the cached hashes prior to the actual entries themselves.
//
// We do this because implementing the first strategy requires us to make
// HashTableEntry look roughly like:
//
// template <typename T>
// class HashTableEntry {
//   HashNumber mKeyHash;
//   T mValue;
// };
//
// The problem with this setup is that, depending on the layout of `T`, there
// may be platform ABI-mandated padding between `mKeyHash` and the first
// member of `T`. This ABI-mandated padding is wasted space, and can be
// surprisingly common, e.g. when `T` is a single pointer on 64-bit platforms.
// In such cases, we're throwing away a quarter of our entry store on padding,
// which is undesirable.
//
// The second layout above, namely:
//
// +-------+-------+-------+-------+--------+--------+--------+--------+
// | hash0 | hash1 |  ...  | hashN | entry0 | entry1 |  ....  | entryN |
// +-------+-------+-------+-------+--------+--------+--------+--------+
//
// means there is no wasted space between the hashes themselves, and no wasted
// space between the entries themselves.  However, we would also like there to
// be no gap between the last hash and the first entry. The memory allocator
// guarantees the alignment of the start of the hashes. The use of a
// power-of-two capacity of at least 4 guarantees that the alignment of the
// *end* of the hash array is no less than the alignment of the start.
// Finally, the static_asserts here guarantee that the entries themselves
// don't need to be any more aligned than the alignment of the entry store
// itself.
//
// This assertion is safe for 32-bit builds because on both Windows and Linux
// (including Android), the minimum alignment for allocations larger than 8
// bytes is 8 bytes, and the actual data for entries in our entry store is
// guaranteed to have that alignment as well, thanks to the power-of-two
// number of cached hash values stored prior to the entry data.

// The allocation policy must allocate a table with at least this much
// alignment.
static constexpr size_t kMinimumAlignment = 8;

static_assert(alignof(HashNumber) <= kMinimumAlignment,
              "[N*2 hashes, N*2 T values] allocation's alignment must be "
              "enough to align each hash");
static_assert(alignof(NonConstT) <= 2 * sizeof(HashNumber),
              "subsequent N*2 T values must not require more than an even "
              "number of HashNumbers provides");

static const HashNumber sFreeKey = 0;
static const HashNumber sRemovedKey = 1;
static const HashNumber sCollisionBit = 1;

alignas(NonConstT) unsigned char mValueData[sizeof(NonConstT)];

private:
template <class, class, class>
friend class HashTable;
template <typename>
friend class EntrySlot;

// Some versions of GCC treat it as a -Wstrict-aliasing violation (ergo a
// -Werror compile error) to reinterpret_cast<> |mValueData| to |T*|, even
// through |void*|.  Placing the latter cast in these separate functions
// breaks the chain such that affected GCC versions no longer warn/error.
void* rawValuePtr() { return mValueData; }

static bool isLiveHash(HashNumber hash) { return hash > sRemovedKey; }

HashTableEntry(const HashTableEntry&) = delete;
void operator=(const HashTableEntry&) = delete;

NonConstT* valuePtr() { return reinterpret_cast<NonConstT*>(rawValuePtr()); }

void destroyStoredT() {
  NonConstT* ptr = valuePtr();
  ptr->~T();
  MOZ_MAKE_MEM_UNDEFINED(ptr, sizeof(*ptr))do { } while (0);
}

public:
HashTableEntry() = default;

~HashTableEntry() { MOZ_MAKE_MEM_UNDEFINED(this, sizeof(*this))do { } while (0); }

void destroy() { destroyStoredT(); }

void swap(HashTableEntry* aOther, bool aIsLive) {
  // This allows types to use Argument-Dependent-Lookup, and thus use a custom
  // std::swap, which is needed by types like JS::Heap and such.
  using std::swap;

  if (this == aOther) {
    return;
  }
  if (aIsLive) {
    swap(*valuePtr(), *aOther->valuePtr());
  } else {
    *aOther->valuePtr() = std::move(*valuePtr());
    destroy();
  }
}

T& get() { return *valuePtr(); }

NonConstT& getMutable() { return *valuePtr(); }
1111};

1113// A slot represents a cached hash value and its associated entry stored
1114// in the hash table. These two things are not stored in contiguous memory.
1115template <class T>
1116class EntrySlot {
using NonConstT = std::remove_const_t<T>;

using Entry = HashTableEntry<T>;

Entry* mEntry;
HashNumber* mKeyHash;

template <class, class, class>
friend class HashTable;

EntrySlot(Entry* aEntry, HashNumber* aKeyHash)
    : mEntry(aEntry), mKeyHash(aKeyHash) {}

public:
static bool isLiveHash(HashNumber hash) { return hash > Entry::sRemovedKey; }

EntrySlot(const EntrySlot&) = default;
EntrySlot(EntrySlot&& aOther) = default;

EntrySlot& operator=(const EntrySlot&) = default;
EntrySlot& operator=(EntrySlot&&) = default;

bool operator==(const EntrySlot& aRhs) const { return mEntry == aRhs.mEntry; }

bool operator<(const EntrySlot& aRhs) const { return mEntry < aRhs.mEntry; }

EntrySlot& operator++() {
  ++mEntry;
  ++mKeyHash;
  return *this;
}

void destroy() { mEntry->destroy(); }

void swap(EntrySlot& aOther) {
  mEntry->swap(aOther.mEntry, aOther.isLive());
  std::swap(*mKeyHash, *aOther.mKeyHash);
}

T& get() const { return mEntry->get(); }

NonConstT& getMutable() { return mEntry->getMutable(); }

bool isFree() const { return *mKeyHash == Entry::sFreeKey; }

void clearLive() {
  MOZ_ASSERT(isLive())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isLive())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isLive()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isLive()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1163); AnnotateMozCrashReason("MOZ_ASSERT" "(" "isLive()" ")"
); do { *((volatile int*)__null) = 1163; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  *mKeyHash = Entry::sFreeKey;
  mEntry->destroyStoredT();
}

void clear() {
  if (isLive()) {
    mEntry->destroyStoredT();
  }
  MOZ_MAKE_MEM_UNDEFINED(mEntry, sizeof(*mEntry))do { } while (0);
  *mKeyHash = Entry::sFreeKey;
}

bool isRemoved() const { return *mKeyHash == Entry::sRemovedKey; }

void removeLive() {
  MOZ_ASSERT(isLive())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isLive())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isLive()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isLive()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1179); AnnotateMozCrashReason("MOZ_ASSERT" "(" "isLive()" ")"
); do { *((volatile int*)__null) = 1179; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  *mKeyHash = Entry::sRemovedKey;
  mEntry->destroyStoredT();
}

bool isLive() const { return isLiveHash(*mKeyHash); }

void setCollision() {
  MOZ_ASSERT(isLive())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isLive())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isLive()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isLive()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1187); AnnotateMozCrashReason("MOZ_ASSERT" "(" "isLive()" ")"
); do { *((volatile int*)__null) = 1187; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  *mKeyHash |= Entry::sCollisionBit;
}
void unsetCollision() { *mKeyHash &= ~Entry::sCollisionBit; }
bool hasCollision() const { return *mKeyHash & Entry::sCollisionBit; }
bool matchHash(HashNumber hn) {
  return (*mKeyHash & ~Entry::sCollisionBit) == hn;
}
HashNumber getKeyHash() const { return *mKeyHash & ~Entry::sCollisionBit; }

template <typename... Args>
void setLive(HashNumber aHashNumber, Args&&... aArgs) {
  MOZ_ASSERT(!isLive())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!isLive())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!isLive()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("!isLive()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1199); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!isLive()" ")"
); do { *((volatile int*)__null) = 1199; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  *mKeyHash = aHashNumber;
  new (KnownNotNull, mEntry->valuePtr()) T(std::forward<Args>(aArgs)...);
  MOZ_ASSERT(isLive())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isLive())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isLive()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isLive()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1202); AnnotateMozCrashReason("MOZ_ASSERT" "(" "isLive()" ")"
); do { *((volatile int*)__null) = 1202; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
}

Entry* toEntry() const { return mEntry; }
1206};

1208template <class T, class HashPolicy, class AllocPolicy>
1209class HashTable : private AllocPolicy {
friend class mozilla::ReentrancyGuard;

using NonConstT = std::remove_const_t<T>;
using Key = typename HashPolicy::KeyType;
using Lookup = typename HashPolicy::Lookup;

public:
using Entry = HashTableEntry<T>;
using Slot = EntrySlot<T>;

template <typename F>
static void forEachSlot(char* aTable, uint32_t aCapacity, F&& f) {
  auto hashes = reinterpret_cast<HashNumber*>(aTable);
  auto entries = reinterpret_cast<Entry*>(&hashes[aCapacity]);
  Slot slot(entries, hashes);
  for (size_t i = 0; i < size_t(aCapacity); ++i) {
    f(slot);
    ++slot;
  }
}

// A nullable pointer to a hash table element. A Ptr |p| can be tested
// either explicitly |if (p.found()) p->...| or using boolean conversion
// |if (p) p->...|. Ptr objects must not be used after any mutating hash
// table operations unless |generation()| is tested.
class Ptr {
  friend class HashTable;

  Slot mSlot;
1239#ifdef DEBUG1
  const HashTable* mTable;
  Generation mGeneration;
1242#endif

 protected:
  Ptr(Slot aSlot, const HashTable& aTable)
      : mSlot(aSlot)
1247#ifdef DEBUG1
        ,
        mTable(&aTable),
        mGeneration(aTable.generation())
1251#endif
  {
  }

  // This constructor is used only by AddPtr() within lookupForAdd().
  explicit Ptr(const HashTable& aTable)
      : mSlot(nullptr, nullptr)
1258#ifdef DEBUG1
        ,
        mTable(&aTable),
        mGeneration(aTable.generation())
1262#endif
  {
  }

  bool isValid() const { return !!mSlot.toEntry(); }

 public:
  Ptr()
      : mSlot(nullptr, nullptr)
1271#ifdef DEBUG1
        ,
        mTable(nullptr),
        mGeneration(0)
1275#endif
  {
  }

  bool found() const {
    if (!isValid()) {
      return false;
    }
1283#ifdef DEBUG1
    MOZ_ASSERT(mGeneration == mTable->generation())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mGeneration == mTable->generation())>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(mGeneration == mTable->generation()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mGeneration == mTable->generation()"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1284); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mGeneration == mTable->generation()"
 ")"); do { *((volatile int*)__null) = 1284; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
1285#endif
    return mSlot.isLive();
  }

  explicit operator bool() const { return found(); }

  bool operator==(const Ptr& aRhs) const {
    MOZ_ASSERT(found() && aRhs.found())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(found() && aRhs.found())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(found() && aRhs.found
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("found() && aRhs.found()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1292); AnnotateMozCrashReason("MOZ_ASSERT" "(" "found() && aRhs.found()"
 ")"); do { *((volatile int*)__null) = 1292; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    return mSlot == aRhs.mSlot;
  }

  bool operator!=(const Ptr& aRhs) const {
1297#ifdef DEBUG1
    MOZ_ASSERT(mGeneration == mTable->generation())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mGeneration == mTable->generation())>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(mGeneration == mTable->generation()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mGeneration == mTable->generation()"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1298); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mGeneration == mTable->generation()"
 ")"); do { *((volatile int*)__null) = 1298; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
1299#endif
    return !(*this == aRhs);
  }

  T& operator*() const {
1304#ifdef DEBUG1
    MOZ_ASSERT(found())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(found())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(found()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("found()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1305); AnnotateMozCrashReason("MOZ_ASSERT" "(" "found()" ")"
); do { *((volatile int*)__null) = 1305; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(mGeneration == mTable->generation())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mGeneration == mTable->generation())>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(mGeneration == mTable->generation()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mGeneration == mTable->generation()"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1306); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mGeneration == mTable->generation()"
 ")"); do { *((volatile int*)__null) = 1306; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
1307#endif
    return mSlot.get();
  }

  T* operator->() const {
1312#ifdef DEBUG1
    MOZ_ASSERT(found())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(found())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(found()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("found()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1313); AnnotateMozCrashReason("MOZ_ASSERT" "(" "found()" ")"
); do { *((volatile int*)__null) = 1313; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(mGeneration == mTable->generation())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mGeneration == mTable->generation())>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(mGeneration == mTable->generation()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mGeneration == mTable->generation()"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1314); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mGeneration == mTable->generation()"
 ")"); do { *((volatile int*)__null) = 1314; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
1315#endif
    return &mSlot.get();
  }
};

// A Ptr that can be used to add a key after a failed lookup.
class AddPtr : public Ptr {
  friend class HashTable;

  HashNumber mKeyHash;
1325#ifdef DEBUG1
  uint64_t mMutationCount;
1327#endif

  AddPtr(Slot aSlot, const HashTable& aTable, HashNumber aHashNumber)
      : Ptr(aSlot, aTable),
        mKeyHash(aHashNumber)
1332#ifdef DEBUG1
        ,
        mMutationCount(aTable.mMutationCount)
1335#endif
  {
  }

  // This constructor is used when lookupForAdd() is performed on a table
  // lacking entry storage; it leaves mSlot null but initializes everything
  // else.
  AddPtr(const HashTable& aTable, HashNumber aHashNumber)
      : Ptr(aTable),
        mKeyHash(aHashNumber)
1345#ifdef DEBUG1
        ,
        mMutationCount(aTable.mMutationCount)
1348#endif
  {
    MOZ_ASSERT(isLive())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isLive())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isLive()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("isLive()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1350); AnnotateMozCrashReason("MOZ_ASSERT" "(" "isLive()" ")"
); do { *((volatile int*)__null) = 1350; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  }

  bool isLive() const { return isLiveHash(mKeyHash); }

 public:
  AddPtr() : mKeyHash(0) {}
};

// A hash table iterator that (mostly) doesn't allow table modifications.
// As with Ptr/AddPtr, Iterator objects must not be used after any mutating
// hash table operation unless the |generation()| is tested.
class Iterator {
  void moveToNextLiveEntry() {
    while (++mCur < mEnd && !mCur.isLive()) {
      continue;
    }
  }

 protected:
  friend class HashTable;

  explicit Iterator(const HashTable& aTable)
      : mCur(aTable.slotForIndex(0)),
        mEnd(aTable.slotForIndex(aTable.capacity()))
1375#ifdef DEBUG1
        ,
        mTable(aTable),
        mMutationCount(aTable.mMutationCount),
        mGeneration(aTable.generation()),
        mValidEntry(true)
1381#endif
  {
    if (!done() && !mCur.isLive()) {
      moveToNextLiveEntry();
    }
  }

  Slot mCur;
  Slot mEnd;
1390#ifdef DEBUG1
  const HashTable& mTable;
  uint64_t mMutationCount;
  Generation mGeneration;
  bool mValidEntry;
1395#endif

 public:
  bool done() const {
    MOZ_ASSERT(mGeneration == mTable.generation())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mGeneration == mTable.generation())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mGeneration == mTable.generation
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("mGeneration == mTable.generation()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1399); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mGeneration == mTable.generation()"
 ")"); do { *((volatile int*)__null) = 1399; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(mMutationCount == mTable.mMutationCount)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mMutationCount == mTable.mMutationCount)>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(mMutationCount == mTable.mMutationCount))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mMutationCount == mTable.mMutationCount"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1400); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mMutationCount == mTable.mMutationCount"
 ")"); do { *((volatile int*)__null) = 1400; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    return mCur == mEnd;
  }

  T& get() const {
    MOZ_ASSERT(!done())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!done())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!done()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("!done()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1405); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!done()" ")"
); do { *((volatile int*)__null) = 1405; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(mValidEntry)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mValidEntry)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mValidEntry))), 0))) { do { }
 while (false); MOZ_ReportAssertionFailure("mValidEntry", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1406); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mValidEntry"
 ")"); do { *((volatile int*)__null) = 1406; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(mGeneration == mTable.generation())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mGeneration == mTable.generation())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mGeneration == mTable.generation
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("mGeneration == mTable.generation()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1407); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mGeneration == mTable.generation()"
 ")"); do { *((volatile int*)__null) = 1407; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(mMutationCount == mTable.mMutationCount)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mMutationCount == mTable.mMutationCount)>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(mMutationCount == mTable.mMutationCount))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mMutationCount == mTable.mMutationCount"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1408); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mMutationCount == mTable.mMutationCount"
 ")"); do { *((volatile int*)__null) = 1408; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    return mCur.get();
  }

  void next() {
    MOZ_ASSERT(!done())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!done())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!done()))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("!done()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1413); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!done()" ")"
); do { *((volatile int*)__null) = 1413; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(mGeneration == mTable.generation())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mGeneration == mTable.generation())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mGeneration == mTable.generation
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("mGeneration == mTable.generation()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1414); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mGeneration == mTable.generation()"
 ")"); do { *((volatile int*)__null) = 1414; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(mMutationCount == mTable.mMutationCount)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mMutationCount == mTable.mMutationCount)>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!(mMutationCount == mTable.mMutationCount))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mMutationCount == mTable.mMutationCount"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1415); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mMutationCount == mTable.mMutationCount"
 ")"); do { *((volatile int*)__null) = 1415; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    moveToNextLiveEntry();
1417#ifdef DEBUG1
    mValidEntry = true;
1419#endif
  }
};

// A hash table iterator that permits modification, removal and rekeying.
// Since rehashing when elements were removed during enumeration would be
// bad, it is postponed until the ModIterator is destructed. Since the
// ModIterator's destructor touches the hash table, the user must ensure
// that the hash table is still alive when the destructor runs.
class ModIterator : public Iterator {
  friend class HashTable;

  HashTable& mTable;
  bool mRekeyed;
  bool mRemoved;

  // ModIterator is movable but not copyable.
  ModIterator(const ModIterator&) = delete;
  void operator=(const ModIterator&) = delete;

 protected:
  explicit ModIterator(HashTable& aTable)
      : Iterator(aTable), mTable(aTable), mRekeyed(false), mRemoved(false) {}

 public:
  MOZ_IMPLICIT ModIterator(ModIterator&& aOther)
      : Iterator(aOther),
        mTable(aOther.mTable),
        mRekeyed(aOther.mRekeyed),
        mRemoved(aOther.mRemoved) {
    aOther.mRekeyed = false;
    aOther.mRemoved = false;
  }

  // Removes the current element from the table, leaving |get()|
  // invalid until the next call to |next()|.
  void remove() {
    mTable.remove(this->mCur);
    mRemoved = true;
1458#ifdef DEBUG1
    this->mValidEntry = false;
    this->mMutationCount = mTable.mMutationCount;
1461#endif
  }

  NonConstT& getMutable() {
    MOZ_ASSERT(!this->done())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!this->done())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!this->done()))), 0))) { do
 { } while (false); MOZ_ReportAssertionFailure("!this->done()"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1465); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!this->done()"
 ")"); do { *((volatile int*)__null) = 1465; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(this->mValidEntry)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(this->mValidEntry)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(this->mValidEntry))), 0))
) { do { } while (false); MOZ_ReportAssertionFailure("this->mValidEntry"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1466); AnnotateMozCrashReason("MOZ_ASSERT" "(" "this->mValidEntry"
 ")"); do { *((volatile int*)__null) = 1466; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(this->mGeneration == this->Iterator::mTable.generation())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(this->mGeneration == this->Iterator::mTable.generation
())>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(this->mGeneration == this->Iterator::mTable.generation
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("this->mGeneration == this->Iterator::mTable.generation()"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1467); AnnotateMozCrashReason("MOZ_ASSERT" "(" "this->mGeneration == this->Iterator::mTable.generation()"
 ")"); do { *((volatile int*)__null) = 1467; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    MOZ_ASSERT(this->mMutationCount == this->Iterator::mTable.mMutationCount)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(this->mMutationCount == this->Iterator::mTable
.mMutationCount)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(this->mMutationCount == this
->Iterator::mTable.mMutationCount))), 0))) { do { } while (
false); MOZ_ReportAssertionFailure("this->mMutationCount == this->Iterator::mTable.mMutationCount"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1468); AnnotateMozCrashReason("MOZ_ASSERT" "(" "this->mMutationCount == this->Iterator::mTable.mMutationCount"
 ")"); do { *((volatile int*)__null) = 1468; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    return this->mCur.getMutable();
  }

  // Removes the current element and re-inserts it into the table with
  // a new key at the new Lookup position.  |get()| is invalid after
  // this operation until the next call to |next()|.
  void rekey(const Lookup& l, const Key& k) {
    MOZ_ASSERT(&k != &HashPolicy::getKey(this->mCur.get()))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(&k != &HashPolicy::getKey(this->mCur.get(
)))>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(&k != &HashPolicy::getKey(this->mCur.get(
))))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("&k != &HashPolicy::getKey(this->mCur.get())", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1476); AnnotateMozCrashReason("MOZ_ASSERT" "(" "&k != &HashPolicy::getKey(this->mCur.get())"
 ")"); do { *((volatile int*)__null) = 1476; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    Ptr p(this->mCur, mTable);
    mTable.rekeyWithoutRehash(p, l, k);
    mRekeyed = true;
1480#ifdef DEBUG1
    this->mValidEntry = false;
    this->mMutationCount = mTable.mMutationCount;
1483#endif
  }

  void rekey(const Key& k) { rekey(k, k); }

  // Potentially rehashes the table.
  ~ModIterator() {
    if (mRekeyed) {
      mTable.mGen++;
      mTable.infallibleRehashIfOverloaded();
    }

    if (mRemoved) {
      mTable.compact();
    }
  }
};

// Range is similar to Iterator, but uses different terminology.
class Range {
  friend class HashTable;

  Iterator mIter;

 protected:
  explicit Range(const HashTable& table) : mIter(table) {}

 public:
  bool empty() const { return mIter.done(); }

  T& front() const { return mIter.get(); }

  void popFront() { return mIter.next(); }
};

// Enum is similar to ModIterator, but uses different terminology.
class Enum {
  ModIterator mIter;

  // Enum is movable but not copyable.
  Enum(const Enum&) = delete;
  void operator=(const Enum&) = delete;

 public:
  template <class Map>
  explicit Enum(Map& map) : mIter(map.mImpl) {}

  MOZ_IMPLICIT Enum(Enum&& other) : mIter(std::move(other.mIter)) {}

  bool empty() const { return mIter.done(); }

  T& front() const { return mIter.get(); }

  void popFront() { return mIter.next(); }

  void removeFront() { mIter.remove(); }

  NonConstT& mutableFront() { return mIter.getMutable(); }

  void rekeyFront(const Lookup& aLookup, const Key& aKey) {
    mIter.rekey(aLookup, aKey);
  }

  void rekeyFront(const Key& aKey) { mIter.rekey(aKey); }
};

// HashTable is movable
HashTable(HashTable&& aRhs) : AllocPolicy(std::move(aRhs)) { moveFrom(aRhs); }
HashTable& operator=(HashTable&& aRhs) {
  MOZ_ASSERT(this != &aRhs, "self-move assignment is prohibited")do { static_assert( mozilla::detail::AssertionConditionType<
decltype(this != &aRhs)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(this != &aRhs))), 0))) {
 do { } while (false); MOZ_ReportAssertionFailure("this != &aRhs"
 " (" "self-move assignment is prohibited" ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1552); AnnotateMozCrashReason("MOZ_ASSERT" "(" "this != &aRhs"
 ") (" "self-move assignment is prohibited" ")"); do { *((volatile
 int*)__null) = 1552; __attribute__((nomerge)) ::abort(); } while
 (false); } } while (false);
  if (mTable) {
    destroyTable(*this, mTable, capacity());
  }
  AllocPolicy::operator=(std::move(aRhs));
  moveFrom(aRhs);
  return *this;
}

private:
void moveFrom(HashTable& aRhs) {
  mGen = aRhs.mGen;
  mHashShift = aRhs.mHashShift;
  mTable = aRhs.mTable;
  mEntryCount = aRhs.mEntryCount;
  mRemovedCount = aRhs.mRemovedCount;
1568#ifdef DEBUG1
  mMutationCount = aRhs.mMutationCount;
  mEntered = aRhs.mEntered;
1571#endif
  aRhs.mTable = nullptr;
  aRhs.clearAndCompact();
}

// HashTable is not copyable or assignable
HashTable(const HashTable&) = delete;
void operator=(const HashTable&) = delete;

static const uint32_t CAP_BITS = 30;

public:
uint64_t mGen : 56;       // entry storage generation number
uint64_t mHashShift : 8;  // multiplicative hash shift
char* mTable;             // entry storage
uint32_t mEntryCount;     // number of entries in mTable
uint32_t mRemovedCount;   // removed entry sentinels in mTable

1589#ifdef DEBUG1
uint64_t mMutationCount;
mutable bool mEntered;
1592#endif

// The default initial capacity is 32 (enough to hold 16 elements), but it
// can be as low as 4.
static const uint32_t sDefaultLen = 16;
static const uint32_t sMinCapacity = 4;
// See the comments in HashTableEntry about this value.
static_assert(sMinCapacity >= 4, "too-small sMinCapacity breaks assumptions");
static const uint32_t sMaxInit = 1u << (CAP_BITS - 1);
static const uint32_t sMaxCapacity = 1u << CAP_BITS;

// Hash-table alpha is conceptually a fraction, but to avoid floating-point
// math we implement it as a ratio of integers.
static const uint8_t sAlphaDenominator = 4;
static const uint8_t sMinAlphaNumerator = 1;  // min alpha: 1/4
static const uint8_t sMaxAlphaNumerator = 3;  // max alpha: 3/4

static const HashNumber sFreeKey = Entry::sFreeKey;
static const HashNumber sRemovedKey = Entry::sRemovedKey;
static const HashNumber sCollisionBit = Entry::sCollisionBit;

static uint32_t bestCapacity(uint32_t aLen) {
  static_assert(
      (sMaxInit * sAlphaDenominator) / sAlphaDenominator == sMaxInit,
      "multiplication in numerator below could overflow");
  static_assert(
      sMaxInit * sAlphaDenominator <= UINT32_MAX(4294967295U) - sMaxAlphaNumerator,
      "numerator calculation below could potentially overflow");

  // Callers should ensure this is true.
  MOZ_ASSERT(aLen <= sMaxInit)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aLen <= sMaxInit)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aLen <= sMaxInit))), 0)))
 { do { } while (false); MOZ_ReportAssertionFailure("aLen <= sMaxInit"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1622); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aLen <= sMaxInit"
 ")"); do { *((volatile int*)__null) = 1622; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  // Compute the smallest capacity allowing |aLen| elements to be
  // inserted without rehashing: ceil(aLen / max-alpha).  (Ceiling
  // integral division: <http://stackoverflow.com/a/2745086>.)
  uint32_t capacity = (aLen * sAlphaDenominator + sMaxAlphaNumerator - 1) /
                      sMaxAlphaNumerator;
  capacity = (capacity < sMinCapacity) ? sMinCapacity : RoundUpPow2(capacity);

  MOZ_ASSERT(capacity >= aLen)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(capacity >= aLen)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(capacity >= aLen))), 0)))
 { do { } while (false); MOZ_ReportAssertionFailure("capacity >= aLen"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1631); AnnotateMozCrashReason("MOZ_ASSERT" "(" "capacity >= aLen"
 ")"); do { *((volatile int*)__null) = 1631; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(capacity <= sMaxCapacity)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(capacity <= sMaxCapacity)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(capacity <= sMaxCapacity)
)), 0))) { do { } while (false); MOZ_ReportAssertionFailure("capacity <= sMaxCapacity"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1632); AnnotateMozCrashReason("MOZ_ASSERT" "(" "capacity <= sMaxCapacity"
 ")"); do { *((volatile int*)__null) = 1632; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  return capacity;
}

static uint32_t hashShift(uint32_t aLen) {
  // Reject all lengths whose initial computed capacity would exceed
  // sMaxCapacity. Round that maximum aLen down to the nearest power of two
  // for speedier code.
  if (MOZ_UNLIKELY(aLen > sMaxInit)(__builtin_expect(!!(aLen > sMaxInit), 0))) {
    MOZ_CRASH("initial length is too large")do { do { } while (false); MOZ_ReportCrash("" "initial length is too large"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1642); AnnotateMozCrashReason("MOZ_CRASH(" "initial length is too large"
 ")"); do { *((volatile int*)__null) = 1642; __attribute__((nomerge
)) ::abort(); } while (false); } while (false);
  }

  return kHashNumberBits - mozilla::CeilingLog2(bestCapacity(aLen));
}

static bool isLiveHash(HashNumber aHash) { return Entry::isLiveHash(aHash); }

static HashNumber prepareHash(HashNumber aInputHash) {
  HashNumber keyHash = ScrambleHashCode(aInputHash);

  // Avoid reserved hash codes.
  if (!isLiveHash(keyHash)) {
    keyHash -= (sRemovedKey + 1);
  }
  return keyHash & ~sCollisionBit;
}

enum FailureBehavior { DontReportFailure = false, ReportFailure = true };

// Fake a struct that we're going to alloc. See the comments in
// HashTableEntry about how the table is laid out, and why it's safe.
struct FakeSlot {
  unsigned char c[sizeof(HashNumber) + sizeof(typename Entry::NonConstT)];
};

static char* createTable(AllocPolicy& aAllocPolicy, uint32_t aCapacity,
                         FailureBehavior aReportFailure = ReportFailure) {
  FakeSlot* fake =
      aReportFailure
          ? aAllocPolicy.template pod_malloc<FakeSlot>(aCapacity)
          : aAllocPolicy.template maybe_pod_malloc<FakeSlot>(aCapacity);

  MOZ_ASSERT((reinterpret_cast<uintptr_t>(fake) % Entry::kMinimumAlignment) ==do { static_assert( mozilla::detail::AssertionConditionType<
decltype((reinterpret_cast<uintptr_t>(fake) % Entry::kMinimumAlignment
) == 0)>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!((reinterpret_cast<uintptr_t>(fake) % Entry::kMinimumAlignment
) == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("(reinterpret_cast<uintptr_t>(fake) % Entry::kMinimumAlignment) == 0"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1676); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(reinterpret_cast<uintptr_t>(fake) % Entry::kMinimumAlignment) == 0"
 ")"); do { *((volatile int*)__null) = 1676; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false)
             0)do { static_assert( mozilla::detail::AssertionConditionType<
decltype((reinterpret_cast<uintptr_t>(fake) % Entry::kMinimumAlignment
) == 0)>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!((reinterpret_cast<uintptr_t>(fake) % Entry::kMinimumAlignment
) == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("(reinterpret_cast<uintptr_t>(fake) % Entry::kMinimumAlignment) == 0"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1676); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(reinterpret_cast<uintptr_t>(fake) % Entry::kMinimumAlignment) == 0"
 ")"); do { *((volatile int*)__null) = 1676; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  char* table = reinterpret_cast<char*>(fake);
  if (table) {
    forEachSlot(table, aCapacity, [&](Slot& slot) {
      *slot.mKeyHash = sFreeKey;
      new (KnownNotNull, slot.toEntry()) Entry();
    });
  }
  return table;
}

static void destroyTable(AllocPolicy& aAllocPolicy, char* aOldTable,
                         uint32_t aCapacity) {
  forEachSlot(aOldTable, aCapacity, [&](const Slot& slot) {
    if (slot.isLive()) {
      slot.toEntry()->destroyStoredT();
    }
  });
  freeTable(aAllocPolicy, aOldTable, aCapacity);
20
←
Calling 'HashTable::freeTable'→
26
←
Returning; memory was released via 2nd parameter→
}

static void freeTable(AllocPolicy& aAllocPolicy, char* aOldTable,
                      uint32_t aCapacity) {
  FakeSlot* fake = reinterpret_cast<FakeSlot*>(aOldTable);
  aAllocPolicy.free_(fake, aCapacity);
21
←
Calling 'AllocPolicyBase::free_'→
25
←
Returning; memory was released via 1st parameter→
}

public:
HashTable(AllocPolicy aAllocPolicy, uint32_t aLen)
    : AllocPolicy(std::move(aAllocPolicy)),
      mGen(0),
      mHashShift(hashShift(aLen)),
      mTable(nullptr),
      mEntryCount(0),
      mRemovedCount(0)
1712#ifdef DEBUG1
      ,
      mMutationCount(0),
      mEntered(false)
1716#endif
{
}

explicit HashTable(AllocPolicy aAllocPolicy)
    : HashTable(aAllocPolicy, sDefaultLen) {}

~HashTable() {
  if (mTable35.1
Field 'mTable' is non-null
1
Field 'mTable' is non-null
1
Field 'mTable' is non-null
1
Field 'mTable' is non-null
1
Field 'mTable' is non-null
1
Field 'mTable' is non-null
1
Field 'mTable' is non-null
) {
17
←
Assuming field 'mTable' is non-null→
18
←
Taking true branch→
36
←
Taking true branch→
    destroyTable(*this, mTable, capacity());
19
←
Calling 'HashTable::destroyTable'→
27
←
Returning; memory was released via 2nd parameter→
37
←
Use of memory after it is freed
  }
}

private:
HashNumber hash1(HashNumber aHash0) const { return aHash0 >> mHashShift; }

struct DoubleHash {
  HashNumber mHash2;
  HashNumber mSizeMask;
};

DoubleHash hash2(HashNumber aCurKeyHash) const {
  uint32_t sizeLog2 = kHashNumberBits - mHashShift;
  DoubleHash dh = {((aCurKeyHash << sizeLog2) >> mHashShift) | 1,
                   (HashNumber(1) << sizeLog2) - 1};
  return dh;
}

static HashNumber applyDoubleHash(HashNumber aHash1,
                                  const DoubleHash& aDoubleHash) {
  return WrappingSubtract(aHash1, aDoubleHash.mHash2) & aDoubleHash.mSizeMask;
}

static MOZ_ALWAYS_INLINEinline bool match(T& aEntry, const Lookup& aLookup) {
  return HashPolicy::match(HashPolicy::getKey(aEntry), aLookup);
}

enum LookupReason { ForNonAdd, ForAdd };

Slot slotForIndex(HashNumber aIndex) const {
  auto hashes = reinterpret_cast<HashNumber*>(mTable);
  auto entries = reinterpret_cast<Entry*>(&hashes[capacity()]);
  return Slot(&entries[aIndex], &hashes[aIndex]);
}

// Warning: in order for readonlyThreadsafeLookup() to be safe this
// function must not modify the table in any way when Reason==ForNonAdd.
template <LookupReason Reason>
MOZ_ALWAYS_INLINEinline Slot lookup(const Lookup& aLookup,
                              HashNumber aKeyHash) const {
  MOZ_ASSERT(isLiveHash(aKeyHash))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(isLiveHash(aKeyHash))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(isLiveHash(aKeyHash)))), 0))
) { do { } while (false); MOZ_ReportAssertionFailure("isLiveHash(aKeyHash)"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1766); AnnotateMozCrashReason("MOZ_ASSERT" "(" "isLiveHash(aKeyHash)"
 ")"); do { *((volatile int*)__null) = 1766; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(!(aKeyHash & sCollisionBit))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!(aKeyHash & sCollisionBit))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!(aKeyHash & sCollisionBit
)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!(aKeyHash & sCollisionBit)", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1767); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!(aKeyHash & sCollisionBit)"
 ")"); do { *((volatile int*)__null) = 1767; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(mTable)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mTable)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(mTable))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mTable", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1768); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mTable" ")"
); do { *((volatile int*)__null) = 1768; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  // Compute the primary hash address.
  HashNumber h1 = hash1(aKeyHash);
  Slot slot = slotForIndex(h1);

  // Miss: return space for a new entry.
  if (slot.isFree()) {
    return slot;
  }

  // Hit: return entry.
  if (slot.matchHash(aKeyHash) && match(slot.get(), aLookup)) {
    return slot;
  }

  // Collision: double hash.
  DoubleHash dh = hash2(aKeyHash);

  // Save the first removed entry pointer so we can recycle later.
  Maybe<Slot> firstRemoved;

  while (true) {
    if (Reason == ForAdd && !firstRemoved) {
      if (MOZ_UNLIKELY(slot.isRemoved())(__builtin_expect(!!(slot.isRemoved()), 0))) {
        firstRemoved.emplace(slot);
      } else {
        slot.setCollision();
      }
    }

    h1 = applyDoubleHash(h1, dh);

    slot = slotForIndex(h1);
    if (slot.isFree()) {
      return firstRemoved.refOr(slot);
    }

    if (slot.matchHash(aKeyHash) && match(slot.get(), aLookup)) {
      return slot;
    }
  }
}

// This is a copy of lookup() hardcoded to the assumptions:
//   1. the lookup is for an add;
//   2. the key, whose |keyHash| has been passed, is not in the table.
Slot findNonLiveSlot(HashNumber aKeyHash) {
  MOZ_ASSERT(!(aKeyHash & sCollisionBit))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!(aKeyHash & sCollisionBit))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!(aKeyHash & sCollisionBit
)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!(aKeyHash & sCollisionBit)", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1816); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!(aKeyHash & sCollisionBit)"
 ")"); do { *((volatile int*)__null) = 1816; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(mTable)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mTable)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(mTable))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mTable", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1817); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mTable" ")"
); do { *((volatile int*)__null) = 1817; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  // We assume 'aKeyHash' has already been distributed.

  // Compute the primary hash address.
  HashNumber h1 = hash1(aKeyHash);
  Slot slot = slotForIndex(h1);

  // Miss: return space for a new entry.
  if (!slot.isLive()) {
    return slot;
  }

  // Collision: double hash.
  DoubleHash dh = hash2(aKeyHash);

  while (true) {
    slot.setCollision();

    h1 = applyDoubleHash(h1, dh);

    slot = slotForIndex(h1);
    if (!slot.isLive()) {
      return slot;
    }
  }
}

enum RebuildStatus { NotOverloaded, Rehashed, RehashFailed };

RebuildStatus changeTableSize(
    uint32_t newCapacity, FailureBehavior aReportFailure = ReportFailure) {
  MOZ_ASSERT(IsPowerOfTwo(newCapacity))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(IsPowerOfTwo(newCapacity))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(IsPowerOfTwo(newCapacity))))
, 0))) { do { } while (false); MOZ_ReportAssertionFailure("IsPowerOfTwo(newCapacity)"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1849); AnnotateMozCrashReason("MOZ_ASSERT" "(" "IsPowerOfTwo(newCapacity)"
 ")"); do { *((volatile int*)__null) = 1849; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(!!mTable == !!capacity())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!!mTable == !!capacity())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!!mTable == !!capacity()))),
 0))) { do { } while (false); MOZ_ReportAssertionFailure("!!mTable == !!capacity()"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1850); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!!mTable == !!capacity()"
 ")"); do { *((volatile int*)__null) = 1850; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  // Look, but don't touch, until we succeed in getting new entry store.
  char* oldTable = mTable;
  uint32_t oldCapacity = capacity();
  uint32_t newLog2 = mozilla::CeilingLog2(newCapacity);

  if (MOZ_UNLIKELY(newCapacity > sMaxCapacity)(__builtin_expect(!!(newCapacity > sMaxCapacity), 0))) {
    if (aReportFailure) {
      this->reportAllocOverflow();
    }
    return RehashFailed;
  }

  char* newTable = createTable(*this, newCapacity, aReportFailure);
  if (!newTable) {
    return RehashFailed;
  }

  // We can't fail from here on, so update table parameters.
  mHashShift = kHashNumberBits - newLog2;
  mRemovedCount = 0;
  mGen++;
  mTable = newTable;

  // Copy only live entries, leaving removed ones behind.
  forEachSlot(oldTable, oldCapacity, [&](Slot& slot) {
    if (slot.isLive()) {
      HashNumber hn = slot.getKeyHash();
      findNonLiveSlot(hn).setLive(
          hn, std::move(const_cast<typename Entry::NonConstT&>(slot.get())));
    }

    slot.clear();
  });

  // All entries have been destroyed, no need to destroyTable.
  freeTable(*this, oldTable, oldCapacity);
  return Rehashed;
}

RebuildStatus rehashIfOverloaded(
    FailureBehavior aReportFailure = ReportFailure) {
  static_assert(sMaxCapacity <= UINT32_MAX(4294967295U) / sMaxAlphaNumerator,
                "multiplication below could overflow");

  // Note: if capacity() is zero, this will always succeed, which is
  // what we want.
  bool overloaded = mEntryCount + mRemovedCount >=
                    capacity() * sMaxAlphaNumerator / sAlphaDenominator;

  if (!overloaded) {
    return NotOverloaded;
  }

  // Succeed if a quarter or more of all entries are removed. Note that this
  // always succeeds if capacity() == 0 (i.e. entry storage has not been
  // allocated), which is what we want, because it means changeTableSize()
  // will allocate the requested capacity rather than doubling it.
  bool manyRemoved = mRemovedCount >= (capacity() >> 2);
  uint32_t newCapacity = manyRemoved ? rawCapacity() : rawCapacity() * 2;
  return changeTableSize(newCapacity, aReportFailure);
}

void infallibleRehashIfOverloaded() {
  if (rehashIfOverloaded(DontReportFailure) == RehashFailed) {
    rehashTableInPlace();
  }
}

void remove(Slot& aSlot) {
  MOZ_ASSERT(mTable)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mTable)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(mTable))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mTable", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1921); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mTable" ")"
); do { *((volatile int*)__null) = 1921; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  if (aSlot.hasCollision()) {
    aSlot.removeLive();
    mRemovedCount++;
  } else {
    aSlot.clearLive();
  }
  mEntryCount--;
1930#ifdef DEBUG1
  mMutationCount++;
1932#endif
}

void shrinkIfUnderloaded() {
  static_assert(sMaxCapacity <= UINT32_MAX(4294967295U) / sMinAlphaNumerator,
                "multiplication below could overflow");
  bool underloaded =
      capacity() > sMinCapacity &&
      mEntryCount <= capacity() * sMinAlphaNumerator / sAlphaDenominator;

  if (underloaded) {
    (void)changeTableSize(capacity() / 2, DontReportFailure);
  }
}

// This is identical to changeTableSize(currentSize), but without requiring
// a second table.  We do this by recycling the collision bits to tell us if
// the element is already inserted or still waiting to be inserted.  Since
// already-inserted elements win any conflicts, we get the same table as we
// would have gotten through random insertion order.
void rehashTableInPlace() {
  mRemovedCount = 0;
  mGen++;
  forEachSlot(mTable, capacity(), [&](Slot& slot) { slot.unsetCollision(); });
  for (uint32_t i = 0; i < capacity();) {
    Slot src = slotForIndex(i);

    if (!src.isLive() || src.hasCollision()) {
      ++i;
      continue;
    }

    HashNumber keyHash = src.getKeyHash();
    HashNumber h1 = hash1(keyHash);
    DoubleHash dh = hash2(keyHash);
    Slot tgt = slotForIndex(h1);
    while (true) {
      if (!tgt.hasCollision()) {
        src.swap(tgt);
        tgt.setCollision();
        break;
      }

      h1 = applyDoubleHash(h1, dh);
      tgt = slotForIndex(h1);
    }
  }

  // TODO: this algorithm leaves collision bits on *all* elements, even if
  // they are on no collision path. We have the option of setting the
  // collision bits correctly on a subsequent pass or skipping the rehash
  // unless we are totally filled with tombstones: benchmark to find out
  // which approach is best.
}

// Prefer to use putNewInfallible; this function does not check
// invariants.
template <typename... Args>
void putNewInfallibleInternal(HashNumber aKeyHash, Args&&... aArgs) {
  MOZ_ASSERT(mTable)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mTable)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(mTable))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mTable", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 1991); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mTable" ")"
); do { *((volatile int*)__null) = 1991; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  Slot slot = findNonLiveSlot(aKeyHash);

  if (slot.isRemoved()) {
    mRemovedCount--;
    aKeyHash |= sCollisionBit;
  }

  slot.setLive(aKeyHash, std::forward<Args>(aArgs)...);
  mEntryCount++;
2002#ifdef DEBUG1
  mMutationCount++;
2004#endif
}

public:
void clear() {
  forEachSlot(mTable, capacity(), [&](Slot& slot) { slot.clear(); });
  mRemovedCount = 0;
  mEntryCount = 0;
2012#ifdef DEBUG1
  mMutationCount++;
2014#endif
}

// Resize the table down to the smallest capacity that doesn't overload the
// table. Since we call shrinkIfUnderloaded() on every remove, you only need
// to call this after a bulk removal of items done without calling remove().
void compact() {
  if (empty()) {
    // Free the entry storage.
    freeTable(*this, mTable, capacity());
    mGen++;
    mHashShift = hashShift(0);  // gives minimum capacity on regrowth
    mTable = nullptr;
    mRemovedCount = 0;
    return;
  }

  uint32_t bestCapacity = this->bestCapacity(mEntryCount);
  MOZ_ASSERT(bestCapacity <= capacity())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(bestCapacity <= capacity())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(bestCapacity <= capacity(
)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("bestCapacity <= capacity()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2032); AnnotateMozCrashReason("MOZ_ASSERT" "(" "bestCapacity <= capacity()"
 ")"); do { *((volatile int*)__null) = 2032; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  if (bestCapacity < capacity()) {
    (void)changeTableSize(bestCapacity, DontReportFailure);
  }
}

void clearAndCompact() {
  clear();
  compact();
}

[[nodiscard]] bool reserve(uint32_t aLen) {
  if (aLen == 0) {
    return true;
  }

  if (MOZ_UNLIKELY(aLen > sMaxInit)(__builtin_expect(!!(aLen > sMaxInit), 0))) {
    this->reportAllocOverflow();
    return false;
  }

  uint32_t bestCapacity = this->bestCapacity(aLen);
  if (bestCapacity <= capacity()) {
    return true;  // Capacity is already sufficient.
  }

  RebuildStatus status = changeTableSize(bestCapacity, ReportFailure);
  MOZ_ASSERT(status != NotOverloaded)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(status != NotOverloaded)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(status != NotOverloaded))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("status != NotOverloaded"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2060); AnnotateMozCrashReason("MOZ_ASSERT" "(" "status != NotOverloaded"
 ")"); do { *((volatile int*)__null) = 2060; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  return status != RehashFailed;
}

Iterator iter() const { return Iterator(*this); }

ModIterator modIter() { return ModIterator(*this); }

Range all() const { return Range(*this); }

bool empty() const { return mEntryCount == 0; }

uint32_t count() const { return mEntryCount; }

uint32_t rawCapacity() const { return 1u << (kHashNumberBits - mHashShift); }

uint32_t capacity() const { return mTable ? rawCapacity() : 0; }

Generation generation() const { return Generation(mGen); }

size_t shallowSizeOfExcludingThis(MallocSizeOf aMallocSizeOf) const {
  return aMallocSizeOf(mTable);
}

size_t shallowSizeOfIncludingThis(MallocSizeOf aMallocSizeOf) const {
  return aMallocSizeOf(this) + shallowSizeOfExcludingThis(aMallocSizeOf);
}

MOZ_ALWAYS_INLINEinline Ptr readonlyThreadsafeLookup(const Lookup& aLookup) const {
  if (empty()) {
    return Ptr();
  }

  HashNumber inputHash;
  if (!MaybeGetHash<HashPolicy>(aLookup, &inputHash)) {
    return Ptr();
  }

  HashNumber keyHash = prepareHash(inputHash);
  return Ptr(lookup<ForNonAdd>(aLookup, keyHash), *this);
}

MOZ_ALWAYS_INLINEinline Ptr lookup(const Lookup& aLookup) const {
  ReentrancyGuard g(*this);
  return readonlyThreadsafeLookup(aLookup);
}

MOZ_ALWAYS_INLINEinline AddPtr lookupForAdd(const Lookup& aLookup) {
  ReentrancyGuard g(*this);

  HashNumber inputHash;
  if (!EnsureHash<HashPolicy>(aLookup, &inputHash)) {
    return AddPtr();
  }

  HashNumber keyHash = prepareHash(inputHash);

  if (!mTable) {
    return AddPtr(*this, keyHash);
  }

  // Directly call the constructor in the return statement to avoid
  // excess copying when building with Visual Studio 2017.
  // See bug 1385181.
  return AddPtr(lookup<ForAdd>(aLookup, keyHash), *this, keyHash);
}

template <typename... Args>
[[nodiscard]] bool add(AddPtr& aPtr, Args&&... aArgs) {
  ReentrancyGuard g(*this);
  MOZ_ASSERT_IF(aPtr.isValid(), mTable)do { if (aPtr.isValid()) { do { static_assert( mozilla::detail
::AssertionConditionType<decltype(mTable)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(mTable))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mTable", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2130); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mTable" ")"
); do { *((volatile int*)__null) = 2130; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false);
  MOZ_ASSERT_IF(aPtr.isValid(), aPtr.mTable == this)do { if (aPtr.isValid()) { do { static_assert( mozilla::detail
::AssertionConditionType<decltype(aPtr.mTable == this)>
::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(aPtr.mTable == this))), 0))) { do { } while (false);
 MOZ_ReportAssertionFailure("aPtr.mTable == this", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2131); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aPtr.mTable == this"
 ")"); do { *((volatile int*)__null) = 2131; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false); } } while (
false);
  MOZ_ASSERT(!aPtr.found())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!aPtr.found())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!aPtr.found()))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("!aPtr.found()",
 "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2132); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!aPtr.found()"
 ")"); do { *((volatile int*)__null) = 2132; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(!(aPtr.mKeyHash & sCollisionBit))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!(aPtr.mKeyHash & sCollisionBit))>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!(aPtr.mKeyHash & sCollisionBit
)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!(aPtr.mKeyHash & sCollisionBit)", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2133); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!(aPtr.mKeyHash & sCollisionBit)"
 ")"); do { *((volatile int*)__null) = 2133; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);

  // Check for error from ensureHash() here.
  if (!aPtr.isLive()) {
    return false;
  }

  MOZ_ASSERT(aPtr.mGeneration == generation())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aPtr.mGeneration == generation())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aPtr.mGeneration == generation
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("aPtr.mGeneration == generation()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2140); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aPtr.mGeneration == generation()"
 ")"); do { *((volatile int*)__null) = 2140; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
2141#ifdef DEBUG1
  MOZ_ASSERT(aPtr.mMutationCount == mMutationCount)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aPtr.mMutationCount == mMutationCount)>::isValid,
 "invalid assertion condition"); if ((__builtin_expect(!!(!(!
!(aPtr.mMutationCount == mMutationCount))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("aPtr.mMutationCount == mMutationCount"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2142); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aPtr.mMutationCount == mMutationCount"
 ")"); do { *((volatile int*)__null) = 2142; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
2143#endif

  if (!aPtr.isValid()) {
    MOZ_ASSERT(!mTable && mEntryCount == 0)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!mTable && mEntryCount == 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!mTable && mEntryCount
 == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("!mTable && mEntryCount == 0", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2146); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mTable && mEntryCount == 0"
 ")"); do { *((volatile int*)__null) = 2146; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    uint32_t newCapacity = rawCapacity();
    RebuildStatus status = changeTableSize(newCapacity, ReportFailure);
    MOZ_ASSERT(status != NotOverloaded)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(status != NotOverloaded)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(status != NotOverloaded))), 0
))) { do { } while (false); MOZ_ReportAssertionFailure("status != NotOverloaded"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2149); AnnotateMozCrashReason("MOZ_ASSERT" "(" "status != NotOverloaded"
 ")"); do { *((volatile int*)__null) = 2149; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    if (status == RehashFailed) {
      return false;
    }
    aPtr.mSlot = findNonLiveSlot(aPtr.mKeyHash);

  } else if (aPtr.mSlot.isRemoved()) {
    // Changing an entry from removed to live does not affect whether we are
    // overloaded and can be handled separately.
    if (!this->checkSimulatedOOM()) {
      return false;
    }
    mRemovedCount--;
    aPtr.mKeyHash |= sCollisionBit;

  } else {
    // Preserve the validity of |aPtr.mSlot|.
    RebuildStatus status = rehashIfOverloaded();
    if (status == RehashFailed) {
      return false;
    }
    if (status == NotOverloaded && !this->checkSimulatedOOM()) {
      return false;
    }
    if (status == Rehashed) {
      aPtr.mSlot = findNonLiveSlot(aPtr.mKeyHash);
    }
  }

  aPtr.mSlot.setLive(aPtr.mKeyHash, std::forward<Args>(aArgs)...);
  mEntryCount++;
2180#ifdef DEBUG1
  mMutationCount++;
  aPtr.mGeneration = generation();
  aPtr.mMutationCount = mMutationCount;
2184#endif
  return true;
}

// Note: |aLookup| may reference pieces of arguments in |aArgs|, so this
// function must take care not to use |aLookup| after moving |aArgs|.
template <typename... Args>
void putNewInfallible(const Lookup& aLookup, Args&&... aArgs) {
  MOZ_ASSERT(!lookup(aLookup).found())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!lookup(aLookup).found())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!lookup(aLookup).found()))),
 0))) { do { } while (false); MOZ_ReportAssertionFailure("!lookup(aLookup).found()"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2192); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!lookup(aLookup).found()"
 ")"); do { *((volatile int*)__null) = 2192; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  ReentrancyGuard g(*this);
  HashNumber keyHash = prepareHash(HashPolicy::hash(aLookup));
  putNewInfallibleInternal(keyHash, std::forward<Args>(aArgs)...);
}

// Note: |aLookup| may alias arguments in |aArgs|, so this function must take
// care not to use |aLookup| after moving |aArgs|.
template <typename... Args>
[[nodiscard]] bool putNew(const Lookup& aLookup, Args&&... aArgs) {
  MOZ_ASSERT(!lookup(aLookup).found())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!lookup(aLookup).found())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!lookup(aLookup).found()))),
 0))) { do { } while (false); MOZ_ReportAssertionFailure("!lookup(aLookup).found()"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2202); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!lookup(aLookup).found()"
 ")"); do { *((volatile int*)__null) = 2202; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  ReentrancyGuard g(*this);
  if (!this->checkSimulatedOOM()) {
    return false;
  }
  HashNumber inputHash;
  if (!EnsureHash<HashPolicy>(aLookup, &inputHash)) {
    return false;
  }
  HashNumber keyHash = prepareHash(inputHash);
  if (rehashIfOverloaded() == RehashFailed) {
    return false;
  }
  putNewInfallibleInternal(keyHash, std::forward<Args>(aArgs)...);
  return true;
}

// Note: |aLookup| may be a reference pieces of arguments in |aArgs|, so this
// function must take care not to use |aLookup| after moving |aArgs|.
template <typename... Args>
[[nodiscard]] bool relookupOrAdd(AddPtr& aPtr, const Lookup& aLookup,
                                 Args&&... aArgs) {
  // Check for error from ensureHash() here.
  if (!aPtr.isLive()) {
    return false;
  }
2228#ifdef DEBUG1
  aPtr.mGeneration = generation();
  aPtr.mMutationCount = mMutationCount;
2231#endif
  if (mTable) {
    ReentrancyGuard g(*this);
    // Check that aLookup has not been destroyed.
    MOZ_ASSERT(prepareHash(HashPolicy::hash(aLookup)) == aPtr.mKeyHash)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(prepareHash(HashPolicy::hash(aLookup)) == aPtr.mKeyHash
)>::isValid, "invalid assertion condition"); if ((__builtin_expect
(!!(!(!!(prepareHash(HashPolicy::hash(aLookup)) == aPtr.mKeyHash
))), 0))) { do { } while (false); MOZ_ReportAssertionFailure(
"prepareHash(HashPolicy::hash(aLookup)) == aPtr.mKeyHash", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2235); AnnotateMozCrashReason("MOZ_ASSERT" "(" "prepareHash(HashPolicy::hash(aLookup)) == aPtr.mKeyHash"
 ")"); do { *((volatile int*)__null) = 2235; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
    aPtr.mSlot = lookup<ForAdd>(aLookup, aPtr.mKeyHash);
    if (aPtr.found()) {
      return true;
    }
  } else {
    // Clear aPtr so it's invalid; add() will allocate storage and redo the
    // lookup.
    aPtr.mSlot = Slot(nullptr, nullptr);
  }
  return add(aPtr, std::forward<Args>(aArgs)...);
}

void remove(Ptr aPtr) {
  MOZ_ASSERT(mTable)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mTable)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(mTable))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mTable", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2249); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mTable" ")"
); do { *((volatile int*)__null) = 2249; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  ReentrancyGuard g(*this);
  MOZ_ASSERT(aPtr.found())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aPtr.found())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aPtr.found()))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("aPtr.found()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2251); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aPtr.found()"
 ")"); do { *((volatile int*)__null) = 2251; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(aPtr.mGeneration == generation())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aPtr.mGeneration == generation())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aPtr.mGeneration == generation
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("aPtr.mGeneration == generation()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2252); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aPtr.mGeneration == generation()"
 ")"); do { *((volatile int*)__null) = 2252; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  remove(aPtr.mSlot);
  shrinkIfUnderloaded();
}

void rekeyWithoutRehash(Ptr aPtr, const Lookup& aLookup, const Key& aKey) {
  MOZ_ASSERT(mTable)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(mTable)>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(mTable))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("mTable", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2258); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mTable" ")"
); do { *((volatile int*)__null) = 2258; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  ReentrancyGuard g(*this);
  MOZ_ASSERT(aPtr.found())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aPtr.found())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aPtr.found()))), 0))) { do {
 } while (false); MOZ_ReportAssertionFailure("aPtr.found()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2260); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aPtr.found()"
 ")"); do { *((volatile int*)__null) = 2260; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  MOZ_ASSERT(aPtr.mGeneration == generation())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(aPtr.mGeneration == generation())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(aPtr.mGeneration == generation
()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure
("aPtr.mGeneration == generation()", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/HashTable.h"
, 2261); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aPtr.mGeneration == generation()"
 ")"); do { *((volatile int*)__null) = 2261; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  typename HashTableEntry<T>::NonConstT t(std::move(*aPtr));
  HashPolicy::setKey(t, const_cast<Key&>(aKey));
  remove(aPtr.mSlot);
  HashNumber keyHash = prepareHash(HashPolicy::hash(aLookup));
  putNewInfallibleInternal(keyHash, std::move(t));
}

void rekeyAndMaybeRehash(Ptr aPtr, const Lookup& aLookup, const Key& aKey) {
  rekeyWithoutRehash(aPtr, aLookup, aKey);
  infallibleRehashIfOverloaded();
}
2273};

2275}  // namespace detail
2276}  // namespace mozilla

2278#endif /* mozilla_HashTable_h */

←

/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/AllocPolicy.h

→

1/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* 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/. */

7/*
* JS allocation policies.
*
* The allocators here are for system memory with lifetimes which are not
* managed by the GC. See the comment at the top of vm/MallocProvider.h.
*/

14#ifndef js_AllocPolicy_h
15#define js_AllocPolicy_h

17#include "js/TypeDecls.h"
18#include "js/Utility.h"

20extern MOZ_COLD__attribute__((cold)) JS_PUBLIC_API void JS_ReportOutOfMemory(JSContext* cx);

22namespace js {

24class FrontendContext;

26enum class AllocFunction { Malloc, Calloc, Realloc };

28class ArenaAllocPolicyBase {
public:
template <typename T>
T* maybe_pod_arena_malloc(arena_id_t arenaId, size_t numElems) {
  return js_pod_arena_malloc<T>(arenaId, numElems);
}
template <typename T>
T* maybe_pod_arena_calloc(arena_id_t arenaId, size_t numElems) {
  return js_pod_arena_calloc<T>(arenaId, numElems);
}
template <typename T>
T* maybe_pod_arena_realloc(arena_id_t arenaId, T* p, size_t oldSize,
                           size_t newSize) {
  return js_pod_arena_realloc<T>(arenaId, p, oldSize, newSize);
}
template <typename T>
T* pod_arena_malloc(arena_id_t arenaId, size_t numElems) {
  return maybe_pod_arena_malloc<T>(arenaId, numElems);
}
template <typename T>
T* pod_arena_calloc(arena_id_t arenaId, size_t numElems) {
  return maybe_pod_arena_calloc<T>(arenaId, numElems);
}
template <typename T>
T* pod_arena_realloc(arena_id_t arenaId, T* p, size_t oldSize,
                     size_t newSize) {
  return maybe_pod_arena_realloc<T>(arenaId, p, oldSize, newSize);
}
56};

58/* Base class allocation policies providing allocation methods. */
59class AllocPolicyBase : public ArenaAllocPolicyBase {
public:
template <typename T>
T* maybe_pod_malloc(size_t numElems) {
  return maybe_pod_arena_malloc<T>(js::MallocArena, numElems);
}
template <typename T>
T* maybe_pod_calloc(size_t numElems) {
  return maybe_pod_arena_calloc<T>(js::MallocArena, numElems);
}
template <typename T>
T* maybe_pod_realloc(T* p, size_t oldSize, size_t newSize) {
  return maybe_pod_arena_realloc<T>(js::MallocArena, p, oldSize, newSize);
}
template <typename T>
T* pod_malloc(size_t numElems) {
  return pod_arena_malloc<T>(js::MallocArena, numElems);
}
template <typename T>
T* pod_calloc(size_t numElems) {
  return pod_arena_calloc<T>(js::MallocArena, numElems);
}
template <typename T>
T* pod_realloc(T* p, size_t oldSize, size_t newSize) {
  return pod_arena_realloc<T>(js::MallocArena, p, oldSize, newSize);
}

template <typename T>
void free_(T* p, size_t numElems = 0) {
  js_free(p);
22
←
Calling 'js_free'→
24
←
Returning; memory was released via 1st parameter→
}
90};

92/*
* Base class allocation policies providing allocation methods for allocations
* off the main thread.
*/
96class BackgroundAllocPolicyBase : ArenaAllocPolicyBase {
public:
template <typename T>
T* maybe_pod_malloc(size_t numElems) {
  return maybe_pod_arena_malloc<T>(js::BackgroundMallocArena, numElems);
}
template <typename T>
T* maybe_pod_calloc(size_t numElems) {
  return maybe_pod_arena_calloc<T>(js::BackgroundMallocArena, numElems);
}
template <typename T>
T* maybe_pod_realloc(T* p, size_t oldSize, size_t newSize) {
  return maybe_pod_arena_realloc<T>(js::BackgroundMallocArena, p, oldSize,
                                    newSize);
}
template <typename T>
T* pod_malloc(size_t numElems) {
  return pod_arena_malloc<T>(js::BackgroundMallocArena, numElems);
}
template <typename T>
T* pod_calloc(size_t numElems) {
  return pod_arena_calloc<T>(js::BackgroundMallocArena, numElems);
}
template <typename T>
T* pod_realloc(T* p, size_t oldSize, size_t newSize) {
  return pod_arena_realloc<T>(js::BackgroundMallocArena, p, oldSize, newSize);
}

template <typename T>
void free_(T* p, size_t numElems = 0) {
  js_free(p);
}
128};

130/* Policy for using system memory functions and doing no error reporting. */
131class SystemAllocPolicy : public AllocPolicyBase {
public:
void reportAllocOverflow() const {}
bool checkSimulatedOOM() const { return !js::oom::ShouldFailWithOOM(); }
135};

137class BackgroundSystemAllocPolicy : public BackgroundAllocPolicyBase {
public:
void reportAllocOverflow() const {}
bool checkSimulatedOOM() const { return !js::oom::ShouldFailWithOOM(); }
141};

143MOZ_COLD__attribute__((cold)) JS_PUBLIC_API void ReportOutOfMemory(JSContext* cx);
144MOZ_COLD__attribute__((cold)) JS_PUBLIC_API void ReportOutOfMemory(FrontendContext* fc);

146// An out of memory condition which is easily user generatable and should
147// be specially handled to try and avoid a tab crash.
148MOZ_COLD__attribute__((cold)) JS_PUBLIC_API void ReportLargeOutOfMemory(JSContext* cx);

150/*
* Allocation policy that calls the system memory functions and reports errors
* to the context. Since the JSContext given on construction is stored for
* the lifetime of the container, this policy may only be used for containers
* whose lifetime is a shorter than the given JSContext.
*
* FIXME bug 647103 - rewrite this in terms of temporary allocation functions,
* not the system ones.
*/
159class JS_PUBLIC_API TempAllocPolicy : public AllocPolicyBase {
// Type tag for context_bits_
static constexpr uintptr_t JsContextTag = 0x1;

// Either a JSContext* (if JsContextTag is set), or FrontendContext*
uintptr_t const context_bits_;

MOZ_ALWAYS_INLINEinline bool hasJSContext() const {
  return (context_bits_ & JsContextTag) == JsContextTag;
}

MOZ_ALWAYS_INLINEinline JSContext* cx() const {
  MOZ_ASSERT(hasJSContext())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(hasJSContext())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(hasJSContext()))), 0))) { do
 { } while (false); MOZ_ReportAssertionFailure("hasJSContext()"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/AllocPolicy.h"
, 171); AnnotateMozCrashReason("MOZ_ASSERT" "(" "hasJSContext()"
 ")"); do { *((volatile int*)__null) = 171; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  return reinterpret_cast<JSContext*>(context_bits_ ^ JsContextTag);
}

MOZ_ALWAYS_INLINEinline FrontendContext* fc() const {
  MOZ_ASSERT(!hasJSContext())do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!hasJSContext())>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(!hasJSContext()))), 0))) { do
 { } while (false); MOZ_ReportAssertionFailure("!hasJSContext()"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/AllocPolicy.h"
, 176); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!hasJSContext()"
 ")"); do { *((volatile int*)__null) = 176; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
  return reinterpret_cast<FrontendContext*>(context_bits_);
}

/*
 * Non-inline helper to call JSRuntime::onOutOfMemory with minimal
 * code bloat.
 */
void* onOutOfMemory(arena_id_t arenaId, AllocFunction allocFunc,
                    size_t nbytes, void* reallocPtr = nullptr);

template <typename T>
T* onOutOfMemoryTyped(arena_id_t arenaId, AllocFunction allocFunc,
                      size_t numElems, void* reallocPtr = nullptr) {
  size_t bytes;
  if (MOZ_UNLIKELY(!CalculateAllocSize<T>(numElems, &bytes))(__builtin_expect(!!(!CalculateAllocSize<T>(numElems, &
bytes)), 0))) {
    return nullptr;
  }
  return static_cast<T*>(
      onOutOfMemory(arenaId, allocFunc, bytes, reallocPtr));
}

public:
MOZ_IMPLICIT TempAllocPolicy(JSContext* cx)
    : context_bits_(uintptr_t(cx) | JsContextTag) {
  MOZ_ASSERT((uintptr_t(cx) & JsContextTag) == 0)do { static_assert( mozilla::detail::AssertionConditionType<
decltype((uintptr_t(cx) & JsContextTag) == 0)>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!((uintptr_t(cx) & JsContextTag) == 0))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("(uintptr_t(cx) & JsContextTag) == 0"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/AllocPolicy.h"
, 201); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(uintptr_t(cx) & JsContextTag) == 0"
 ")"); do { *((volatile int*)__null) = 201; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
}
MOZ_IMPLICIT TempAllocPolicy(FrontendContext* fc)
    : context_bits_(uintptr_t(fc)) {
  MOZ_ASSERT((uintptr_t(fc) & JsContextTag) == 0)do { static_assert( mozilla::detail::AssertionConditionType<
decltype((uintptr_t(fc) & JsContextTag) == 0)>::isValid
, "invalid assertion condition"); if ((__builtin_expect(!!(!(
!!((uintptr_t(fc) & JsContextTag) == 0))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("(uintptr_t(fc) & JsContextTag) == 0"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/AllocPolicy.h"
, 205); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(uintptr_t(fc) & JsContextTag) == 0"
 ")"); do { *((volatile int*)__null) = 205; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
}

template <typename T>
T* pod_arena_malloc(arena_id_t arenaId, size_t numElems) {
  T* p = this->maybe_pod_arena_malloc<T>(arenaId, numElems);
  if (MOZ_UNLIKELY(!p)(__builtin_expect(!!(!p), 0))) {
    p = onOutOfMemoryTyped<T>(arenaId, AllocFunction::Malloc, numElems);
  }
  return p;
}

template <typename T>
T* pod_arena_calloc(arena_id_t arenaId, size_t numElems) {
  T* p = this->maybe_pod_arena_calloc<T>(arenaId, numElems);
  if (MOZ_UNLIKELY(!p)(__builtin_expect(!!(!p), 0))) {
    p = onOutOfMemoryTyped<T>(arenaId, AllocFunction::Calloc, numElems);
  }
  return p;
}

template <typename T>
T* pod_arena_realloc(arena_id_t arenaId, T* prior, size_t oldSize,
                     size_t newSize) {
  T* p2 = this->maybe_pod_arena_realloc<T>(arenaId, prior, oldSize, newSize);
  if (MOZ_UNLIKELY(!p2)(__builtin_expect(!!(!p2), 0))) {
    p2 = onOutOfMemoryTyped<T>(arenaId, AllocFunction::Realloc, newSize,
                               prior);
  }
  return p2;
}

template <typename T>
T* pod_malloc(size_t numElems) {
  return pod_arena_malloc<T>(js::MallocArena, numElems);
}

template <typename T>
T* pod_calloc(size_t numElems) {
  return pod_arena_calloc<T>(js::MallocArena, numElems);
}

template <typename T>
T* pod_realloc(T* prior, size_t oldSize, size_t newSize) {
  return pod_arena_realloc<T>(js::MallocArena, prior, oldSize, newSize);
}

template <typename T>
void free_(T* p, size_t numElems = 0) {
  js_free(p);
}

void reportAllocOverflow() const;

bool checkSimulatedOOM() const {
  if (js::oom::ShouldFailWithOOM()) {
    if (hasJSContext()) {
      ReportOutOfMemory(cx());
    } else {
      ReportOutOfMemory(fc());
    }
    return false;
  }

  return true;
}
271};

273/*
* A replacement for MallocAllocPolicy that allocates in the JS heap and adds no
* extra behaviours.
*
* This is currently used for allocating source buffers for parsing. Since these
* are temporary and will not be freed by GC, the memory is not tracked by the
* usual accounting.
*/
281class MallocAllocPolicy : public AllocPolicyBase {
public:
void reportAllocOverflow() const {}

[[nodiscard]] bool checkSimulatedOOM() const { return true; }
286};

288} /* namespace js */

290#endif /* js_AllocPolicy_h */

←

/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h

→

1/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 * vim: set ts=8 sts=2 et sw=2 tw=80:
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6 
7#ifndef js_Utility_h
8#define js_Utility_h
9 
10#include "mozilla/Assertions.h"
11#include "mozilla/Atomics.h"
12#include "mozilla/Attributes.h"
13#include "mozilla/Compiler.h"
14#include "mozilla/TemplateLib.h"
15#include "mozilla/UniquePtr.h"
16 
17#include <stdlib.h>
18#include <string.h>
19#include <type_traits>
20#include <utility>
21 
22#include "jstypes.h"
23#include "mozmemory.h"
24#include "js/TypeDecls.h"
25 
26/* The public JS engine namespace. */
27namespace JS {}
28 
29/* The mozilla-shared reusable template/utility namespace. */
30namespace mozilla {}
31 
32/* The private JS engine namespace. */
33namespace js {}
34 
35extern MOZ_NORETURN__attribute__((noreturn)) MOZ_COLD__attribute__((cold)) JS_PUBLIC_API void JS_Assert(const char* s,
36                                                          const char* file,
37                                                          int ln);
38 
39/*
40 * Custom allocator support for SpiderMonkey
41 */
42#if defined JS_USE_CUSTOM_ALLOCATOR
43#  include "jscustomallocator.h"
44#else
45 
46namespace js {
47 
48/*
49 * Thread types are used to tag threads for certain kinds of testing (see
50 * below), and also used to characterize threads in the thread scheduler (see
51 * js/src/vm/HelperThreads.cpp).
52 *
53 * Please update oom::FirstThreadTypeToTest and oom::LastThreadTypeToTest when
54 * adding new thread types.
55 */
56enum ThreadType {
57  THREAD_TYPE_NONE = 0,                       // 0
58  THREAD_TYPE_MAIN,                           // 1
59  THREAD_TYPE_WASM_COMPILE_TIER1,             // 2
60  THREAD_TYPE_WASM_COMPILE_TIER2,             // 3
61  THREAD_TYPE_ION,                            // 4
62  THREAD_TYPE_COMPRESS,                       // 5
63  THREAD_TYPE_GCPARALLEL,                     // 6
64  THREAD_TYPE_PROMISE_TASK,                   // 7
65  THREAD_TYPE_ION_FREE,                       // 8
66  THREAD_TYPE_WASM_GENERATOR_COMPLETE_TIER2,  // 9
67  THREAD_TYPE_WASM_COMPILE_PARTIAL_TIER2,     // 10
68  THREAD_TYPE_WORKER,                         // 11
69  THREAD_TYPE_DELAZIFY,                       // 12
70  THREAD_TYPE_DELAZIFY_FREE,                  // 13
71  THREAD_TYPE_MAX  // Used to check shell function arguments
72};
73 
74namespace oom {
75 
76/*
77 * Theads are tagged only in certain debug contexts.  Notably, to make testing
78 * OOM in certain helper threads more effective, we allow restricting the OOM
79 * testing to a certain helper thread type. This allows us to fail e.g. in
80 * off-thread script parsing without causing an OOM in the active thread first.
81 *
82 * Getter/Setter functions to encapsulate mozilla::ThreadLocal, implementation
83 * is in util/Utility.cpp.
84 */
85#  if defined(DEBUG1) || defined(JS_OOM_BREAKPOINT)
86 
87// Define the range of threads tested by simulated OOM testing and the
88// like. Testing worker threads is not supported.
89const ThreadType FirstThreadTypeToTest = THREAD_TYPE_MAIN;
90const ThreadType LastThreadTypeToTest = THREAD_TYPE_WASM_COMPILE_PARTIAL_TIER2;
91 
92extern bool InitThreadType(void);
93extern void SetThreadType(ThreadType);
94extern JS_PUBLIC_API uint32_t GetThreadType(void);
95 
96#  else
97 
98inline bool InitThreadType(void) { return true; }
99inline void SetThreadType(ThreadType t) {};
100inline uint32_t GetThreadType(void) { return 0; }
101inline uint32_t GetAllocationThreadType(void) { return 0; }
102inline uint32_t GetStackCheckThreadType(void) { return 0; }
103inline uint32_t GetInterruptCheckThreadType(void) { return 0; }
104 
105#  endif
106 
107} /* namespace oom */
108} /* namespace js */
109 
110#  if defined(DEBUG1) || defined(JS_OOM_BREAKPOINT)
111 
112#    ifdef JS_OOM_BREAKPOINT
113#      if defined(_MSC_VER)
114static MOZ_NEVER_INLINE__attribute__((noinline)) void js_failedAllocBreakpoint() {
115  __asm {}
116  ;
117}
118#      else
119static MOZ_NEVER_INLINE__attribute__((noinline)) void js_failedAllocBreakpoint() { asm(""); }
120#      endif
121#      define JS_OOM_CALL_BP_FUNC()do { } while (0) js_failedAllocBreakpoint()
122#    else
123#      define JS_OOM_CALL_BP_FUNC()do { } while (0) \
124        do {                        \
125        } while (0)
126#    endif
127 
128namespace js {
129namespace oom {
130 
131/*
132 * Out of memory testing support.  We provide various testing functions to
133 * simulate OOM conditions and so we can test that they are handled correctly.
134 */
135class FailureSimulator {
136 public:
137  enum class Kind : uint8_t { Nothing, OOM, StackOOM, Interrupt };
138 
139 private:
140  Kind kind_ = Kind::Nothing;
141  uint32_t targetThread_ = 0;
142  uint64_t maxChecks_ = UINT64_MAX(18446744073709551615UL);
143  uint64_t counter_ = 0;
144  bool failAlways_ = true;
145  bool inUnsafeRegion_ = false;
146 
147 public:
148  uint64_t maxChecks() const { return maxChecks_; }
149  uint64_t counter() const { return counter_; }
150  void setInUnsafeRegion(bool b) {
151    MOZ_ASSERT(inUnsafeRegion_ != b)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(inUnsafeRegion_ != b)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(inUnsafeRegion_ != b))), 0))
) { do { } while (false); MOZ_ReportAssertionFailure("inUnsafeRegion_ != b"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
, 151); AnnotateMozCrashReason("MOZ_ASSERT" "(" "inUnsafeRegion_ != b"
 ")"); do { *((volatile int*)__null) = 151; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
152    inUnsafeRegion_ = b;
153  }
154  uint32_t targetThread() const { return targetThread_; }
155  bool isThreadSimulatingAny() const {
156    return targetThread_ && targetThread_ == js::oom::GetThreadType() &&
157           !inUnsafeRegion_;
158  }
159  bool isThreadSimulating(Kind kind) const {
160    return kind_ == kind && isThreadSimulatingAny();
161  }
162  bool isSimulatedFailure(Kind kind) const {
163    if (!isThreadSimulating(kind)) {
164      return false;
165    }
166    return counter_ == maxChecks_ || (counter_ > maxChecks_ && failAlways_);
167  }
168  bool hadFailure(Kind kind) const {
169    return kind_ == kind && counter_ >= maxChecks_;
170  }
171  bool shouldFail(Kind kind) {
172    if (!isThreadSimulating(kind)) {
173      return false;
174    }
175    counter_++;
176    if (isSimulatedFailure(kind)) {
177      JS_OOM_CALL_BP_FUNC()do { } while (0);
178      return true;
179    }
180    return false;
181  }
182 
183  void simulateFailureAfter(Kind kind, uint64_t checks, uint32_t thread,
184                            bool always);
185  void reset();
186};
187extern JS_PUBLIC_DATA FailureSimulator simulator;
188 
189inline bool IsSimulatedOOMAllocation() {
190  return simulator.isSimulatedFailure(FailureSimulator::Kind::OOM);
191}
192 
193inline bool ShouldFailWithOOM() {
194  return simulator.shouldFail(FailureSimulator::Kind::OOM);
195}
196 
197inline bool HadSimulatedOOM() {
198  return simulator.hadFailure(FailureSimulator::Kind::OOM);
199}
200 
201/*
202 * Out of stack space testing support, similar to OOM testing functions.
203 */
204 
205inline bool IsSimulatedStackOOMCheck() {
206  return simulator.isSimulatedFailure(FailureSimulator::Kind::StackOOM);
207}
208 
209inline bool ShouldFailWithStackOOM() {
210  return simulator.shouldFail(FailureSimulator::Kind::StackOOM);
211}
212 
213inline bool HadSimulatedStackOOM() {
214  return simulator.hadFailure(FailureSimulator::Kind::StackOOM);
215}
216 
217/*
218 * Interrupt testing support, similar to OOM testing functions.
219 */
220 
221inline bool IsSimulatedInterruptCheck() {
222  return simulator.isSimulatedFailure(FailureSimulator::Kind::Interrupt);
223}
224 
225inline bool ShouldFailWithInterrupt() {
226  return simulator.shouldFail(FailureSimulator::Kind::Interrupt);
227}
228 
229inline bool HadSimulatedInterrupt() {
230  return simulator.hadFailure(FailureSimulator::Kind::Interrupt);
231}
232 
233} /* namespace oom */
234} /* namespace js */
235 
236#    define JS_OOM_POSSIBLY_FAIL()do { if (js::oom::ShouldFailWithOOM()) return nullptr; } while
 (0)                        \
237      do {                                                \
238        if (js::oom::ShouldFailWithOOM()) return nullptr; \
239      } while (0)
240 
241#    define JS_OOM_POSSIBLY_FAIL_BOOL()do { if (js::oom::ShouldFailWithOOM()) return false; } while (
0)                 \
242      do {                                              \
243        if (js::oom::ShouldFailWithOOM()) return false; \
244      } while (0)
245 
246#    define JS_STACK_OOM_POSSIBLY_FAIL()do { if (js::oom::ShouldFailWithStackOOM()) return false; } while
 (0)                     \
247      do {                                                   \
248        if (js::oom::ShouldFailWithStackOOM()) return false; \
249      } while (0)
250 
251#    define JS_INTERRUPT_POSSIBLY_FAIL()do { if ((__builtin_expect(!!(js::oom::ShouldFailWithInterrupt
()), 0))) { cx->requestInterrupt(js::InterruptReason::CallbackUrgent
); return cx->handleInterrupt(); } } while (0)                             \
252      do {                                                           \
253        if (MOZ_UNLIKELY(js::oom::ShouldFailWithInterrupt())(__builtin_expect(!!(js::oom::ShouldFailWithInterrupt()), 0))) {      \
254          cx->requestInterrupt(js::InterruptReason::CallbackUrgent); \
255          return cx->handleInterrupt();                              \
256        }                                                            \
257      } while (0)
258 
259#  else
260 
261#    define JS_OOM_POSSIBLY_FAIL()do { if (js::oom::ShouldFailWithOOM()) return nullptr; } while
 (0) \
262      do {                         \
263      } while (0)
264#    define JS_OOM_POSSIBLY_FAIL_BOOL()do { if (js::oom::ShouldFailWithOOM()) return false; } while (
0) \
265      do {                              \
266      } while (0)
267#    define JS_STACK_OOM_POSSIBLY_FAIL()do { if (js::oom::ShouldFailWithStackOOM()) return false; } while
 (0) \
268      do {                               \
269      } while (0)
270#    define JS_INTERRUPT_POSSIBLY_FAIL()do { if ((__builtin_expect(!!(js::oom::ShouldFailWithInterrupt
()), 0))) { cx->requestInterrupt(js::InterruptReason::CallbackUrgent
); return cx->handleInterrupt(); } } while (0) \
271      do {                               \
272      } while (0)
273namespace js {
274namespace oom {
275static inline bool IsSimulatedOOMAllocation() { return false; }
276static inline bool ShouldFailWithOOM() { return false; }
277} /* namespace oom */
278} /* namespace js */
279 
280#  endif /* DEBUG || JS_OOM_BREAKPOINT */
281 
282#  ifdef FUZZING
283namespace js {
284namespace oom {
285extern JS_PUBLIC_DATA size_t largeAllocLimit;
286extern void InitLargeAllocLimit();
287} /* namespace oom */
288} /* namespace js */
289 
290#    define JS_CHECK_LARGE_ALLOC(x)do { } while (0)                                     \
291      do {                                                              \
292        if (js::oom::largeAllocLimit && x > js::oom::largeAllocLimit) { \
293          if (getenv("MOZ_FUZZ_CRASH_ON_LARGE_ALLOC")) {                \
294            MOZ_CRASH("Large allocation")do { do { } while (false); MOZ_ReportCrash("" "Large allocation"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
, 294); AnnotateMozCrashReason("MOZ_CRASH(" "Large allocation"
 ")"); do { *((volatile int*)__null) = 294; __attribute__((nomerge
)) ::abort(); } while (false); } while (false);                              \
295          } else {                                                      \
296            return nullptr;                                             \
297          }                                                             \
298        }                                                               \
299      } while (0)
300#  else
301#    define JS_CHECK_LARGE_ALLOC(x)do { } while (0) \
302      do {                          \
303      } while (0)
304#  endif
305 
306namespace js {
307 
308/* Disable OOM testing in sections which are not OOM safe. */
309struct MOZ_RAII JS_PUBLIC_DATA AutoEnterOOMUnsafeRegion {
310  MOZ_NORETURN__attribute__((noreturn)) MOZ_COLD__attribute__((cold)) void crash(const char* reason) { crash_impl(reason); }
311  MOZ_NORETURN__attribute__((noreturn)) MOZ_COLD__attribute__((cold)) void crash(size_t size, const char* reason) {
312    crash_impl(reason);
313  }
314 
315  using AnnotateOOMAllocationSizeCallback = void (*)(size_t);
316  static mozilla::Atomic<AnnotateOOMAllocationSizeCallback, mozilla::Relaxed>
317      annotateOOMSizeCallback;
318  static void setAnnotateOOMAllocationSizeCallback(
319      AnnotateOOMAllocationSizeCallback callback) {
320    annotateOOMSizeCallback = callback;
321  }
322 
323#  if defined(DEBUG1) || defined(JS_OOM_BREAKPOINT)
324  AutoEnterOOMUnsafeRegion()
325      : oomEnabled_(oom::simulator.isThreadSimulatingAny()) {
326    if (oomEnabled_) {
327      MOZ_ALWAYS_TRUE(owner_.compareExchange(nullptr, this))do { if ((__builtin_expect(!!(owner_.compareExchange(nullptr,
 this)), 1))) { } else { do { static_assert( mozilla::detail::
AssertionConditionType<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("false" " (" "owner_.compareExchange(nullptr, this)"
 ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
, 327); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
 ") (" "owner_.compareExchange(nullptr, this)" ")"); do { *((
volatile int*)__null) = 327; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false); } } while (false);
328      oom::simulator.setInUnsafeRegion(true);
329    }
330  }
331 
332  ~AutoEnterOOMUnsafeRegion() {
333    if (oomEnabled_) {
334      oom::simulator.setInUnsafeRegion(false);
335      MOZ_ALWAYS_TRUE(owner_.compareExchange(this, nullptr))do { if ((__builtin_expect(!!(owner_.compareExchange(this, nullptr
)), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType
<decltype(false)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("false" " (" "owner_.compareExchange(this, nullptr)"
 ")", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
, 335); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false"
 ") (" "owner_.compareExchange(this, nullptr)" ")"); do { *((
volatile int*)__null) = 335; __attribute__((nomerge)) ::abort
(); } while (false); } } while (false); } } while (false);
336    }
337  }
338 
339 private:
340  // Used to catch concurrent use from other threads.
341  static mozilla::Atomic<AutoEnterOOMUnsafeRegion*> owner_;
342 
343  bool oomEnabled_;
344#  endif
345 private:
346  static MOZ_NORETURN__attribute__((noreturn)) MOZ_COLD__attribute__((cold)) void crash_impl(const char* reason);
347  static MOZ_NORETURN__attribute__((noreturn)) MOZ_COLD__attribute__((cold)) void crash_impl(size_t size, const char* reason);
348};
349 
350} /* namespace js */
351 
352// Malloc allocation.
353 
354namespace js {
355 
356// The following two arenas require a little bit of clarification. We have
357// observed that, particularly on devices with heterogeneous CPU architectures
358// where background work can run on significantly slower cores than main thread
359// work, the lock contention in the allocator can be a big problem for the
360// main thread. So we introduced an arena for background allocations which can
361// reduce that contention.
362//
363// The general rule for these is: if it's easy to determine at the time of
364// authorship that an allocation will be *off* the main thread, use the
365// BackgroundMallocArena, and vice versa. If it is hard to determine, just make
366// a guess, and that will be fine. Do not spend too much time on this, and
367// don't do anything fancy at runtime to try to determine which to use.
368extern JS_PUBLIC_DATA arena_id_t MallocArena;
369extern JS_PUBLIC_DATA arena_id_t BackgroundMallocArena;
370 
371extern JS_PUBLIC_DATA arena_id_t ArrayBufferContentsArena;
372extern JS_PUBLIC_DATA arena_id_t StringBufferArena;
373 
374extern void InitMallocAllocator();
375extern void ShutDownMallocAllocator();
376 
377// This is a no-op if built without MOZ_MEMORY and MOZ_DEBUG.
378extern void AssertJSStringBufferInCorrectArena(const void* ptr);
379 
380} /* namespace js */
381 
382static inline void* js_arena_malloc(arena_id_t arena, size_t bytes) {
383  JS_OOM_POSSIBLY_FAIL()do { if (js::oom::ShouldFailWithOOM()) return nullptr; } while
 (0);
384  JS_CHECK_LARGE_ALLOC(bytes)do { } while (0);
385  return moz_arena_malloc(arena, bytes);
386}
387 
388static inline void* js_malloc(size_t bytes) {
389  return js_arena_malloc(js::MallocArena, bytes);
390}
391 
392static inline void* js_arena_calloc(arena_id_t arena, size_t bytes) {
393  JS_OOM_POSSIBLY_FAIL()do { if (js::oom::ShouldFailWithOOM()) return nullptr; } while
 (0);
394  JS_CHECK_LARGE_ALLOC(bytes)do { } while (0);
395  return moz_arena_calloc(arena, bytes, 1);
396}
397 
398static inline void* js_arena_calloc(arena_id_t arena, size_t nmemb,
399                                    size_t size) {
400  JS_OOM_POSSIBLY_FAIL()do { if (js::oom::ShouldFailWithOOM()) return nullptr; } while
 (0);
401  JS_CHECK_LARGE_ALLOC(nmemb * size)do { } while (0);
402  return moz_arena_calloc(arena, nmemb, size);
403}
404 
405static inline void* js_calloc(size_t bytes) {
406  return js_arena_calloc(js::MallocArena, bytes);
407}
408 
409static inline void* js_calloc(size_t nmemb, size_t size) {
410  return js_arena_calloc(js::MallocArena, nmemb, size);
411}
412 
413static inline void* js_arena_realloc(arena_id_t arena, void* p, size_t bytes) {
414  // realloc() with zero size is not portable, as some implementations may
415  // return nullptr on success and free |p| for this.  We assume nullptr
416  // indicates failure and that |p| is still valid.
417  MOZ_ASSERT(bytes != 0)do { static_assert( mozilla::detail::AssertionConditionType<
decltype(bytes != 0)>::isValid, "invalid assertion condition"
); if ((__builtin_expect(!!(!(!!(bytes != 0))), 0))) { do { }
 while (false); MOZ_ReportAssertionFailure("bytes != 0", "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
, 417); AnnotateMozCrashReason("MOZ_ASSERT" "(" "bytes != 0" ")"
); do { *((volatile int*)__null) = 417; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
418 
419  JS_OOM_POSSIBLY_FAIL()do { if (js::oom::ShouldFailWithOOM()) return nullptr; } while
 (0);
420  JS_CHECK_LARGE_ALLOC(bytes)do { } while (0);
421  return moz_arena_realloc(arena, p, bytes);
422}
423 
424static inline void* js_realloc(void* p, size_t bytes) {
425  return js_arena_realloc(js::MallocArena, p, bytes);
426}
427 
428static inline void js_free(void* p) {
429  // Bug 1784164: This should call |moz_arena_free(js::MallocArena, p)| but we
430  // currently can't enforce that all memory freed here was allocated by
431  // js_malloc(). All other memory should go through a different allocator and
432  // deallocator.
433  free(p);
23
←
Memory is released→
434}
435#endif /* JS_USE_CUSTOM_ALLOCATOR */
436 
437#include <new>
438 
439/*
440 * [SMDOC] Low-level memory management in SpiderMonkey
441 *
442 *  ** Do not use the standard malloc/free/realloc: SpiderMonkey allows these
443 *     to be redefined (via JS_USE_CUSTOM_ALLOCATOR) and Gecko even #define's
444 *     these symbols.
445 *
446 *  ** Do not use the builtin C++ operator new and delete: these throw on
447 *     error and we cannot override them not to.
448 *
449 * Allocation:
450 *
451 * - If the lifetime of the allocation is tied to the lifetime of a GC-thing
452 *   (that is, finalizing the GC-thing will free the allocation), call one of
453 *   the following functions:
454 *
455 *     JSContext::{pod_malloc,pod_calloc,pod_realloc}
456 *     Zone::{pod_malloc,pod_calloc,pod_realloc}
457 *
458 *   These functions accumulate the number of bytes allocated which is used as
459 *   part of the GC-triggering heuristics.
460 *
461 *   The difference between the JSContext and Zone versions is that the
462 *   cx version report an out-of-memory error on OOM. (This follows from the
463 *   general SpiderMonkey idiom that a JSContext-taking function reports its
464 *   own errors.)
465 *
466 *   If you don't want to report an error on failure, there are maybe_ versions
467 *   of these methods available too, e.g. maybe_pod_malloc.
468 *
469 *   The methods above use templates to allow allocating memory suitable for an
470 *   array of a given type and number of elements. There are _with_extra
471 *   versions to allow allocating an area of memory which is larger by a
472 *   specified number of bytes, e.g. pod_malloc_with_extra.
473 *
474 *   These methods are available on a JSRuntime, but calling them is
475 *   discouraged. Memory attributed to a runtime can only be reclaimed by full
476 *   GCs, and we try to avoid those where possible.
477 *
478 * - Otherwise, use js_malloc/js_realloc/js_calloc/js_new
479 *
480 * Deallocation:
481 *
482 * - Ordinarily, use js_free/js_delete.
483 *
484 * - For deallocations during GC finalization, use one of the following
485 *   operations on the JS::GCContext provided to the finalizer:
486 *
487 *     JS::GCContext::{free_,delete_}
488 */
489 
490/*
491 * Given a class which should provide a 'new' method, add
492 * JS_DECLARE_NEW_METHODS (see js::MallocProvider for an example).
493 *
494 * Note: Do not add a ; at the end of a use of JS_DECLARE_NEW_METHODS,
495 * or the build will break.
496 */
497#define JS_DECLARE_NEW_METHODS(NEWNAME, ALLOCATOR, QUALIFIERS)template <class T, typename... Args> QUALIFIERS T* NEWNAME
(Args&&... args) { static_assert( alignof(T) <= alignof
(max_align_t), "over-aligned type is not supported by JS_DECLARE_NEW_METHODS"
); void* memory = ALLOCATOR(sizeof(T)); return (__builtin_expect
(!!(memory), 1)) ? new (memory) T(std::forward<Args>(args
)...) : nullptr; }              \
498  template <class T, typename... Args>                                      \
499  QUALIFIERS T* MOZ_HEAP_ALLOCATOR NEWNAME(Args&&... args) {                \
500    static_assert(                                                          \
501        alignof(T) <= alignof(max_align_t),                                 \
502        "over-aligned type is not supported by JS_DECLARE_NEW_METHODS");    \
503    void* memory = ALLOCATOR(sizeof(T));                                    \
504    return MOZ_LIKELY(memory)(__builtin_expect(!!(memory), 1)) ? new (memory) T(std::forward<Args>(args)...) \
505                              : nullptr;                                    \
506  }
507 
508/*
509 * Given a class which should provide a 'new' method that takes an arena as
510 * its first argument, add JS_DECLARE_NEW_ARENA_METHODS
511 * (see js::MallocProvider for an example).
512 *
513 * Note: Do not add a ; at the end of a use of JS_DECLARE_NEW_ARENA_METHODS,
514 * or the build will break.
515 */
516#define JS_DECLARE_NEW_ARENA_METHODS(NEWNAME, ALLOCATOR, QUALIFIERS)template <class T, typename... Args> QUALIFIERS T* NEWNAME
(arena_id_t arena, Args&&... args) { static_assert( alignof
(T) <= alignof(max_align_t), "over-aligned type is not supported by JS_DECLARE_NEW_ARENA_METHODS"
); void* memory = ALLOCATOR(arena, sizeof(T)); return (__builtin_expect
(!!(memory), 1)) ? new (memory) T(std::forward<Args>(args
)...) : nullptr; }           \
517  template <class T, typename... Args>                                         \
518  QUALIFIERS T* MOZ_HEAP_ALLOCATOR NEWNAME(arena_id_t arena, Args&&... args) { \
519    static_assert(                                                             \
520        alignof(T) <= alignof(max_align_t),                                    \
521        "over-aligned type is not supported by JS_DECLARE_NEW_ARENA_METHODS"); \
522    void* memory = ALLOCATOR(arena, sizeof(T));                                \
523    return MOZ_LIKELY(memory)(__builtin_expect(!!(memory), 1)) ? new (memory) T(std::forward<Args>(args)...)    \
524                              : nullptr;                                       \
525  }
526 
527/*
528 * Given a class which should provide 'make' methods, add
529 * JS_DECLARE_MAKE_METHODS (see js::MallocProvider for an example).  This
530 * method is functionally the same as JS_DECLARE_NEW_METHODS: it just declares
531 * methods that return mozilla::UniquePtr instances that will singly-manage
532 * ownership of the created object.
533 *
534 * Note: Do not add a ; at the end of a use of JS_DECLARE_MAKE_METHODS,
535 * or the build will break.
536 */
537#define JS_DECLARE_MAKE_METHODS(MAKENAME, NEWNAME, QUALIFIERS)template <class T, typename... Args> QUALIFIERS mozilla
::UniquePtr<T, JS::DeletePolicy<T>> MAKENAME(Args
&&... args) { T* ptr = NEWNAME<T>(std::forward<
Args>(args)...); return mozilla::UniquePtr<T, JS::DeletePolicy
<T>>(ptr); }             \
538  template <class T, typename... Args>                                     \
539  QUALIFIERS mozilla::UniquePtr<T, JS::DeletePolicy<T>> MOZ_HEAP_ALLOCATOR \
540  MAKENAME(Args&&... args) {                                               \
541    T* ptr = NEWNAME<T>(std::forward<Args>(args)...);                      \
542    return mozilla::UniquePtr<T, JS::DeletePolicy<T>>(ptr);                \
543  }
544 
545JS_DECLARE_NEW_METHODS(js_new, js_malloc, static MOZ_ALWAYS_INLINE)template <class T, typename... Args> static inline T* js_new
(Args&&... args) { static_assert( alignof(T) <= alignof
(max_align_t), "over-aligned type is not supported by JS_DECLARE_NEW_METHODS"
); void* memory = js_malloc(sizeof(T)); return (__builtin_expect
(!!(memory), 1)) ? new (memory) T(std::forward<Args>(args
)...) : nullptr; }
546JS_DECLARE_NEW_ARENA_METHODS(js_arena_new, js_arena_malloc,template <class T, typename... Args> static inline T* js_arena_new
(arena_id_t arena, Args&&... args) { static_assert( alignof
(T) <= alignof(max_align_t), "over-aligned type is not supported by JS_DECLARE_NEW_ARENA_METHODS"
); void* memory = js_arena_malloc(arena, sizeof(T)); return (
__builtin_expect(!!(memory), 1)) ? new (memory) T(std::forward
<Args>(args)...) : nullptr; }
547                             static MOZ_ALWAYS_INLINE)template <class T, typename... Args> static inline T* js_arena_new
(arena_id_t arena, Args&&... args) { static_assert( alignof
(T) <= alignof(max_align_t), "over-aligned type is not supported by JS_DECLARE_NEW_ARENA_METHODS"
); void* memory = js_arena_malloc(arena, sizeof(T)); return (
__builtin_expect(!!(memory), 1)) ? new (memory) T(std::forward
<Args>(args)...) : nullptr; }
548 
549namespace js {
550 
551/*
552 * Calculate the number of bytes needed to allocate |numElems| contiguous
553 * instances of type |T|.  Return false if the calculation overflowed.
554 */
555template <typename T>
556[[nodiscard]] inline bool CalculateAllocSize(size_t numElems,
557                                             size_t* bytesOut) {
558  *bytesOut = numElems * sizeof(T);
559  return (numElems & mozilla::tl::MulOverflowMask<sizeof(T)>::value) == 0;
560}
561 
562/*
563 * Calculate the number of bytes needed to allocate a single instance of type
564 * |T| followed by |numExtra| contiguous instances of type |Extra|.  Return
565 * false if the calculation overflowed.
566 */
567template <typename T, typename Extra>
568[[nodiscard]] inline bool CalculateAllocSizeWithExtra(size_t numExtra,
569                                                      size_t* bytesOut) {
570  *bytesOut = sizeof(T) + numExtra * sizeof(Extra);
571  return (numExtra & mozilla::tl::MulOverflowMask<sizeof(Extra)>::value) == 0 &&
572         *bytesOut >= sizeof(T);
573}
574 
575} /* namespace js */
576 
577template <class T>
578static MOZ_ALWAYS_INLINEinline void js_delete(const T* p) {
579  if (p) {
580    p->~T();
581    js_free(const_cast<T*>(p));
582  }
583}
584 
585template <class T>
586static MOZ_ALWAYS_INLINEinline void js_delete_poison(const T* p) {
587  if (p) {
588    p->~T();
589    memset(static_cast<void*>(const_cast<T*>(p)), 0x3B, sizeof(T));
590    js_free(const_cast<T*>(p));
591  }
592}
593 
594template <class T>
595static MOZ_ALWAYS_INLINEinline T* js_pod_arena_malloc(arena_id_t arena,
596                                                size_t numElems) {
597  size_t bytes;
598  if (MOZ_UNLIKELY(!js::CalculateAllocSize<T>(numElems, &bytes))(__builtin_expect(!!(!js::CalculateAllocSize<T>(numElems
, &bytes)), 0))) {
599    return nullptr;
600  }
601  return static_cast<T*>(js_arena_malloc(arena, bytes));
602}
603 
604template <class T>
605static MOZ_ALWAYS_INLINEinline T* js_pod_malloc(size_t numElems) {
606  return js_pod_arena_malloc<T>(js::MallocArena, numElems);
607}
608 
609template <class T>
610static MOZ_ALWAYS_INLINEinline T* js_pod_arena_calloc(arena_id_t arena,
611                                                size_t numElems) {
612  size_t bytes;
613  if (MOZ_UNLIKELY(!js::CalculateAllocSize<T>(numElems, &bytes))(__builtin_expect(!!(!js::CalculateAllocSize<T>(numElems
, &bytes)), 0))) {
614    return nullptr;
615  }
616  return static_cast<T*>(js_arena_calloc(arena, bytes, 1));
617}
618 
619template <class T>
620static MOZ_ALWAYS_INLINEinline T* js_pod_calloc(size_t numElems) {
621  return js_pod_arena_calloc<T>(js::MallocArena, numElems);
622}
623 
624template <class T>
625static MOZ_ALWAYS_INLINEinline T* js_pod_arena_realloc(arena_id_t arena, T* prior,
626                                                 size_t oldSize,
627                                                 size_t newSize) {
628  MOZ_ASSERT(!(oldSize & mozilla::tl::MulOverflowMask<sizeof(T)>::value))do { static_assert( mozilla::detail::AssertionConditionType<
decltype(!(oldSize & mozilla::tl::MulOverflowMask<sizeof
(T)>::value))>::isValid, "invalid assertion condition")
; if ((__builtin_expect(!!(!(!!(!(oldSize & mozilla::tl::
MulOverflowMask<sizeof(T)>::value)))), 0))) { do { } while
 (false); MOZ_ReportAssertionFailure("!(oldSize & mozilla::tl::MulOverflowMask<sizeof(T)>::value)"
, "/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/js/Utility.h"
, 628); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!(oldSize & mozilla::tl::MulOverflowMask<sizeof(T)>::value)"
 ")"); do { *((volatile int*)__null) = 628; __attribute__((nomerge
)) ::abort(); } while (false); } } while (false);
629  size_t bytes;
630  if (MOZ_UNLIKELY(!js::CalculateAllocSize<T>(newSize, &bytes))(__builtin_expect(!!(!js::CalculateAllocSize<T>(newSize
, &bytes)), 0))) {
631    return nullptr;
632  }
633  return static_cast<T*>(js_arena_realloc(arena, prior, bytes));
634}
635 
636template <class T>
637static MOZ_ALWAYS_INLINEinline T* js_pod_realloc(T* prior, size_t oldSize,
638                                           size_t newSize) {
639  return js_pod_arena_realloc<T>(js::MallocArena, prior, oldSize, newSize);
640}
641 
642namespace JS {
643 
644template <typename T>
645struct DeletePolicy {
646  constexpr DeletePolicy() = default;
647 
648  template <typename U>
649  MOZ_IMPLICIT DeletePolicy(
650      DeletePolicy<U> other,
651      std::enable_if_t<std::is_convertible_v<U*, T*>, int> dummy = 0) {}
652 
653  void operator()(const T* ptr) { js_delete(const_cast<T*>(ptr)); }
654};
655 
656struct FreePolicy {
657  void operator()(const void* ptr) { js_free(const_cast<void*>(ptr)); }
658};
659 
660using UniqueChars = mozilla::UniquePtr<char[], JS::FreePolicy>;
661using UniqueTwoByteChars = mozilla::UniquePtr<char16_t[], JS::FreePolicy>;
662using UniqueLatin1Chars = mozilla::UniquePtr<JS::Latin1Char[], JS::FreePolicy>;
663using UniqueWideChars = mozilla::UniquePtr<wchar_t[], JS::FreePolicy>;
664 
665}  // namespace JS
666 
667/* sixgill annotation defines */
668#ifndef HAVE_STATIC_ANNOTATIONS
669#  define HAVE_STATIC_ANNOTATIONS
670#  ifdef XGILL_PLUGIN
671#    define STATIC_PRECONDITION(COND) __attribute__((precondition(#COND)))
672#    define STATIC_PRECONDITION_ASSUME(COND) \
673      __attribute__((precondition_assume(#COND)))
674#    define STATIC_POSTCONDITION(COND) __attribute__((postcondition(#COND)))
675#    define STATIC_POSTCONDITION_ASSUME(COND) \
676      __attribute__((postcondition_assume(#COND)))
677#    define STATIC_INVARIANT(COND) __attribute__((invariant(#COND)))
678#    define STATIC_INVARIANT_ASSUME(COND) \
679      __attribute__((invariant_assume(#COND)))
680#    define STATIC_ASSUME(COND)do { } while (0)                                          \
681      JS_BEGIN_MACROdo {                                                     \
682        __attribute__((assume_static(#COND), unused)) int STATIC_PASTE1( \
683            assume_static_, __COUNTER__0);                                \
684      JS_END_MACRO} while (0)
685#  else                                       /* XGILL_PLUGIN */
686#    define STATIC_PRECONDITION(COND)         /* nothing */
687#    define STATIC_PRECONDITION_ASSUME(COND)  /* nothing */
688#    define STATIC_POSTCONDITION(COND)        /* nothing */
689#    define STATIC_POSTCONDITION_ASSUME(COND) /* nothing */
690#    define STATIC_INVARIANT(COND)            /* nothing */
691#    define STATIC_INVARIANT_ASSUME(COND)     /* nothing */
692#    define STATIC_ASSUME(COND)do { } while (0)    \
693      JS_BEGIN_MACROdo { /* nothing */ \
694      JS_END_MACRO} while (0)
695#  endif /* XGILL_PLUGIN */
696#  define STATIC_SKIP_INFERENCE STATIC_INVARIANT(skip_inference())
697#endif /* HAVE_STATIC_ANNOTATIONS */
698 
699#endif /* js_Utility_h */

←

/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/mozilla/MaybeStorageBase.h

1/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2/* vim: set ts=8 sts=2 et sw=2 tw=80: */
3/* 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/. */

7/* Internal storage class used e.g. by Maybe and Result. This file doesn't
* contain any public declarations. */

10#ifndef mfbt_MaybeStorageBase_h
11#define mfbt_MaybeStorageBase_h

13#include <type_traits>
14#include <utility>

16namespace mozilla::detail {

18template <typename T>
19constexpr bool IsTriviallyDestructibleAndCopyable =
  std::is_trivially_destructible_v<T> &&
  (std::is_trivially_copy_constructible_v<T> ||
   !std::is_copy_constructible_v<T>);

24template <typename T, bool TriviallyDestructibleAndCopyable =
                        IsTriviallyDestructibleAndCopyable<T>>
26struct MaybeStorageBase;

28template <typename T>
29struct MaybeStorageBase<T, false> {
protected:
using NonConstT = std::remove_const_t<T>;

union Union {
  Union() {}
  explicit Union(const T& aVal) : val{aVal} {}
  template <typename U,
            typename = std::enable_if_t<std::is_move_constructible_v<U>>>
  explicit Union(U&& aVal) : val{std::forward<U>(aVal)} {}
  template <typename... Args>
  explicit Union(std::in_place_t, Args&&... aArgs)
      : val{std::forward<Args>(aArgs)...} {}

  ~Union() {}
33
←
Calling implicit destructor for 'ShortestPaths'→
34
←
Calling implicit destructor for 'HashMap<JS::ubi::Node, mozilla::Vector<mozilla::UniquePtr<JS::ubi::BackEdge, JS::DeletePolicy<JS::ubi::BackEdge>>, 0, js::SystemAllocPolicy>, mozilla::DefaultHasher<JS::ubi::Node>, js::SystemAllocPolicy>'→
35
←
Calling '~HashTable'→

  NonConstT val;
} mStorage;

public:
MaybeStorageBase() = default;
explicit MaybeStorageBase(const T& aVal) : mStorage{aVal} {}
explicit MaybeStorageBase(T&& aVal) : mStorage{std::move(aVal)} {}
template <typename... Args>
explicit MaybeStorageBase(std::in_place_t, Args&&... aArgs)
    : mStorage{std::in_place, std::forward<Args>(aArgs)...} {}

const T* addr() const { return &mStorage.val; }
T* addr() { return &mStorage.val; }
58};

60template <typename T>
61struct MaybeStorageBase<T, true> {
protected:
using NonConstT = std::remove_const_t<T>;

union Union {
  constexpr Union() : dummy() {}
  constexpr explicit Union(const T& aVal) : val{aVal} {}
  constexpr explicit Union(T&& aVal) : val{std::move(aVal)} {}
  template <typename... Args>
  constexpr explicit Union(std::in_place_t, Args&&... aArgs)
      : val{std::forward<Args>(aArgs)...} {}

  NonConstT val;
  char dummy;
} mStorage;

public:
constexpr MaybeStorageBase() = default;
constexpr explicit MaybeStorageBase(const T& aVal) : mStorage{aVal} {}
constexpr explicit MaybeStorageBase(T&& aVal) : mStorage{std::move(aVal)} {}

template <typename... Args>
constexpr explicit MaybeStorageBase(std::in_place_t, Args&&... aArgs)
    : mStorage{std::in_place, std::forward<Args>(aArgs)...} {}

constexpr const T* addr() const { return &mStorage.val; }
constexpr T* addr() { return &mStorage.val; }
88};

90}  // namespace mozilla::detail

92#endif