../deps/v8/src/handles/global-handles.cc

Bug Summary

File:	out/../deps/v8/src/handles/global-handles.cc
Warning:	line 684, column 45 1st function call argument is an uninitialized value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name global-handles.cc -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 -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D V8_GYP_BUILD -D V8_TYPED_ARRAY_MAX_SIZE_IN_HEAP=64 -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D V8_TARGET_ARCH_X64 -D V8_HAVE_TARGET_OS -D V8_TARGET_OS_LINUX -D V8_EMBEDDER_STRING="-node.8" -D ENABLE_DISASSEMBLER -D V8_PROMISE_INTERNAL_FIELD_COUNT=1 -D V8_SHORT_BUILTIN_CALLS -D OBJECT_PRINT -D V8_INTL_SUPPORT -D V8_ATOMIC_OBJECT_FIELD_WRITES -D V8_ENABLE_LAZY_SOURCE_POSITIONS -D V8_USE_SIPHASH -D V8_SHARED_RO_HEAP -D V8_WIN64_UNWINDING_INFO -D V8_ENABLE_REGEXP_INTERPRETER_THREADED_DISPATCH -D V8_SNAPSHOT_COMPRESSION -D V8_ENABLE_WEBASSEMBLY -D V8_ENABLE_JAVASCRIPT_PROMISE_HOOKS -D V8_ALLOCATION_FOLDING -D V8_ALLOCATION_SITE_TRACKING -D V8_SCRIPTORMODULE_LEGACY_LIFETIME -D V8_ADVANCED_BIGINT_ALGORITHMS -D ICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_STATIC -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_STATIC_IMPLEMENTATION=1 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/v8 -I ../deps/v8/include -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/inspector-generated-output-root -I ../deps/v8/third_party/inspector_protocol -I /home/maurizio/node-v18.6.0/out/Release/obj/gen -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/generate-bytecode-output-root -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/common -I ../deps/v8/third_party/zlib -I ../deps/v8/third_party/zlib/google -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-return-type -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/v8/src/handles/global-handles.cc
1// Copyright 2009 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.

5#include "src/handles/global-handles.h"

7#include <algorithm>
8#include <atomic>
9#include <climits>
10#include <cstdint>
11#include <map>

13#include "include/v8-traced-handle.h"
14#include "src/api/api-inl.h"
15#include "src/base/bits.h"
16#include "src/base/compiler-specific.h"
17#include "src/base/sanitizer/asan.h"
18#include "src/common/allow-deprecated.h"
19#include "src/common/globals.h"
20#include "src/execution/vm-state-inl.h"
21#include "src/heap/base/stack.h"
22#include "src/heap/embedder-tracing.h"
23#include "src/heap/heap-inl.h"
24#include "src/heap/heap-write-barrier-inl.h"
25#include "src/heap/heap-write-barrier.h"
26#include "src/init/v8.h"
27#include "src/logging/counters.h"
28#include "src/objects/objects-inl.h"
29#include "src/objects/slots.h"
30#include "src/objects/visitors.h"
31#include "src/tasks/cancelable-task.h"
32#include "src/tasks/task-utils.h"
33#include "src/utils/utils.h"

