mirror of https://github.com/lukechilds/node.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
92 lines
2.7 KiB
92 lines
2.7 KiB
// Copyright 2015 the V8 project authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#ifndef V8_IDENTITY_MAP_H_
|
|
#define V8_IDENTITY_MAP_H_
|
|
|
|
#include "src/handles.h"
|
|
|
|
namespace v8 {
|
|
namespace internal {
|
|
|
|
// Forward declarations.
|
|
class Heap;
|
|
class Zone;
|
|
|
|
// Base class of identity maps contains shared code for all template
|
|
// instantions.
|
|
class IdentityMapBase {
|
|
protected:
|
|
// Allow Tester to access internals, including changing the address of objects
|
|
// within the {keys_} array in order to simulate a moving GC.
|
|
friend class IdentityMapTester;
|
|
|
|
typedef void** RawEntry;
|
|
|
|
IdentityMapBase(Heap* heap, Zone* zone)
|
|
: heap_(heap),
|
|
zone_(zone),
|
|
gc_counter_(-1),
|
|
size_(0),
|
|
mask_(0),
|
|
keys_(nullptr),
|
|
values_(nullptr) {}
|
|
~IdentityMapBase();
|
|
|
|
RawEntry GetEntry(Object* key);
|
|
RawEntry FindEntry(Object* key);
|
|
|
|
private:
|
|
// Internal implementation should not be called directly by subclasses.
|
|
int LookupIndex(Object* address);
|
|
int InsertIndex(Object* address);
|
|
void Rehash();
|
|
void Resize();
|
|
RawEntry Lookup(Object* key);
|
|
RawEntry Insert(Object* key);
|
|
int Hash(Object* address);
|
|
|
|
Heap* heap_;
|
|
Zone* zone_;
|
|
int gc_counter_;
|
|
int size_;
|
|
int mask_;
|
|
Object** keys_;
|
|
void** values_;
|
|
};
|
|
|
|
// Implements an identity map from object addresses to a given value type {V}.
|
|
// The map is robust w.r.t. garbage collection by synchronization with the
|
|
// supplied {heap}.
|
|
// * Keys are treated as strong roots.
|
|
// * SMIs are valid keys, except SMI #0.
|
|
// * The value type {V} must be reinterpret_cast'able to {void*}
|
|
// * The value type {V} must not be a heap type.
|
|
template <typename V>
|
|
class IdentityMap : public IdentityMapBase {
|
|
public:
|
|
IdentityMap(Heap* heap, Zone* zone) : IdentityMapBase(heap, zone) {}
|
|
|
|
// Searches this map for the given key using the object's address
|
|
// as the identity, returning:
|
|
// found => a pointer to the storage location for the value
|
|
// not found => a pointer to a new storage location for the value
|
|
V* Get(Handle<Object> key) { return Get(*key); }
|
|
V* Get(Object* key) { return reinterpret_cast<V*>(GetEntry(key)); }
|
|
|
|
// Searches this map for the given key using the object's address
|
|
// as the identity, returning:
|
|
// found => a pointer to the storage location for the value
|
|
// not found => {nullptr}
|
|
V* Find(Handle<Object> key) { return Find(*key); }
|
|
V* Find(Object* key) { return reinterpret_cast<V*>(FindEntry(key)); }
|
|
|
|
// Set the value for the given key.
|
|
void Set(Handle<Object> key, V v) { Set(*key, v); }
|
|
void Set(Object* key, V v) { *(reinterpret_cast<V*>(GetEntry(key))) = v; }
|
|
};
|
|
} // namespace internal
|
|
} // namespace v8
|
|
|
|
#endif // V8_IDENTITY_MAP_H_
|
|
|