if (inline_value->IsUndefined()) return GetHeap()->the_hole_value();
ObjectHashTable* hashtable = ObjectHashTable::cast(inline_value);
- Object* entry = hashtable->Lookup(*key);
+ Object* entry = hashtable->Lookup(key);
return entry;
}
}
-Object* ObjectHashTable::Lookup(Object* key) {
- ASSERT(IsKey(key));
+Object* ObjectHashTable::Lookup(Handle<Object> key) {
+ DisallowHeapAllocation no_gc;
+ ASSERT(IsKey(*key));
// If the object does not have an identity hash, it was never used as a key.
Object* hash = key->GetHash();
}
-Object* OrderedHashMap::Lookup(Object* key) {
- int entry = FindEntry(key);
+Object* OrderedHashMap::Lookup(Handle<Object> key) {
+ DisallowHeapAllocation no_gc;
+ int entry = FindEntry(*key);
if (entry == kNotFound) return GetHeap()->the_hole_value();
return ValueAt(entry);
}
// Looks up the value associated with the given key. The hole value is
// returned in case the key is not present.
- Object* Lookup(Object* key);
+ Object* Lookup(Handle<Object> key);
int FindEntry(Handle<Object> key);
// TODO(ishell): Remove this when all the callers are handlified.
return reinterpret_cast<OrderedHashMap*>(obj);
}
- Object* Lookup(Object* key);
+ Object* Lookup(Handle<Object> key);
static Handle<OrderedHashMap> Put(
Handle<OrderedHashMap> table,
Handle<Object> key,
CONVERT_ARG_HANDLE_CHECKED(JSMap, holder, 0);
CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
Handle<OrderedHashMap> table(OrderedHashMap::cast(holder->table()));
- Handle<Object> lookup(table->Lookup(*key), isolate);
+ Handle<Object> lookup(table->Lookup(key), isolate);
return lookup->IsTheHole() ? isolate->heap()->undefined_value() : *lookup;
}
CONVERT_ARG_HANDLE_CHECKED(JSMap, holder, 0);
CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
Handle<OrderedHashMap> table(OrderedHashMap::cast(holder->table()));
- Handle<Object> lookup(table->Lookup(*key), isolate);
+ Handle<Object> lookup(table->Lookup(key), isolate);
return isolate->heap()->ToBoolean(!lookup->IsTheHole());
}
CONVERT_ARG_HANDLE_CHECKED(JSMap, holder, 0);
CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
Handle<OrderedHashMap> table(OrderedHashMap::cast(holder->table()));
- Handle<Object> lookup(table->Lookup(*key), isolate);
+ Handle<Object> lookup(table->Lookup(key), isolate);
Handle<OrderedHashMap> new_table =
OrderedHashMap::Put(table, key, isolate->factory()->the_hole_value());
holder->set_table(*new_table);
CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
Handle<ObjectHashTable> table(
ObjectHashTable::cast(weak_collection->table()));
- Handle<Object> lookup(table->Lookup(*key), isolate);
+ Handle<Object> lookup(table->Lookup(key), isolate);
return lookup->IsTheHole() ? isolate->heap()->undefined_value() : *lookup;
}
CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
Handle<ObjectHashTable> table(
ObjectHashTable::cast(weak_collection->table()));
- Handle<Object> lookup(table->Lookup(*key), isolate);
+ Handle<Object> lookup(table->Lookup(key), isolate);
return isolate->heap()->ToBoolean(!lookup->IsTheHole());
}
CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
Handle<ObjectHashTable> table(ObjectHashTable::cast(
weak_collection->table()));
- Handle<Object> lookup(table->Lookup(*key), isolate);
+ Handle<Object> lookup(table->Lookup(key), isolate);
Handle<ObjectHashTable> new_table =
ObjectHashTable::Put(table, key, isolate->factory()->the_hole_value());
weak_collection->set_table(*new_table);
Handle<JSObject> b = factory->NewJSArray(11);
table = HashMap::Put(table, a, b);
CHECK_EQ(table->NumberOfElements(), 1);
- CHECK_EQ(table->Lookup(*a), *b);
- CHECK_EQ(table->Lookup(*b), CcTest::heap()->the_hole_value());
+ CHECK_EQ(table->Lookup(a), *b);
+ CHECK_EQ(table->Lookup(b), CcTest::heap()->the_hole_value());
// Keys still have to be valid after objects were moved.
CcTest::heap()->CollectGarbage(NEW_SPACE);
CHECK_EQ(table->NumberOfElements(), 1);
- CHECK_EQ(table->Lookup(*a), *b);
- CHECK_EQ(table->Lookup(*b), CcTest::heap()->the_hole_value());
+ CHECK_EQ(table->Lookup(a), *b);
+ CHECK_EQ(table->Lookup(b), CcTest::heap()->the_hole_value());
// Keys that are overwritten should not change number of elements.
table = HashMap::Put(table, a, factory->NewJSArray(13));
CHECK_EQ(table->NumberOfElements(), 1);
- CHECK_NE(table->Lookup(*a), *b);
+ CHECK_NE(table->Lookup(a), *b);
// Keys mapped to the hole should be removed permanently.
table = HashMap::Put(table, a, factory->the_hole_value());
CHECK_EQ(table->NumberOfElements(), 0);
- CHECK_EQ(table->Lookup(*a), CcTest::heap()->the_hole_value());
+ CHECK_EQ(table->Lookup(a), CcTest::heap()->the_hole_value());
// Keys should map back to their respective values and also should get
// an identity hash code generated.
table = HashMap::Put(table, key, value);
CHECK_EQ(table->NumberOfElements(), i + 1);
CHECK_NE(table->FindEntry(*key), HashMap::kNotFound);
- CHECK_EQ(table->Lookup(*key), *value);
+ CHECK_EQ(table->Lookup(key), *value);
CHECK(key->GetIdentityHash()->IsSmi());
}
Handle<JSReceiver> key = factory->NewJSArray(7);
CHECK(JSReceiver::GetOrCreateIdentityHash(key)->IsSmi());
CHECK_EQ(table->FindEntry(*key), HashMap::kNotFound);
- CHECK_EQ(table->Lookup(*key), CcTest::heap()->the_hole_value());
+ CHECK_EQ(table->Lookup(key), CcTest::heap()->the_hole_value());
CHECK(key->GetIdentityHash()->IsSmi());
}
// should not get an identity hash code generated.
for (int i = 0; i < 100; i++) {
Handle<JSReceiver> key = factory->NewJSArray(7);
- CHECK_EQ(table->Lookup(*key), CcTest::heap()->the_hole_value());
+ CHECK_EQ(table->Lookup(key), CcTest::heap()->the_hole_value());
CHECK_EQ(key->GetIdentityHash(),
CcTest::heap()->undefined_value());
}
}
int lookup(int key) {
- return Smi::cast(Lookup(Smi::FromInt(key)))->value();
+ Handle<Object> key_obj(Smi::FromInt(key), GetIsolate());
+ return Smi::cast(Lookup(key_obj))->value();
}
int capacity() {
SimulateFullSpace(CcTest::heap()->old_pointer_space());
// Calling Lookup() should not cause GC ever.
- CHECK(table->Lookup(*key)->IsTheHole());
+ CHECK(table->Lookup(key)->IsTheHole());
// Calling Put() should request GC by returning a failure.
int gc_count = isolate->heap()->gc_count();
Handle<Map> map = factory->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
Handle<JSObject> obj = factory->NewJSObjectFromMap(map);
Handle<JSObject> val = factory->NewJSObjectFromMap(map);
- CHECK(ordered_map->Lookup(*obj)->IsTheHole());
+ CHECK(ordered_map->Lookup(obj)->IsTheHole());
ordered_map = OrderedHashMap::Put(ordered_map, obj, val);
CHECK_EQ(1, ordered_map->NumberOfElements());
- CHECK(ordered_map->Lookup(*obj)->SameValue(*val));
+ CHECK(ordered_map->Lookup(obj)->SameValue(*val));
ordered_map = OrderedHashMap::Put(
ordered_map, obj, factory->the_hole_value());
CHECK_EQ(0, ordered_map->NumberOfElements());
- CHECK(ordered_map->Lookup(*obj)->IsTheHole());
+ CHECK(ordered_map->Lookup(obj)->IsTheHole());
// Test for collisions/chaining
Handle<JSObject> obj1 = factory->NewJSObjectFromMap(map);
ordered_map = OrderedHashMap::Put(ordered_map, obj2, val2);
ordered_map = OrderedHashMap::Put(ordered_map, obj3, val3);
CHECK_EQ(3, ordered_map->NumberOfElements());
- CHECK(ordered_map->Lookup(*obj1)->SameValue(*val1));
- CHECK(ordered_map->Lookup(*obj2)->SameValue(*val2));
- CHECK(ordered_map->Lookup(*obj3)->SameValue(*val3));
+ CHECK(ordered_map->Lookup(obj1)->SameValue(*val1));
+ CHECK(ordered_map->Lookup(obj2)->SameValue(*val2));
+ CHECK(ordered_map->Lookup(obj3)->SameValue(*val3));
// Test iteration
CheckIterResultObject(
Handle<JSObject> obj4 = factory->NewJSObjectFromMap(map);
Handle<JSObject> val4 = factory->NewJSObjectFromMap(map);
ordered_map = OrderedHashMap::Put(ordered_map, obj4, val4);
- CHECK(ordered_map->Lookup(*obj)->SameValue(*val));
- CHECK(ordered_map->Lookup(*obj1)->SameValue(*val1));
- CHECK(ordered_map->Lookup(*obj2)->SameValue(*val2));
- CHECK(ordered_map->Lookup(*obj3)->SameValue(*val3));
- CHECK(ordered_map->Lookup(*obj4)->SameValue(*val4));
+ CHECK(ordered_map->Lookup(obj)->SameValue(*val));
+ CHECK(ordered_map->Lookup(obj1)->SameValue(*val1));
+ CHECK(ordered_map->Lookup(obj2)->SameValue(*val2));
+ CHECK(ordered_map->Lookup(obj3)->SameValue(*val3));
+ CHECK(ordered_map->Lookup(obj4)->SameValue(*val4));
CHECK_EQ(5, ordered_map->NumberOfElements());
CHECK_EQ(4, ordered_map->NumberOfBuckets());