ef93854ab9
Moves the temporary register allocator out of the bytecode array builder into TemporaryRegisterAllocator class and adds unittests. Particular must be taken around the translation window boundary motivating the addition of tests. Also adds a Clear() method to IdentityMap() which is called by the destructor. This allows classes to hold an IdentityMap if they are zone allocated. Classes must call Clear() before the zone is re-cycled or face v8 heap corruption. BUG=v8:4280,v8:4675 LOG=N Review URL: https://codereview.chromium.org/1651133002 Cr-Commit-Position: refs/heads/master@{#33686}
97 lines
2.8 KiB
C++
97 lines
2.8 KiB
C++
// 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);
|
|
void Clear();
|
|
|
|
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; }
|
|
|
|
// Removes all elements from the map.
|
|
void Clear() { IdentityMapBase::Clear(); }
|
|
};
|
|
} // namespace internal
|
|
} // namespace v8
|
|
|
|
#endif // V8_IDENTITY_MAP_H_
|