35namespace v8 {
36namespace internal {

38namespace {

40constexpr size_t kBlockSize = 256;

42}  // namespace

44template <class _NodeType>
45class GlobalHandles::NodeBlock final {
public:
using BlockType = NodeBlock<_NodeType>;
using NodeType = _NodeType;

V8_INLINEinline __attribute__((always_inline)) static const NodeBlock* From(const NodeType* node);
V8_INLINEinline __attribute__((always_inline)) static NodeBlock* From(NodeType* node);

NodeBlock(GlobalHandles* global_handles,
          GlobalHandles::NodeSpace<NodeType>* space,
          NodeBlock* next) V8_NOEXCEPTnoexcept : next_(next),
                                         global_handles_(global_handles),
                                         space_(space) {}

NodeBlock(const NodeBlock&) = delete;
NodeBlock& operator=(const NodeBlock&) = delete;

NodeType* at(size_t index) { return &nodes_[index]; }
const NodeType* at(size_t index) const { return &nodes_[index]; }
GlobalHandles::NodeSpace<NodeType>* space() const { return space_; }
GlobalHandles* global_handles() const { return global_handles_; }

V8_INLINEinline __attribute__((always_inline)) bool IncreaseUsage();
V8_INLINEinline __attribute__((always_inline)) bool DecreaseUsage();

V8_INLINEinline __attribute__((always_inline)) void ListAdd(NodeBlock** top);
V8_INLINEinline __attribute__((always_inline)) void ListRemove(NodeBlock** top);

NodeBlock* next() const { return next_; }
NodeBlock* next_used() const { return next_used_; }

void set_markbit(size_t index) {
  const auto [cell, bit] = CellAndBit(index);
  reinterpret_cast<std::atomic<CellType>&>(mark_bits_[cell])
      .fetch_or(CellType{1} << bit, std::memory_order_relaxed);
}

void clear_markbit(size_t index) {
  const auto [cell, bit] = CellAndBit(index);
  mark_bits_[cell] &= ~(CellType{1} << bit);
}

bool markbit(size_t index) const {
  const auto [cell, bit] = CellAndBit(index);
  return mark_bits_[cell] & CellType{1} << bit;
}

private:
using CellType = uint32_t;

std::tuple<CellType, CellType> CellAndBit(size_t index) const {
  static constexpr CellType kMarkBitCellSizeLog2 = 5;
  static_assert(base::bits::IsPowerOfTwo(kBlockSize),
                "Block size must be power of two.");
  static_assert(
      sizeof(CellType) * CHAR_BIT8 == (CellType{1} << kMarkBitCellSizeLog2),
      "Markbit CellType not matching defined log2 size.");
  static constexpr CellType kCellMask =
      (CellType{1} << kMarkBitCellSizeLog2) - 1;
  return {static_cast<CellType>(index >> kMarkBitCellSizeLog2),
          index & kCellMask};
}

NodeType nodes_[kBlockSize];
NodeBlock* const next_;
GlobalHandles* const global_handles_;
GlobalHandles::NodeSpace<NodeType>* const space_;
NodeBlock* next_used_ = nullptr;
NodeBlock* prev_used_ = nullptr;
uint32_t used_nodes_ = 0;
CellType mark_bits_[kBlockSize / (sizeof(CellType) * CHAR_BIT8)] = {0};
116};

118template <class NodeType>
119const GlobalHandles::NodeBlock<NodeType>*
120GlobalHandles::NodeBlock<NodeType>::From(const NodeType* node) {
const NodeType* firstNode = node - node->index();
const BlockType* block = reinterpret_cast<const BlockType*>(firstNode);
DCHECK_EQ(node, block->at(node->index()))((void) 0);
return block;
125}

127template <class NodeType>
128GlobalHandles::NodeBlock<NodeType>* GlobalHandles::NodeBlock<NodeType>::From(
  NodeType* node) {
NodeType* firstNode = node - node->index();
BlockType* block = reinterpret_cast<BlockType*>(firstNode);
DCHECK_EQ(node, block->at(node->index()))((void) 0);
return block;
134}

136template <class NodeType>
137bool GlobalHandles::NodeBlock<NodeType>::IncreaseUsage() {
DCHECK_LT(used_nodes_, kBlockSize)((void) 0);
return used_nodes_++ == 0;
140}

142template <class NodeType>
143void GlobalHandles::NodeBlock<NodeType>::ListAdd(BlockType** top) {
BlockType* old_top = *top;
*top = this;
next_used_ = old_top;
prev_used_ = nullptr;
if (old_top != nullptr) {
  old_top->prev_used_ = this;
}
151}

153template <class NodeType>
154bool GlobalHandles::NodeBlock<NodeType>::DecreaseUsage() {
DCHECK_GT(used_nodes_, 0)((void) 0);
return --used_nodes_ == 0;
157}

159template <class NodeType>
160void GlobalHandles::NodeBlock<NodeType>::ListRemove(BlockType** top) {
if (next_used_ != nullptr) next_used_->prev_used_ = prev_used_;
if (prev_used_ != nullptr) prev_used_->next_used_ = next_used_;
if (this == *top) {
  *top = next_used_;
}
166}

168template <class BlockType>
169class GlobalHandles::NodeIterator final {
public:
using NodeType = typename BlockType::NodeType;

// Iterator traits.
using iterator_category = std::forward_iterator_tag;
using difference_type = std::ptrdiff_t;
using value_type = NodeType*;
using reference = value_type;
using pointer = value_type*;

explicit NodeIterator(BlockType* block) V8_NOEXCEPTnoexcept : block_(block) {}
NodeIterator(NodeIterator&& other) V8_NOEXCEPTnoexcept : block_(other.block_),
                                                 index_(other.index_) {}

NodeIterator(const NodeIterator&) = delete;
NodeIterator& operator=(const NodeIterator&) = delete;

bool operator==(const NodeIterator& other) const {
  return block_ == other.block_;
}
bool operator!=(const NodeIterator& other) const {
  return block_ != other.block_;
}

NodeIterator& operator++() {
  if (++index_ < kBlockSize) return *this;
  index_ = 0;
  block_ = block_->next_used();
  return *this;
}

NodeType* operator*() { return block_->at(index_); }
NodeType* operator->() { return block_->at(index_); }

private:
BlockType* block_ = nullptr;
size_t index_ = 0;
207};

209template <class NodeType>
210class GlobalHandles::NodeSpace final {
public:
using BlockType = NodeBlock<NodeType>;
using iterator = NodeIterator<BlockType>;

static NodeSpace* From(NodeType* node);
static void Release(NodeType* node);

explicit NodeSpace(GlobalHandles* global_handles) V8_NOEXCEPTnoexcept
    : global_handles_(global_handles) {}
~NodeSpace();

V8_INLINEinline __attribute__((always_inline)) NodeType* Acquire(Object object);

iterator begin() { return iterator(first_used_block_); }
iterator end() { return iterator(nullptr); }

size_t TotalSize() const { return blocks_ * sizeof(NodeType) * kBlockSize; }
size_t handles_count() const { return handles_count_; }

private:
void PutNodesOnFreeList(BlockType* block);
V8_INLINEinline __attribute__((always_inline)) void Free(NodeType* node);

GlobalHandles* const global_handles_;
BlockType* first_block_ = nullptr;
BlockType* first_used_block_ = nullptr;
NodeType* first_free_ = nullptr;
size_t blocks_ = 0;
size_t handles_count_ = 0;
240};

242template <class NodeType>
243GlobalHandles::NodeSpace<NodeType>::~NodeSpace() {
auto* block = first_block_;
while (block != nullptr) {
  auto* tmp = block->next();
  delete block;
  block = tmp;
}
250}

252template <class NodeType>
253NodeType* GlobalHandles::NodeSpace<NodeType>::Acquire(Object object) {
if (first_free_ == nullptr) {
  first_block_ = new BlockType(global_handles_, this, first_block_);
  blocks_++;
  PutNodesOnFreeList(first_block_);
}
DCHECK_NOT_NULL(first_free_)((void) 0);
NodeType* node = first_free_;
first_free_ = first_free_->next_free();
node->Acquire(object);
BlockType* block = BlockType::From(node);
if (block->IncreaseUsage()) {
  block->ListAdd(&first_used_block_);
}
global_handles_->isolate()->counters()->global_handles()->Increment();
handles_count_++;
DCHECK(node->IsInUse())((void) 0);
return node;
271}

273template <class NodeType>
274void GlobalHandles::NodeSpace<NodeType>::PutNodesOnFreeList(BlockType* block) {
for (int32_t i = kBlockSize - 1; i >= 0; --i) {
  NodeType* node = block->at(i);
  const uint8_t index = static_cast<uint8_t>(i);
  DCHECK_EQ(i, index)((void) 0);
  node->set_index(index);
  node->Free(first_free_);
  first_free_ = node;
}
283}

285template <class NodeType>
286void GlobalHandles::NodeSpace<NodeType>::Release(NodeType* node) {
BlockType* block = BlockType::From(node);
block->space()->Free(node);
289}

291template <class NodeType>
292void GlobalHandles::NodeSpace<NodeType>::Free(NodeType* node) {
node->Release(first_free_);
first_free_ = node;
BlockType* block = BlockType::From(node);
if (block->DecreaseUsage()) {
  block->ListRemove(&first_used_block_);
}
global_handles_->isolate()->counters()->global_handles()->Decrement();
handles_count_--;
301}

303template <class Child>
304class NodeBase {
public:
static const Child* FromLocation(const Address* location) {
  return reinterpret_cast<const Child*>(location);
}

static Child* FromLocation(Address* location) {
  return reinterpret_cast<Child*>(location);
}

NodeBase() {
  DCHECK_EQ(offsetof(NodeBase, object_), 0)((void) 0);
  DCHECK_EQ(offsetof(NodeBase, class_id_), Internals::kNodeClassIdOffset)((void) 0);
  DCHECK_EQ(offsetof(NodeBase, flags_), Internals::kNodeFlagsOffset)((void) 0);
}
11
←
Returning without writing to 'this->flags_'→

320#ifdef ENABLE_HANDLE_ZAPPING
~NodeBase() {
  ClearFields();
  data_.next_free = nullptr;
  index_ = 0;
}
326#endif

void Free(Child* free_list) {
  ClearFields();
  AsChild()->MarkAsFree();
  data_.next_free = free_list;
}

void Acquire(Object object) {
  DCHECK(!AsChild()->IsInUse())((void) 0);
  CheckFieldsAreCleared();
  reinterpret_cast<std::atomic<Address>*>(&object_)->store(
      object.ptr(), std::memory_order_relaxed);
  AsChild()->MarkAsUsed();
  data_.parameter = nullptr;
  DCHECK(AsChild()->IsInUse())((void) 0);
}

void Release(Child* free_list) {
  DCHECK(AsChild()->IsInUse())((void) 0);
  Free(free_list);
  DCHECK(!AsChild()->IsInUse())((void) 0);
}

Object object() const { return Object(object_); }
FullObjectSlot location() { return FullObjectSlot(&object_); }
Handle<Object> handle() { return Handle<Object>(&object_); }

uint8_t index() const { return index_; }
void set_index(uint8_t value) { index_ = value; }

uint16_t wrapper_class_id() const { return class_id_; }
bool has_wrapper_class_id() const {
  return class_id_ != v8::HeapProfiler::kPersistentHandleNoClassId;
}

// Accessors for next free node in the free list.
Child* next_free() {
  DCHECK(!AsChild()->IsInUse())((void) 0);
  return data_.next_free;
}

void set_parameter(void* parameter) {
  DCHECK(AsChild()->IsInUse())((void) 0);
  data_.parameter = parameter;
}
void* parameter() const {
  DCHECK(AsChild()->IsInUse())((void) 0);
  return data_.parameter;
}

protected:
Child* AsChild() { return reinterpret_cast<Child*>(this); }
const Child* AsChild() const { return reinterpret_cast<const Child*>(this); }

void ClearFields() {
  // Zap the values for eager trapping.
  object_ = kGlobalHandleZapValue;
  class_id_ = v8::HeapProfiler::kPersistentHandleNoClassId;
  AsChild()->ClearImplFields();
}

void CheckFieldsAreCleared() {
  DCHECK_EQ(kGlobalHandleZapValue, object_)((void) 0);
  DCHECK_EQ(v8::HeapProfiler::kPersistentHandleNoClassId, class_id_)((void) 0);
  AsChild()->CheckImplFieldsAreCleared();
}

// Storage for object pointer.
//
// Placed first to avoid offset computation. The stored data is equivalent to
// an Object. It is stored as a plain Address for convenience (smallest number
// of casts), and because it is a private implementation detail: the public
// interface provides type safety.
Address object_;

// Class id set by the embedder.
uint16_t class_id_;

// Index in the containing handle block.
uint8_t index_;

uint8_t flags_;

// The meaning of this field depends on node state:
// - Node in free list: Stores next free node pointer.
// - Otherwise, specific to the node implementation.
union {
  Child* next_free;
  void* parameter;
} data_;
417};

419namespace {

421void ExtractInternalFields(JSObject jsobject, void** embedder_fields, int len) {
int field_count = jsobject.GetEmbedderFieldCount();
Isolate* isolate = GetIsolateForSandbox(jsobject);
for (int i = 0; i < len; ++i) {
  if (field_count == i) break;
  void* pointer;
  if (EmbedderDataSlot(jsobject, i).ToAlignedPointer(isolate, &pointer)) {
    embedder_fields[i] = pointer;
  }
}
431}

433}  // namespace

435class GlobalHandles::Node final : public NodeBase<GlobalHandles::Node> {
public:
// State transition diagram:
// FREE -> NORMAL <-> WEAK -> PENDING -> NEAR_DEATH -> { NORMAL, WEAK, FREE }
enum State {
  FREE = 0,
  NORMAL,      // Normal global handle.
  WEAK,        // Flagged as weak but not yet finalized.
  PENDING,     // Has been recognized as only reachable by weak handles.
  NEAR_DEATH,  // Callback has informed the handle is near death.
  NUMBER_OF_NODE_STATES
};

Node() {
  STATIC_ASSERT(static_cast<int>(NodeState::kMask) ==static_assert(static_cast<int>(NodeState::kMask) == Internals
::kNodeStateMask, "static_cast<int>(NodeState::kMask) == Internals::kNodeStateMask"
)
                Internals::kNodeStateMask)static_assert(static_cast<int>(NodeState::kMask) == Internals
::kNodeStateMask, "static_cast<int>(NodeState::kMask) == Internals::kNodeStateMask"
);
  STATIC_ASSERT(WEAK == Internals::kNodeStateIsWeakValue)static_assert(WEAK == Internals::kNodeStateIsWeakValue, "WEAK == Internals::kNodeStateIsWeakValue"
);
  STATIC_ASSERT(PENDING == Internals::kNodeStateIsPendingValue)static_assert(PENDING == Internals::kNodeStateIsPendingValue,
 "PENDING == Internals::kNodeStateIsPendingValue");
  set_in_young_list(false);
}

Node(const Node&) = delete;
Node& operator=(const Node&) = delete;

const char* label() const {
  return state() == NORMAL ? reinterpret_cast<char*>(data_.parameter)
                           : nullptr;
}

// State and flag accessors.

State state() const { return NodeState::decode(flags_); }
void set_state(State state) { flags_ = NodeState::update(flags_, state); }

bool is_in_young_list() const { return IsInYoungList::decode(flags_); }
void set_in_young_list(bool v) { flags_ = IsInYoungList::update(flags_, v); }

WeaknessType weakness_type() const {
  return NodeWeaknessType::decode(flags_);
}
void set_weakness_type(WeaknessType weakness_type) {
  flags_ = NodeWeaknessType::update(flags_, weakness_type);
}

bool IsWeak() const { return state() == WEAK; }

bool IsInUse() const { return state() != FREE; }

bool IsPhantomCallback() const {
  return weakness_type() == PHANTOM_WEAK ||
         weakness_type() == PHANTOM_WEAK_2_EMBEDDER_FIELDS;
}

bool IsPhantomResetHandle() const {
  return weakness_type() == PHANTOM_WEAK_RESET_HANDLE;
}

bool IsFinalizerHandle() const { return weakness_type() == FINALIZER_WEAK; }

bool IsPendingPhantomCallback() const {
  return state() == PENDING && IsPhantomCallback();
}

bool IsPendingPhantomResetHandle() const {
  return state() == PENDING && IsPhantomResetHandle();
}

bool IsPendingFinalizer() const {
  return state() == PENDING && weakness_type() == FINALIZER_WEAK;
}

bool IsPending() const { return state() == PENDING; }

bool IsRetainer() const {
  return state() != FREE &&
         !(state() == NEAR_DEATH && weakness_type() != FINALIZER_WEAK);
}

bool IsStrongRetainer() const { return state() == NORMAL; }

bool IsWeakRetainer() const {
  return state() == WEAK || state() == PENDING ||
         (state() == NEAR_DEATH && weakness_type() == FINALIZER_WEAK);
}

void MarkPending() {
  DCHECK(state() == WEAK)((void) 0);
  set_state(PENDING);
}

bool has_callback() const { return weak_callback_ != nullptr; }

// Accessors for next free node in the free list.
Node* next_free() {
  DCHECK_EQ(FREE, state())((void) 0);
  return data_.next_free;
}

void MakeWeak(void* parameter,
              WeakCallbackInfo<void>::Callback phantom_callback,
              v8::WeakCallbackType type) {
  DCHECK_NOT_NULL(phantom_callback)((void) 0);
  DCHECK(IsInUse())((void) 0);
  CHECK_NE(object_, kGlobalHandleZapValue)do { bool _cmp = ::v8::base::CmpNEImpl< typename ::v8::base
::pass_value_or_ref<decltype(object_)>::type, typename ::
v8::base::pass_value_or_ref<decltype(kGlobalHandleZapValue
)>::type>((object_), (kGlobalHandleZapValue)); do { if (
(__builtin_expect(!!(!(_cmp)), 0))) { V8_Fatal("Check failed: %s."
, "object_" " " "!=" " " "kGlobalHandleZapValue"); } } while (
false); } while (false);
  set_state(WEAK);
  switch (type) {
    case v8::WeakCallbackType::kParameter:
      set_weakness_type(PHANTOM_WEAK);
      break;
    case v8::WeakCallbackType::kInternalFields:
      set_weakness_type(PHANTOM_WEAK_2_EMBEDDER_FIELDS);
      break;
      START_ALLOW_USE_DEPRECATED()
    case v8::WeakCallbackType::kFinalizer:
      set_weakness_type(FINALIZER_WEAK);
      break;
      END_ALLOW_USE_DEPRECATED()
  }
  set_parameter(parameter);
  weak_callback_ = phantom_callback;
}

void MakeWeak(Address** location_addr) {
  DCHECK(IsInUse())((void) 0);
  CHECK_NE(object_, kGlobalHandleZapValue)do { bool _cmp = ::v8::base::CmpNEImpl< typename ::v8::base
::pass_value_or_ref<decltype(object_)>::type, typename ::
v8::base::pass_value_or_ref<decltype(kGlobalHandleZapValue
)>::type>((object_), (kGlobalHandleZapValue)); do { if (
(__builtin_expect(!!(!(_cmp)), 0))) { V8_Fatal("Check failed: %s."
, "object_" " " "!=" " " "kGlobalHandleZapValue"); } } while (
false); } while (false);
  set_state(WEAK);
  set_weakness_type(PHANTOM_WEAK_RESET_HANDLE);
  set_parameter(location_addr);
  weak_callback_ = nullptr;
}

void* ClearWeakness() {
  DCHECK(IsInUse())((void) 0);
  void* p = parameter();
  set_state(NORMAL);
  set_parameter(nullptr);
  return p;
}

void AnnotateStrongRetainer(const char* label) {
  DCHECK_EQ(state(), NORMAL)((void) 0);
  data_.parameter = const_cast<char*>(label);
}

void CollectPhantomCallbackData(
    std::vector<std::pair<Node*, PendingPhantomCallback>>*
        pending_phantom_callbacks) {
  DCHECK(weakness_type() == PHANTOM_WEAK ||((void) 0)
         weakness_type() == PHANTOM_WEAK_2_EMBEDDER_FIELDS)((void) 0);
  DCHECK(state() == PENDING)((void) 0);
  DCHECK_NOT_NULL(weak_callback_)((void) 0);

  void* embedder_fields[v8::kEmbedderFieldsInWeakCallback] = {nullptr,
                                                              nullptr};
  if (weakness_type() != PHANTOM_WEAK && object().IsJSObject()) {
    ExtractInternalFields(JSObject::cast(object()), embedder_fields,
                          v8::kEmbedderFieldsInWeakCallback);
  }

  // Zap with something dangerous.
  location().store(Object(0xCA11));

  pending_phantom_callbacks->push_back(std::make_pair(
      this,
      PendingPhantomCallback(weak_callback_, parameter(), embedder_fields)));
  DCHECK(IsInUse())((void) 0);
  set_state(NEAR_DEATH);
}

void ResetPhantomHandle() {
  DCHECK_EQ(PHANTOM_WEAK_RESET_HANDLE, weakness_type())((void) 0);
  DCHECK_EQ(PENDING, state())((void) 0);
  DCHECK_NULL(weak_callback_)((void) 0);
  Address** handle = reinterpret_cast<Address**>(parameter());
  *handle = nullptr;
  NodeSpace<Node>::Release(this);
}

void PostGarbageCollectionProcessing(Isolate* isolate) {
  // This method invokes a finalizer. Updating the method name would require
  // adjusting CFI blocklist as weak_callback_ is invoked on the wrong type.
  CHECK(IsPendingFinalizer())do { if ((__builtin_expect(!!(!(IsPendingFinalizer())), 0))) {
 V8_Fatal("Check failed: %s.", "IsPendingFinalizer()"); } } while
 (false);
  set_state(NEAR_DEATH);
  // Check that we are not passing a finalized external string to
  // the callback.
  DCHECK(!object().IsExternalOneByteString() ||((void) 0)
         ExternalOneByteString::cast(object()).resource() != nullptr)((void) 0);
  DCHECK(!object().IsExternalTwoByteString() ||((void) 0)
         ExternalTwoByteString::cast(object()).resource() != nullptr)((void) 0);
  // Leaving V8.
  VMState<EXTERNAL> vmstate(isolate);
  HandleScope handle_scope(isolate);
  void* embedder_fields[v8::kEmbedderFieldsInWeakCallback] = {nullptr,
                                                              nullptr};
  v8::WeakCallbackInfo<void> data(reinterpret_cast<v8::Isolate*>(isolate),
                                  parameter(), embedder_fields, nullptr);
  weak_callback_(data);
  // For finalizers the handle must have either been reset or made strong.
  // Both cases reset the state.
  CHECK_NE(NEAR_DEATH, state())do { bool _cmp = ::v8::base::CmpNEImpl< typename ::v8::base
::pass_value_or_ref<decltype(NEAR_DEATH)>::type, typename
 ::v8::base::pass_value_or_ref<decltype(state())>::type
>((NEAR_DEATH), (state())); do { if ((__builtin_expect(!!(
!(_cmp)), 0))) { V8_Fatal("Check failed: %s.", "NEAR_DEATH" " "
 "!=" " " "state()"); } } while (false); } while (false);
}

void MarkAsFree() { set_state(FREE); }
void MarkAsUsed() { set_state(NORMAL); }

GlobalHandles* global_handles() {
  return NodeBlock<Node>::From(this)->global_handles();
}

private:
// Fields that are not used for managing node memory.
void ClearImplFields() { weak_callback_ = nullptr; }

void CheckImplFieldsAreCleared() { DCHECK_EQ(nullptr, weak_callback_)((void) 0); }

// This stores three flags (independent, partially_dependent and
// in_young_list) and a State.
using NodeState = base::BitField8<State, 0, 3>;
using IsInYoungList = NodeState::Next<bool, 1>;
using NodeWeaknessType = IsInYoungList::Next<WeaknessType, 2>;

// Handle specific callback - might be a weak reference in disguise.
WeakCallbackInfo<void>::Callback weak_callback_;

friend class NodeBase<Node>;
660};

662class GlobalHandles::TracedNode final
  : public NodeBase<GlobalHandles::TracedNode> {
public:
TracedNode() { set_in_young_list(false); }
10
←
Calling default constructor for 'NodeBase<v8::internal::GlobalHandles::TracedNode>'→
12
←
Returning from default constructor for 'NodeBase<v8::internal::GlobalHandles::TracedNode>'→
13
←
Calling 'TracedNode::set_in_young_list'→

// Copy and move ctors are used when constructing a TracedNode when recording
// a node for on-stack data structures. (Older compilers may refer to copy
// instead of move ctor.)
TracedNode(TracedNode&& other) V8_NOEXCEPTnoexcept = default;
TracedNode(const TracedNode& other) V8_NOEXCEPTnoexcept = default;

enum State { FREE = 0, NORMAL, NEAR_DEATH };

State state() const { return NodeState::decode(flags_); }
void set_state(State state) { flags_ = NodeState::update(flags_, state); }

void MarkAsFree() { set_state(FREE); }
void MarkAsUsed() { set_state(NORMAL); }
bool IsInUse() const { return state() != FREE; }
bool IsRetainer() const { return state() == NORMAL; }

bool is_in_young_list() const { return IsInYoungList::decode(flags_); }
void set_in_young_list(bool v) { flags_ = IsInYoungList::update(flags_, v); }
14
←
1st function call argument is an uninitialized value

bool is_root() const { return IsRoot::decode(flags_); }
void set_root(bool v) { flags_ = IsRoot::update(flags_, v); }

void set_markbit() {
  NodeBlock<TracedNode>::From(this)->set_markbit(index());
}

bool markbit() const {
  return NodeBlock<TracedNode>::From(this)->markbit(index());
}
void clear_markbit() {
  NodeBlock<TracedNode>::From(this)->clear_markbit(index());
}

bool is_on_stack() const { return IsOnStack::decode(flags_); }
void set_is_on_stack(bool v) { flags_ = IsOnStack::update(flags_, v); }

void clear_object() {
  reinterpret_cast<std::atomic<Address>*>(&object_)->store(
      kNullAddress, std::memory_order_relaxed);
}

void CopyObjectReference(const TracedNode& other) {
  reinterpret_cast<std::atomic<Address>*>(&object_)->store(
      other.object_, std::memory_order_relaxed);
}

void ResetPhantomHandle() {
  DCHECK(IsInUse())((void) 0);
  NodeSpace<TracedNode>::Release(this);
  DCHECK(!IsInUse())((void) 0);
}

static void Verify(GlobalHandles* global_handles, const Address* const* slot);

protected:
// Various state is managed in a bit field. Mark bits are used concurrently
// and held externally in a NodeBlock.
using NodeState = base::BitField8<State, 0, 2>;
using IsInYoungList = NodeState::Next<bool, 1>;
using IsRoot = IsInYoungList::Next<bool, 1>;
using IsOnStack = IsRoot::Next<bool, 1>;
void ClearImplFields() {
  set_root(true);
  set_is_on_stack(false);
}

void CheckImplFieldsAreCleared() const { DCHECK(is_root())((void) 0); }

friend class NodeBase<GlobalHandles::TracedNode>;
736};

738// Space to keep track of on-stack handles (e.g. TracedReference). Such
739// references are treated as root for any V8 garbage collection. The data
740// structure is self healing and pessimistally filters outdated entries on
741// insertion and iteration.
742//
743// Design doc: http://bit.ly/on-stack-traced-reference
744class GlobalHandles::OnStackTracedNodeSpace final {
public:
static GlobalHandles* GetGlobalHandles(const TracedNode* on_stack_node) {
  DCHECK(on_stack_node->is_on_stack())((void) 0);
  return reinterpret_cast<const NodeEntry*>(on_stack_node)->global_handles;
}

explicit OnStackTracedNodeSpace(GlobalHandles* global_handles)
    : global_handles_(global_handles) {}

void SetStackStart(void* stack_start) {
  CHECK(on_stack_nodes_.empty())do { if ((__builtin_expect(!!(!(on_stack_nodes_.empty())), 0)
)) { V8_Fatal("Check failed: %s.", "on_stack_nodes_.empty()")
; } } while (false);
  stack_.SetStackStart(base::Stack::GetRealStackAddressForSlot(stack_start));
}

V8_INLINEinline __attribute__((always_inline)) bool IsOnStack(uintptr_t slot) const;

void Iterate(RootVisitor* v);
TracedNode* Acquire(Object value, uintptr_t address);
void CleanupBelowCurrentStackPosition();
void NotifyEmptyEmbedderStack();

size_t NumberOfHandlesForTesting() const { return on_stack_nodes_.size(); }

private:
struct NodeEntry {
  TracedNode node;
  // Used to find back to GlobalHandles from a Node on copy. Needs to follow
  // node.
  GlobalHandles* global_handles;
};

// Keeps track of registered handles. The data structure is cleaned on
// iteration and when adding new references using the current stack address.
// Cleaning is based on current stack address and the key of the map which is
// slightly different for ASAN configs -- see below.
780#ifdef V8_USE_ADDRESS_SANITIZER
// Mapping from stack slots or real stack frames to the corresponding nodes.
// In case a reference is part of a fake frame, we map it to the real stack
// frame base instead of the actual stack slot. The list keeps all nodes for
// a particular real frame.
std::map<uintptr_t, std::list<NodeEntry>> on_stack_nodes_;
786#else   // !V8_USE_ADDRESS_SANITIZER
// Mapping from stack slots to the corresponding nodes. We don't expect
// aliasing with overlapping lifetimes of nodes.
std::map<uintptr_t, NodeEntry> on_stack_nodes_;
790#endif  // !V8_USE_ADDRESS_SANITIZER

::heap::base::Stack stack_;
GlobalHandles* global_handles_ = nullptr;
size_t acquire_count_ = 0;
795};

797bool GlobalHandles::OnStackTracedNodeSpace::IsOnStack(uintptr_t slot) const {
// By the time this function is called, the stack start may not be set (i.e.
// SetStackStart() was not called). In that case, assume the slot is not on
// stack.
if (!stack_.stack_start()) return false;
return stack_.IsOnStack(reinterpret_cast<void*>(slot));
803}

805void GlobalHandles::OnStackTracedNodeSpace::NotifyEmptyEmbedderStack() {
on_stack_nodes_.clear();
807}

809void GlobalHandles::OnStackTracedNodeSpace::Iterate(RootVisitor* v) {
810#ifdef V8_USE_ADDRESS_SANITIZER
for (auto& pair : on_stack_nodes_) {
  for (auto& node_entry : pair.second) {
    TracedNode& node = node_entry.node;
    if (node.IsRetainer()) {
      v->VisitRootPointer(Root::kGlobalHandles, "on-stack TracedReference",
                          node.location());
    }
  }
}
820#else   // !V8_USE_ADDRESS_SANITIZER
// Handles have been cleaned from the GC entry point which is higher up the
// stack.
for (auto& pair : on_stack_nodes_) {
  TracedNode& node = pair.second.node;
  if (node.IsRetainer()) {
    v->VisitRootPointer(Root::kGlobalHandles, "on-stack TracedReference",
                        node.location());
  }
}
830#endif  // !V8_USE_ADDRESS_SANITIZER
831}

833GlobalHandles::TracedNode* GlobalHandles::OnStackTracedNodeSpace::Acquire(
  Object value, uintptr_t slot) {
constexpr size_t kAcquireCleanupThresholdLog2 = 8;
constexpr size_t kAcquireCleanupThresholdMask =
    (size_t{1} << kAcquireCleanupThresholdLog2) - 1;
DCHECK(IsOnStack(slot))((void) 0);
if (((acquire_count_++) & kAcquireCleanupThresholdMask) == 0) {
6
←
Assuming the condition is false→
7
←
Taking false branch→
  CleanupBelowCurrentStackPosition();
}
NodeEntry entry;
8
←
Calling implicit default constructor for 'NodeEntry'→
9
←
Calling default constructor for 'TracedNode'→
entry.node.Free(nullptr);
entry.global_handles = global_handles_;
845#ifdef V8_USE_ADDRESS_SANITIZER
auto pair = on_stack_nodes_.insert(
    {base::Stack::GetRealStackAddressForSlot(slot), {}});
pair.first->second.push_back(std::move(entry));
TracedNode* result = &(pair.first->second.back().node);
850#else   // !V8_USE_ADDRESS_SANITIZER
auto pair = on_stack_nodes_.insert(
    {base::Stack::GetRealStackAddressForSlot(slot), std::move(entry)});
if (!pair.second) {
  // Insertion failed because there already was an entry present for that
  // stack address. This can happen because cleanup is conservative in which
  // stack limits it used. Reusing the entry is fine as there's no aliasing of
  // different references with the same stack slot.
  pair.first->second.node.Free(nullptr);
}
TracedNode* result = &(pair.first->second.node);
861#endif  // !V8_USE_ADDRESS_SANITIZER
result->Acquire(value);
result->set_is_on_stack(true);
return result;
865}

867void GlobalHandles::OnStackTracedNodeSpace::CleanupBelowCurrentStackPosition() {
if (on_stack_nodes_.empty()) return;
const uintptr_t stack_ptr = reinterpret_cast<uintptr_t>(
    ::heap::base::Stack::GetCurrentStackPointerForLocalVariables());
const auto it = on_stack_nodes_.upper_bound(stack_ptr);
on_stack_nodes_.erase(on_stack_nodes_.begin(), it);
873}

875// static
876void GlobalHandles::EnableMarkingBarrier(Isolate* isolate) {
auto* global_handles = isolate->global_handles();
DCHECK(!global_handles->is_marking_)((void) 0);
global_handles->is_marking_ = true;
880}

882// static
883void GlobalHandles::DisableMarkingBarrier(Isolate* isolate) {
auto* global_handles = isolate->global_handles();
DCHECK(global_handles->is_marking_)((void) 0);
global_handles->is_marking_ = false;
887}

889// static
890void GlobalHandles::TracedNode::Verify(GlobalHandles* global_handles,
                                     const Address* const* slot) {
892#ifdef DEBUG
const TracedNode* node = FromLocation(*slot);
DCHECK(node->IsInUse())((void) 0);
bool slot_on_stack = global_handles->on_stack_nodes_->IsOnStack(
    reinterpret_cast<uintptr_t>(slot));
DCHECK_EQ(slot_on_stack, node->is_on_stack())((void) 0);
if (!node->is_on_stack()) {
  // On-heap nodes have seprate lists for young generation processing.
  bool is_young_gen_object = ObjectInYoungGeneration(node->object());
  DCHECK_IMPLIES(is_young_gen_object, node->is_in_young_list())((void) 0);
}
bool in_young_list =
    std::find(global_handles->traced_young_nodes_.begin(),
              global_handles->traced_young_nodes_.end(),
              node) != global_handles->traced_young_nodes_.end();
DCHECK_EQ(in_young_list, node->is_in_young_list())((void) 0);
908#endif  // DEBUG
909}

911void GlobalHandles::CleanupOnStackReferencesBelowCurrentStackPosition() {
on_stack_nodes_->CleanupBelowCurrentStackPosition();
913}

915size_t GlobalHandles::NumberOfOnStackHandlesForTesting() {
return on_stack_nodes_->NumberOfHandlesForTesting();
917}

919size_t GlobalHandles::TotalSize() const {
return regular_nodes_->TotalSize() + traced_nodes_->TotalSize();
921}

923size_t GlobalHandles::UsedSize() const {
return regular_nodes_->handles_count() * sizeof(Node) +
       traced_nodes_->handles_count() * sizeof(TracedNode);
926}

928size_t GlobalHandles::handles_count() const {
return regular_nodes_->handles_count() + traced_nodes_->handles_count();
930}

932void GlobalHandles::SetStackStart(void* stack_start) {
on_stack_nodes_->SetStackStart(stack_start);
934}

936void GlobalHandles::NotifyEmptyEmbedderStack() {
on_stack_nodes_->NotifyEmptyEmbedderStack();
938}

940GlobalHandles::GlobalHandles(Isolate* isolate)
  : isolate_(isolate),
    regular_nodes_(new NodeSpace<GlobalHandles::Node>(this)),
    traced_nodes_(new NodeSpace<GlobalHandles::TracedNode>(this)),
    on_stack_nodes_(new OnStackTracedNodeSpace(this)) {}

946GlobalHandles::~GlobalHandles() { regular_nodes_.reset(nullptr); }

948Handle<Object> GlobalHandles::Create(Object value) {
GlobalHandles::Node* result = regular_nodes_->Acquire(value);
if (ObjectInYoungGeneration(value) && !result->is_in_young_list()) {
  young_nodes_.push_back(result);
  result->set_in_young_list(true);
}
return result->handle();
955}

957Handle<Object> GlobalHandles::Create(Address value) {
return Create(Object(value));
959}

961Handle<Object> GlobalHandles::CreateTraced(Object value, Address* slot,
                                         GlobalHandleStoreMode store_mode) {
return CreateTraced(
2
←
Calling 'GlobalHandles::CreateTraced'→
    value, slot, store_mode,
    on_stack_nodes_->IsOnStack(reinterpret_cast<uintptr_t>(slot)));
966}

968Handle<Object> GlobalHandles::CreateTraced(Object value, Address* slot,
                                         GlobalHandleStoreMode store_mode,
                                         bool is_on_stack) {
GlobalHandles::TracedNode* result;
if (is_on_stack) {
3
←
Assuming 'is_on_stack' is true→
4
←
Taking true branch→
  result = on_stack_nodes_->Acquire(value, reinterpret_cast<uintptr_t>(slot));
5
←
Calling 'OnStackTracedNodeSpace::Acquire'→
} else {
  result = traced_nodes_->Acquire(value);
  if (ObjectInYoungGeneration(value) && !result->is_in_young_list()) {
    traced_young_nodes_.push_back(result);
    result->set_in_young_list(true);
  }
  // Nodes are black allocated for simplicity.
  result->set_markbit();
  if (store_mode != GlobalHandleStoreMode::kInitializingStore) {
    WriteBarrier::MarkingFromGlobalHandle(value);
  }
}
result->set_parameter(nullptr);
return result->handle();
988}

990Handle<Object> GlobalHandles::CreateTraced(Address value, Address* slot,
                                         GlobalHandleStoreMode store_mode) {
return CreateTraced(Object(value), slot, store_mode);
1
Calling 'GlobalHandles::CreateTraced'→
993}

995Handle<Object> GlobalHandles::CopyGlobal(Address* location) {
DCHECK_NOT_NULL(location)((void) 0);
GlobalHandles* global_handles =
    Node::FromLocation(location)->global_handles();
999#ifdef VERIFY_HEAP
if (i::FLAG_verify_heap) {
  Object(*location).ObjectVerify(global_handles->isolate());
}
1003#endif  // VERIFY_HEAP
return global_handles->Create(*location);
1005}

1007namespace {
1008void SetSlotThreadSafe(Address** slot, Address* val) {
reinterpret_cast<std::atomic<Address*>*>(slot)->store(
    val, std::memory_order_relaxed);
1011}
1012}  // namespace

1014// static
1015void GlobalHandles::CopyTracedReference(const Address* const* from,
                                      Address** to) {
DCHECK_NOT_NULL(*from)((void) 0);
DCHECK_NULL(*to)((void) 0);
const TracedNode* node = TracedNode::FromLocation(*from);
GlobalHandles* global_handles =
    GlobalHandles::From(const_cast<TracedNode*>(node));
Handle<Object> o = global_handles->CreateTraced(
    node->object(), reinterpret_cast<Address*>(to),
    GlobalHandleStoreMode::kAssigningStore);
SetSlotThreadSafe(to, o.location());
TracedNode::Verify(global_handles, from);
TracedNode::Verify(global_handles, to);
1028#ifdef VERIFY_HEAP
if (i::FLAG_verify_heap) {
  Object(**to).ObjectVerify(global_handles->isolate());
}
1032#endif  // VERIFY_HEAP
1033}

1035void GlobalHandles::MoveGlobal(Address** from, Address** to) {
DCHECK_NOT_NULL(*from)((void) 0);
DCHECK_NOT_NULL(*to)((void) 0);
DCHECK_EQ(*from, *to)((void) 0);
Node* node = Node::FromLocation(*from);
if (node->IsWeak() && node->IsPhantomResetHandle()) {
  node->set_parameter(to);
}

// - Strong handles do not require fixups.
// - Weak handles with finalizers and callbacks are too general to fix up. For
//   those the callers need to ensure consistency.
1047}

1049void GlobalHandles::MoveTracedReference(Address** from, Address** to) {
// Fast path for moving from an empty reference.
if (!*from) {
  DestroyTracedReference(*to);
  SetSlotThreadSafe(to, nullptr);
  return;
}

// Determining whether from or to are on stack.
TracedNode* from_node = TracedNode::FromLocation(*from);
DCHECK(from_node->IsInUse())((void) 0);
TracedNode* to_node = TracedNode::FromLocation(*to);
GlobalHandles* global_handles = nullptr;
1062#ifdef DEBUG
global_handles = GlobalHandles::From(from_node);
1064#endif  // DEBUG
bool from_on_stack = from_node->is_on_stack();
bool to_on_stack = false;
if (!to_node) {
  // Figure out whether stack or heap to allow fast path for heap->heap move.
  global_handles = GlobalHandles::From(from_node);
  to_on_stack = global_handles->on_stack_nodes_->IsOnStack(
      reinterpret_cast<uintptr_t>(to));
} else {
  to_on_stack = to_node->is_on_stack();
}

// Moving.
if (from_on_stack || to_on_stack) {
  // Move involving a stack slot.
  if (!to_node) {
    DCHECK(global_handles)((void) 0);
    Handle<Object> o = global_handles->CreateTraced(
        from_node->object(), reinterpret_cast<Address*>(to),
        GlobalHandleStoreMode::kAssigningStore, to_on_stack);
    SetSlotThreadSafe(to, o.location());
    to_node = TracedNode::FromLocation(*to);
    DCHECK_IMPLIES(!to_node->is_on_stack(), to_node->markbit())((void) 0);
  } else {
    DCHECK(to_node->IsInUse())((void) 0);
    to_node->CopyObjectReference(*from_node);
    if (!to_node->is_on_stack() && !to_node->is_in_young_list() &&
        ObjectInYoungGeneration(to_node->object())) {
      global_handles = GlobalHandles::From(from_node);
      global_handles->traced_young_nodes_.push_back(to_node);
      to_node->set_in_young_list(true);
    }
    if (!to_on_stack) {
      WriteBarrier::MarkingFromGlobalHandle(to_node->object());
    }
  }
  DestroyTracedReference(*from);
  SetSlotThreadSafe(from, nullptr);
} else {
  // Pure heap move.
  DestroyTracedReference(*to);
  SetSlotThreadSafe(to, *from);
  to_node = from_node;
  DCHECK_NOT_NULL(*from)((void) 0);
  DCHECK_NOT_NULL(*to)((void) 0);
  DCHECK_EQ(*from, *to)((void) 0);
  WriteBarrier::MarkingFromGlobalHandle(to_node->object());
  SetSlotThreadSafe(from, nullptr);
}
TracedNode::Verify(global_handles, to);
1114}

1116// static
1117GlobalHandles* GlobalHandles::From(const TracedNode* node) {
return node->is_on_stack()
           ? OnStackTracedNodeSpace::GetGlobalHandles(node)
           : NodeBlock<TracedNode>::From(node)->global_handles();
1121}

1123void GlobalHandles::MarkTraced(Address* location) {
TracedNode* node = TracedNode::FromLocation(location);
DCHECK(node->IsInUse())((void) 0);
if (node->is_on_stack()) return;
node->set_markbit();
1128}

1130void GlobalHandles::Destroy(Address* location) {
if (location != nullptr) {
  NodeSpace<Node>::Release(Node::FromLocation(location));
}
1134}

1136// static
1137void GlobalHandles::DestroyTracedReference(Address* location) {
if (location != nullptr) {
  TracedNode* node = TracedNode::FromLocation(location);
  if (node->is_on_stack()) {
    node->Release(nullptr);
    return;
  }
  DCHECK(!node->is_on_stack())((void) 0);

  auto* global_handles = GlobalHandles::From(node);
  // When marking is off the handle may be freed immediately. Note that this
  // includes also the case when invoking the first pass callbacks during the
  // atomic pause which requires releasing a node fully.
  if (!global_handles->is_marking_) {
    NodeSpace<TracedNode>::Release(node);
    return;
  }

  // Incremental marking is on. This also covers the scavenge case which
  // prohibits eagerly reclaiming nodes when marking is on during a scavenge.
  //
  // On-heap traced nodes are released in the atomic pause in
  // `IterateWeakRootsForPhantomHandles()` when they are discovered as not
  // marked.
  //
  // Eagerly clear out the object here to avoid needlessly marking it from
  // this point on. Also clear out callback and backreference for the version
  // with callbacks to avoid calling into possibly dead memory later.
  //
  // In the case this happens during incremental marking, the node may
  // still be spuriously marked as live and is then only reclaimed on the
  // next cycle.
  node->clear_object();
  node->set_parameter(nullptr);
}
1172}

1174using GenericCallback = v8::WeakCallbackInfo<void>::Callback;

1176void GlobalHandles::MakeWeak(Address* location, void* parameter,
                           GenericCallback phantom_callback,
                           v8::WeakCallbackType type) {
Node::FromLocation(location)->MakeWeak(parameter, phantom_callback, type);
1180}

1182void GlobalHandles::MakeWeak(Address** location_addr) {
Node::FromLocation(*location_addr)->MakeWeak(location_addr);
1184}

1186void* GlobalHandles::ClearWeakness(Address* location) {
return Node::FromLocation(location)->ClearWeakness();
1188}

1190void GlobalHandles::AnnotateStrongRetainer(Address* location,
                                         const char* label) {
Node::FromLocation(location)->AnnotateStrongRetainer(label);
1193}

1195bool GlobalHandles::IsWeak(Address* location) {
return Node::FromLocation(location)->IsWeak();
1197}

1199DISABLE_CFI_PERF__attribute__((no_sanitize("cfi")))
1200void GlobalHandles::IterateWeakRootsForFinalizers(RootVisitor* v) {
for (Node* node : *regular_nodes_) {
  if (node->IsWeakRetainer() && node->state() == Node::PENDING) {
    DCHECK(!node->IsPhantomCallback())((void) 0);
    DCHECK(!node->IsPhantomResetHandle())((void) 0);
    // Finalizers need to survive.
    v->VisitRootPointer(Root::kGlobalHandles, node->label(),
                        node->location());
  }
}
1210}

1212DISABLE_CFI_PERF__attribute__((no_sanitize("cfi")))
1213void GlobalHandles::IterateWeakRootsForPhantomHandles(
  WeakSlotCallbackWithHeap should_reset_handle) {
for (Node* node : *regular_nodes_) {
  if (node->IsWeakRetainer() &&
      should_reset_handle(isolate()->heap(), node->location())) {
    if (node->IsPhantomResetHandle()) {
      node->MarkPending();
      node->ResetPhantomHandle();
      ++number_of_phantom_handle_resets_;
    } else if (node->IsPhantomCallback()) {
      node->MarkPending();
      node->CollectPhantomCallbackData(&regular_pending_phantom_callbacks_);
    }
  }
}
for (TracedNode* node : *traced_nodes_) {
  if (!node->IsInUse()) continue;
  // Detect unreachable nodes first.
  if (!node->markbit()) {
    // The handle itself is unreachable. We can clear it even if the target V8
    // object is alive.
    node->ResetPhantomHandle();
    ++number_of_phantom_handle_resets_;
    continue;
  }
  // Clear the markbit for the next GC.
  node->clear_markbit();
  DCHECK(node->IsInUse())((void) 0);
  // Detect nodes with unreachable target objects.
  if (should_reset_handle(isolate()->heap(), node->location())) {
    node->ResetPhantomHandle();
    ++number_of_phantom_handle_resets_;
  }
}
1247}

1249void GlobalHandles::IterateWeakRootsIdentifyFinalizers(
  WeakSlotCallbackWithHeap should_reset_handle) {
for (Node* node : *regular_nodes_) {
  if (node->IsWeak() &&
      should_reset_handle(isolate()->heap(), node->location())) {
    if (node->IsFinalizerHandle()) {
      node->MarkPending();
    }
  }
}
1259}

1261void GlobalHandles::IdentifyWeakUnmodifiedObjects(
  WeakSlotCallback is_unmodified) {
if (!FLAG_reclaim_unmodified_wrappers) return;

// Treat all objects as roots during incremental marking to avoid corrupting
// marking worklists.
if (isolate()->heap()->incremental_marking()->IsMarking()) return;

auto* const handler = isolate()->heap()->GetEmbedderRootsHandler();
for (TracedNode* node : traced_young_nodes_) {
  if (node->IsInUse()) {
    DCHECK(node->is_root())((void) 0);
    if (is_unmodified(node->location())) {
      v8::Value* value = ToApi<v8::Value>(node->handle());
      node->set_root(handler->IsRoot(
          *reinterpret_cast<v8::TracedReference<v8::Value>*>(&value)));
    }
  }
}
1280}

1282void GlobalHandles::IterateYoungStrongAndDependentRoots(RootVisitor* v) {
for (Node* node : young_nodes_) {
  if (node->IsStrongRetainer()) {
    v->VisitRootPointer(Root::kGlobalHandles, node->label(),
                        node->location());
  }
}
for (TracedNode* node : traced_young_nodes_) {
  if (node->IsInUse() && node->is_root()) {
    v->VisitRootPointer(Root::kGlobalHandles, nullptr, node->location());
  }
}
1294}

1296void GlobalHandles::MarkYoungWeakDeadObjectsPending(
  WeakSlotCallbackWithHeap is_dead) {
for (Node* node : young_nodes_) {
  DCHECK(node->is_in_young_list())((void) 0);
  if (node->IsWeak() && is_dead(isolate_->heap(), node->location())) {
    if (!node->IsPhantomCallback() && !node->IsPhantomResetHandle()) {
      node->MarkPending();
    }
  }
}
1306}

1308void GlobalHandles::IterateYoungWeakDeadObjectsForFinalizers(RootVisitor* v) {
for (Node* node : young_nodes_) {
  DCHECK(node->is_in_young_list())((void) 0);
  if (node->IsWeakRetainer() && (node->state() == Node::PENDING)) {
    DCHECK(!node->IsPhantomCallback())((void) 0);
    DCHECK(!node->IsPhantomResetHandle())((void) 0);
    // Finalizers need to survive.
    v->VisitRootPointer(Root::kGlobalHandles, node->label(),
                        node->location());
  }
}
1319}

1321void GlobalHandles::IterateYoungWeakObjectsForPhantomHandles(
  RootVisitor* v, WeakSlotCallbackWithHeap should_reset_handle) {
for (Node* node : young_nodes_) {
  DCHECK(node->is_in_young_list())((void) 0);
  if (node->IsWeakRetainer() && (node->state() != Node::PENDING)) {
    if (should_reset_handle(isolate_->heap(), node->location())) {
      DCHECK(node->IsPhantomResetHandle() || node->IsPhantomCallback())((void) 0);
      if (node->IsPhantomResetHandle()) {
        node->MarkPending();
        node->ResetPhantomHandle();
        ++number_of_phantom_handle_resets_;
      } else if (node->IsPhantomCallback()) {
        node->MarkPending();
        node->CollectPhantomCallbackData(&regular_pending_phantom_callbacks_);
      } else {
        UNREACHABLE()V8_Fatal("unreachable code");
      }
    } else {
      // Node survived and needs to be visited.
      v->VisitRootPointer(Root::kGlobalHandles, node->label(),
                          node->location());
    }
  }
}

if (!FLAG_reclaim_unmodified_wrappers) return;

auto* const handler = isolate()->heap()->GetEmbedderRootsHandler();
for (TracedNode* node : traced_young_nodes_) {
  if (!node->IsInUse()) continue;

  DCHECK_IMPLIES(node->is_root(),((void) 0)
                 !should_reset_handle(isolate_->heap(), node->location()))((void) 0);
  if (should_reset_handle(isolate_->heap(), node->location())) {
    v8::Value* value = ToApi<v8::Value>(node->handle());
    handler->ResetRoot(
        *reinterpret_cast<v8::TracedReference<v8::Value>*>(&value));
    // We cannot check whether a node is in use here as the reset behavior
    // depends on whether incremental marking is running when reclaiming
    // young objects.
    ++number_of_phantom_handle_resets_;
  } else {
    if (!node->is_root()) {
      node->set_root(true);
      v->VisitRootPointer(Root::kGlobalHandles, nullptr, node->location());
    }
  }
}
1369}

1371void GlobalHandles::InvokeSecondPassPhantomCallbacksFromTask() {
DCHECK(second_pass_callbacks_task_posted_)((void) 0);
second_pass_callbacks_task_posted_ = false;
Heap::DevToolsTraceEventScope devtools_trace_event_scope(
    isolate()->heap(), "MajorGC", "invoke weak phantom callbacks");
TRACE_EVENT0("v8", "V8.GCPhantomHandleProcessingCallback")static v8::base::AtomicWord trace_event_unique_atomic1376 = 0
; const uint8_t* trace_event_unique_category_group_enabled1376
; trace_event_unique_category_group_enabled1376 = reinterpret_cast
<const uint8_t*>(v8::base::Relaxed_Load(&(trace_event_unique_atomic1376
))); if (!trace_event_unique_category_group_enabled1376) { trace_event_unique_category_group_enabled1376
 = v8::internal::tracing::TraceEventHelper::GetTracingController
() ->GetCategoryGroupEnabled("v8"); v8::base::Relaxed_Store
(&(trace_event_unique_atomic1376), (reinterpret_cast<v8
::base::AtomicWord>( trace_event_unique_category_group_enabled1376
))); };; v8::internal::tracing::ScopedTracer trace_event_unique_tracer1376
; if (v8::base::Relaxed_Load(reinterpret_cast<const v8::base
::Atomic8*>( trace_event_unique_category_group_enabled1376
)) & (kEnabledForRecording_CategoryGroupEnabledFlags | kEnabledForEventCallback_CategoryGroupEnabledFlags
)) { uint64_t h = v8::internal::tracing::AddTraceEvent( ('X')
, trace_event_unique_category_group_enabled1376, "V8.GCPhantomHandleProcessingCallback"
, v8::internal::tracing::kGlobalScope, v8::internal::tracing::
kNoId, v8::internal::tracing::kNoId, (static_cast<unsigned
 int>(0))); trace_event_unique_tracer1376 .Initialize(trace_event_unique_category_group_enabled1376
, "V8.GCPhantomHandleProcessingCallback", h); };
isolate()->heap()->CallGCPrologueCallbacks(
    GCType::kGCTypeProcessWeakCallbacks, kNoGCCallbackFlags);
InvokeSecondPassPhantomCallbacks();
isolate()->heap()->CallGCEpilogueCallbacks(
    GCType::kGCTypeProcessWeakCallbacks, kNoGCCallbackFlags);
1382}

1384void GlobalHandles::InvokeSecondPassPhantomCallbacks() {
// The callbacks may execute JS, which in turn may lead to another GC run.
// If we are already processing the callbacks, we do not want to start over
// from within the inner GC. Newly added callbacks will always be run by the
// outermost GC run only.
if (running_second_pass_callbacks_) return;
running_second_pass_callbacks_ = true;

AllowJavascriptExecution allow_js(isolate());
while (!second_pass_callbacks_.empty()) {
  auto callback = second_pass_callbacks_.back();
  second_pass_callbacks_.pop_back();
  callback.Invoke(isolate(), PendingPhantomCallback::kSecondPass);
}
running_second_pass_callbacks_ = false;
1399}

1401size_t GlobalHandles::PostScavengeProcessing(unsigned post_processing_count) {
size_t freed_nodes = 0;
for (Node* node : young_nodes_) {
  // Filter free nodes.
  if (!node->IsRetainer()) continue;

  if (node->IsPending()) {
    DCHECK(node->has_callback())((void) 0);
    DCHECK(node->IsPendingFinalizer())((void) 0);
    node->PostGarbageCollectionProcessing(isolate_);
  }
  if (InRecursiveGC(post_processing_count)) return freed_nodes;

  if (!node->IsRetainer()) freed_nodes++;
}
return freed_nodes;
1417}

1419size_t GlobalHandles::PostMarkSweepProcessing(unsigned post_processing_count) {
size_t freed_nodes = 0;
for (Node* node : *regular_nodes_) {
  // Filter free nodes.
  if (!node->IsRetainer()) continue;

  if (node->IsPending()) {
    DCHECK(node->has_callback())((void) 0);
    DCHECK(node->IsPendingFinalizer())((void) 0);
    node->PostGarbageCollectionProcessing(isolate_);
  }
  if (InRecursiveGC(post_processing_count)) return freed_nodes;

  if (!node->IsRetainer()) freed_nodes++;
}
return freed_nodes;
1435}

1437template <typename T>
1438void GlobalHandles::UpdateAndCompactListOfYoungNode(
  std::vector<T*>* node_list) {
size_t last = 0;
for (T* node : *node_list) {
  DCHECK(node->is_in_young_list())((void) 0);
  if (node->IsInUse()) {
    if (ObjectInYoungGeneration(node->object())) {
      (*node_list)[last++] = node;
      isolate_->heap()->IncrementNodesCopiedInNewSpace();
    } else {
      node->set_in_young_list(false);
      isolate_->heap()->IncrementNodesPromoted();
    }
  } else {
    node->set_in_young_list(false);
    isolate_->heap()->IncrementNodesDiedInNewSpace();
  }
}
DCHECK_LE(last, node_list->size())((void) 0);
node_list->resize(last);
node_list->shrink_to_fit();
1459}

1461void GlobalHandles::UpdateListOfYoungNodes() {
UpdateAndCompactListOfYoungNode(&young_nodes_);
UpdateAndCompactListOfYoungNode(&traced_young_nodes_);
1464}

1466template <typename T>
1467size_t GlobalHandles::InvokeFirstPassWeakCallbacks(
  std::vector<std::pair<T*, PendingPhantomCallback>>* pending) {
size_t freed_nodes = 0;
std::vector<std::pair<T*, PendingPhantomCallback>> pending_phantom_callbacks;
pending_phantom_callbacks.swap(*pending);
{
  // The initial pass callbacks must simply clear the nodes.
  for (auto& pair : pending_phantom_callbacks) {
    T* node = pair.first;
    DCHECK_EQ(T::NEAR_DEATH, node->state())((void) 0);
    pair.second.Invoke(isolate(), PendingPhantomCallback::kFirstPass);

    // Transition to second pass. It is required that the first pass callback
    // resets the handle using |v8::PersistentBase::Reset|. Also see comments
    // on |v8::WeakCallbackInfo|.
    CHECK_WITH_MSG(T::FREE == node->state(),do { if ((__builtin_expect(!!(!(T::FREE == node->state()))
, 0))) { V8_Fatal("Check failed: %s.", "Handle not reset in first callback. See comments on "
 "|v8::WeakCallbackInfo|."); } } while (false)
                   "Handle not reset in first callback. See comments on "do { if ((__builtin_expect(!!(!(T::FREE == node->state()))
, 0))) { V8_Fatal("Check failed: %s.", "Handle not reset in first callback. See comments on "
 "|v8::WeakCallbackInfo|."); } } while (false)
                   "|v8::WeakCallbackInfo|.")do { if ((__builtin_expect(!!(!(T::FREE == node->state()))
, 0))) { V8_Fatal("Check failed: %s.", "Handle not reset in first callback. See comments on "
 "|v8::WeakCallbackInfo|."); } } while (false);

    if (pair.second.callback()) second_pass_callbacks_.push_back(pair.second);
    freed_nodes++;
  }
}
return freed_nodes;
1491}

1493size_t GlobalHandles::InvokeFirstPassWeakCallbacks() {
return InvokeFirstPassWeakCallbacks(&regular_pending_phantom_callbacks_) +
       InvokeFirstPassWeakCallbacks(&traced_pending_phantom_callbacks_);
1496}

1498void GlobalHandles::InvokeOrScheduleSecondPassPhantomCallbacks(
  bool synchronous_second_pass) {
if (!second_pass_callbacks_.empty()) {
  if (FLAG_optimize_for_size || FLAG_predictable || synchronous_second_pass) {
    Heap::DevToolsTraceEventScope devtools_trace_event_scope(
        isolate()->heap(), "MajorGC", "invoke weak phantom callbacks");
    isolate()->heap()->CallGCPrologueCallbacks(
        GCType::kGCTypeProcessWeakCallbacks, kNoGCCallbackFlags);
    InvokeSecondPassPhantomCallbacks();
    isolate()->heap()->CallGCEpilogueCallbacks(
        GCType::kGCTypeProcessWeakCallbacks, kNoGCCallbackFlags);
  } else if (!second_pass_callbacks_task_posted_) {
    second_pass_callbacks_task_posted_ = true;
    auto taskrunner = V8::GetCurrentPlatform()->GetForegroundTaskRunner(
        reinterpret_cast<v8::Isolate*>(isolate()));
    taskrunner->PostTask(MakeCancelableTask(
        isolate(), [this] { InvokeSecondPassPhantomCallbacksFromTask(); }));
  }
}
1517}

1519void GlobalHandles::PendingPhantomCallback::Invoke(Isolate* isolate,
                                                 InvocationType type) {
Data::Callback* callback_addr = nullptr;
if (type == kFirstPass) {
  callback_addr = &callback_;
}
Data data(reinterpret_cast<v8::Isolate*>(isolate), parameter_,
          embedder_fields_, callback_addr);
Data::Callback callback = callback_;
callback_ = nullptr;
callback(data);
1530}

1532bool GlobalHandles::InRecursiveGC(unsigned gc_processing_counter) {
return gc_processing_counter != post_gc_processing_count_;
1534}

1536size_t GlobalHandles::PostGarbageCollectionProcessing(
  GarbageCollector collector, const v8::GCCallbackFlags gc_callback_flags) {
// Process weak global handle callbacks. This must be done after the
// GC is completely done, because the callbacks may invoke arbitrary
// API functions.
DCHECK_EQ(Heap::NOT_IN_GC, isolate_->heap()->gc_state())((void) 0);
const unsigned post_processing_count = ++post_gc_processing_count_;
size_t freed_nodes = 0;
bool synchronous_second_pass =
    isolate_->heap()->IsTearingDown() ||
    (gc_callback_flags &
     (kGCCallbackFlagForced | kGCCallbackFlagCollectAllAvailableGarbage |
      kGCCallbackFlagSynchronousPhantomCallbackProcessing)) != 0;
InvokeOrScheduleSecondPassPhantomCallbacks(synchronous_second_pass);
if (InRecursiveGC(post_processing_count)) return freed_nodes;

freed_nodes += Heap::IsYoungGenerationCollector(collector)
                   ? PostScavengeProcessing(post_processing_count)
                   : PostMarkSweepProcessing(post_processing_count);
if (InRecursiveGC(post_processing_count)) return freed_nodes;

UpdateListOfYoungNodes();
return freed_nodes;
1559}

1561void GlobalHandles::IterateStrongRoots(RootVisitor* v) {
for (Node* node : *regular_nodes_) {
  if (node->IsStrongRetainer()) {
    v->VisitRootPointer(Root::kGlobalHandles, node->label(),
                        node->location());
  }
}
1568}

1570void GlobalHandles::IterateStrongStackRoots(RootVisitor* v) {
on_stack_nodes_->Iterate(v);
1572}

1574void GlobalHandles::IterateWeakRoots(RootVisitor* v) {
for (Node* node : *regular_nodes_) {
  if (node->IsWeak()) {
    v->VisitRootPointer(Root::kGlobalHandles, node->label(),
                        node->location());
  }
}
for (TracedNode* node : *traced_nodes_) {
  if (node->IsInUse()) {
    v->VisitRootPointer(Root::kGlobalHandles, nullptr, node->location());
  }
}
1586}

1588DISABLE_CFI_PERF__attribute__((no_sanitize("cfi")))
1589void GlobalHandles::IterateAllRoots(RootVisitor* v) {
for (Node* node : *regular_nodes_) {
  if (node->IsRetainer()) {
    v->VisitRootPointer(Root::kGlobalHandles, node->label(),
                        node->location());
  }
}
for (TracedNode* node : *traced_nodes_) {
  if (node->IsRetainer()) {
    v->VisitRootPointer(Root::kGlobalHandles, nullptr, node->location());
  }
}
on_stack_nodes_->Iterate(v);
1602}

1604DISABLE_CFI_PERF__attribute__((no_sanitize("cfi")))
1605void GlobalHandles::IterateAllYoungRoots(RootVisitor* v) {
for (Node* node : young_nodes_) {
  if (node->IsRetainer()) {
    v->VisitRootPointer(Root::kGlobalHandles, node->label(),
                        node->location());
  }
}
for (TracedNode* node : traced_young_nodes_) {
  if (node->IsRetainer()) {
    v->VisitRootPointer(Root::kGlobalHandles, nullptr, node->location());
  }
}
on_stack_nodes_->Iterate(v);
1618}

1620DISABLE_CFI_PERF__attribute__((no_sanitize("cfi")))
1621void GlobalHandles::ApplyPersistentHandleVisitor(
  v8::PersistentHandleVisitor* visitor, GlobalHandles::Node* node) {
v8::Value* value = ToApi<v8::Value>(node->handle());
visitor->VisitPersistentHandle(
    reinterpret_cast<v8::Persistent<v8::Value>*>(&value),
    node->wrapper_class_id());
1627}

1629DISABLE_CFI_PERF__attribute__((no_sanitize("cfi")))
1630void GlobalHandles::IterateAllRootsWithClassIds(
  v8::PersistentHandleVisitor* visitor) {
for (Node* node : *regular_nodes_) {
  if (node->IsRetainer() && node->has_wrapper_class_id()) {
    ApplyPersistentHandleVisitor(visitor, node);
  }
}
1637}

1639DISABLE_CFI_PERF__attribute__((no_sanitize("cfi")))
1640void GlobalHandles::IterateTracedNodes(
  v8::EmbedderHeapTracer::TracedGlobalHandleVisitor* visitor) {
for (TracedNode* node : *traced_nodes_) {
  if (node->IsInUse()) {
    v8::Value* value = ToApi<v8::Value>(node->handle());
    visitor->VisitTracedReference(
        *reinterpret_cast<v8::TracedReference<v8::Value>*>(&value));
  }
}
1649}

1651DISABLE_CFI_PERF__attribute__((no_sanitize("cfi")))
1652void GlobalHandles::IterateAllYoungRootsWithClassIds(
  v8::PersistentHandleVisitor* visitor) {
for (Node* node : young_nodes_) {
  if (node->IsRetainer() && node->has_wrapper_class_id()) {
    ApplyPersistentHandleVisitor(visitor, node);
  }
}
1659}

1661DISABLE_CFI_PERF__attribute__((no_sanitize("cfi")))
1662void GlobalHandles::IterateYoungWeakRootsWithClassIds(
  v8::PersistentHandleVisitor* visitor) {
for (Node* node : young_nodes_) {
  if (node->has_wrapper_class_id() && node->IsWeak()) {
    ApplyPersistentHandleVisitor(visitor, node);
  }
}
1669}

1671void GlobalHandles::RecordStats(HeapStats* stats) {
*stats->global_handle_count = 0;
*stats->weak_global_handle_count = 0;
*stats->pending_global_handle_count = 0;
*stats->near_death_global_handle_count = 0;
*stats->free_global_handle_count = 0;
for (Node* node : *regular_nodes_) {
  *stats->global_handle_count += 1;
  if (node->state() == Node::WEAK) {
    *stats->weak_global_handle_count += 1;
  } else if (node->state() == Node::PENDING) {
    *stats->pending_global_handle_count += 1;
  } else if (node->state() == Node::NEAR_DEATH) {
    *stats->near_death_global_handle_count += 1;
  } else if (node->state() == Node::FREE) {
    *stats->free_global_handle_count += 1;
  }
}
1689}

1691#ifdef DEBUG

1693void GlobalHandles::PrintStats() {
int total = 0;
int weak = 0;
int pending = 0;
int near_death = 0;
int destroyed = 0;

for (Node* node : *regular_nodes_) {
  total++;
  if (node->state() == Node::WEAK) weak++;
  if (node->state() == Node::PENDING) pending++;
  if (node->state() == Node::NEAR_DEATH) near_death++;
  if (node->state() == Node::FREE) destroyed++;
}

PrintF("Global Handle Statistics:\n");
PrintF("  allocated memory = %zuB\n", total * sizeof(Node));
PrintF("  # weak       = %d\n", weak);
PrintF("  # pending    = %d\n", pending);
PrintF("  # near_death = %d\n", near_death);
PrintF("  # free       = %d\n", destroyed);
PrintF("  # total      = %d\n", total);
1715}

1717void GlobalHandles::Print() {
PrintF("Global handles:\n");
for (Node* node : *regular_nodes_) {
  PrintF("  handle %p to %p%s\n", node->location().ToVoidPtr(),
         reinterpret_cast<void*>(node->object().ptr()),
         node->IsWeak() ? " (weak)" : "");
}
1724}

1726#endif

1728EternalHandles::~EternalHandles() {
for (Address* block : blocks_) delete[] block;
1730}

1732void EternalHandles::IterateAllRoots(RootVisitor* visitor) {
int limit = size_;
for (Address* block : blocks_) {
  DCHECK_GT(limit, 0)((void) 0);
  visitor->VisitRootPointers(
      Root::kEternalHandles, nullptr, FullObjectSlot(block),
      FullObjectSlot(block + std::min({limit, kSize})));
  limit -= kSize;
}
1741}

1743void EternalHandles::IterateYoungRoots(RootVisitor* visitor) {
for (int index : young_node_indices_) {
  visitor->VisitRootPointer(Root::kEternalHandles, nullptr,
                            FullObjectSlot(GetLocation(index)));
}
1748}

1750void EternalHandles::PostGarbageCollectionProcessing() {
size_t last = 0;
for (int index : young_node_indices_) {
  if (ObjectInYoungGeneration(Object(*GetLocation(index)))) {
    young_node_indices_[last++] = index;
  }
}
DCHECK_LE(last, young_node_indices_.size())((void) 0);
young_node_indices_.resize(last);
1759}

1761void EternalHandles::Create(Isolate* isolate, Object object, int* index) {
DCHECK_EQ(kInvalidIndex, *index)((void) 0);
if (object == Object()) return;
Object the_hole = ReadOnlyRoots(isolate).the_hole_value();
DCHECK_NE(the_hole, object)((void) 0);
int block = size_ >> kShift;
int offset = size_ & kMask;
// Need to resize.
if (offset == 0) {
  Address* next_block = new Address[kSize];
  MemsetPointer(FullObjectSlot(next_block), the_hole, kSize);
  blocks_.push_back(next_block);
}
DCHECK_EQ(the_hole.ptr(), blocks_[block][offset])((void) 0);
blocks_[block][offset] = object.ptr();
if (ObjectInYoungGeneration(object)) {
  young_node_indices_.push_back(size_);
}
*index = size_++;
1780}

1782}  // namespace internal
1783}  // namespace v8