Remove calls to JSObject::SetLocalPropertyIgnoreAttributesTrampoline within objects.cc

src/objects.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1010 matching lines @@
     return context->symbol_function()->instance_prototype();
   }
   if (heap_object->IsBoolean()) {
     return context->boolean_function()->instance_prototype();
   } else {
     return isolate->heap()->null_value();
   }
 }
 
 
+Handle<Object> Object::GetHash(Handle<Object> object, Isolate* isolate,
+                               CreationFlag flag) {
+  CALL_HEAP_FUNCTION(isolate,
+                     object->GetHash(flag),
+                     Object);
+}
+
+
 MaybeObject* Object::GetHash(CreationFlag flag) {
   // The object is either a number, a name, an odd-ball,
   // a real JS object, or a Harmony proxy.
   if (IsNumber()) {
     uint32_t hash = ComputeLongHash(double_to_uint64(Number()));
     return Smi::FromInt(hash & Smi::kMaxValue);
   }
   if (IsName()) {
     uint32_t hash = Name::cast(this)->Hash();
     return Smi::FromInt(hash);
@@ skipping 14656 matching lines @@
   obj->set_properties(fields);
   ASSERT(obj->IsJSObject());
 
   // Check that it really works.
   ASSERT(obj->HasFastProperties());
 
   return obj;
 }
 
 
-bool ObjectHashSet::Contains(Object* key) {
-  ASSERT(IsKey(key));
-
-  // If the object does not have an identity hash, it was never used as a key.
-  { MaybeObject* maybe_hash = key->GetHash(OMIT_CREATION);
-    if (maybe_hash->ToObjectUnchecked()->IsUndefined()) return false;
-  }
-  return (FindEntry(key) != kNotFound);
+Handle<ObjectHashSet> ObjectHashSet::EnsureSetCapacity(
+    Handle<ObjectHashSet> table,
+    int n,
+    Handle<Object> key,
+    PretenureFlag pretenure) {
+  CALL_HEAP_FUNCTION(table->GetIsolate(),
+                     table->EnsureCapacity(n, *key, pretenure),
+                     ObjectHashSet);
 }
 
 
-MaybeObject* ObjectHashSet::Add(Object* key) {
-  ASSERT(IsKey(key));
-
-  // Make sure the key object has an identity hash code.
-  int hash;
-  { MaybeObject* maybe_hash = key->GetHash(ALLOW_CREATION);
-    if (maybe_hash->IsFailure()) return maybe_hash;
-    ASSERT(key->GetHash(OMIT_CREATION) == maybe_hash);
-    hash = Smi::cast(maybe_hash->ToObjectUnchecked())->value();
-  }
-  int entry = FindEntry(key);
-
-  // Check whether key is already present.
-  if (entry != kNotFound) return this;
-
-  // Check whether the hash set should be extended and add entry.
-  Object* obj;
-  { MaybeObject* maybe_obj = EnsureCapacity(1, key);
-    if (!maybe_obj->ToObject(&obj)) return maybe_obj;
-  }
-  ObjectHashSet* table = ObjectHashSet::cast(obj);
-  entry = table->FindInsertionEntry(hash);
-  table->set(EntryToIndex(entry), key);
-  table->ElementAdded();
-  return table;
+Handle<ObjectHashSet> ObjectHashSet::ShrinkSet(Handle<ObjectHashSet> table,
+                                               Handle<Object> key) {
+  CALL_HEAP_FUNCTION(table->GetIsolate(),
+                     table->Shrink(*key),
+                     ObjectHashSet);
 }
 
 
-MaybeObject* ObjectHashSet::Remove(Object* key) {
-  ASSERT(IsKey(key));
+bool ObjectHashSet::Contains(Handle<ObjectHashSet> table, Handle<Object> key) {
+  ASSERT(table->IsKey(*key));
 
-  // If the object does not have an identity hash, it was never used as a key.
-  { MaybeObject* maybe_hash = key->GetHash(OMIT_CREATION);
-    if (maybe_hash->ToObjectUnchecked()->IsUndefined()) return this;
-  }
-  int entry = FindEntry(key);
+  if (Object::GetHash(key, table->GetIsolate(), OMIT_CREATION)->IsUndefined())
+    return false;
 
-  // Check whether key is actually present.
-  if (entry == kNotFound) return this;
-
-  // Remove entry and try to shrink this hash set.
-  set_the_hole(EntryToIndex(entry));
-  ElementRemoved();
-  return Shrink(key);
+  return (table->FindEntry(*key) != kNotFound);
 }
 
 
+Handle<ObjectHashSet> ObjectHashSet::Add(Handle<ObjectHashSet> table,
+                                         Handle<Object> key) {
+  ASSERT(table->IsKey(*key));
+
+  Isolate* isolate = table->GetIsolate();
+
+  // Make sure the key object has an identity hash code.
+  Handle<Object> object_hash = Object::GetHash(key, isolate, ALLOW_CREATION);
+  ASSERT(*Object::GetHash(key, isolate, OMIT_CREATION) == *object_hash);
+
+  int hash = Smi::cast(*object_hash)->value();
+  int entry = table->FindEntry(*key);
+
+  // Check whether key is already present.
+  if (entry != kNotFound) return table;
+
+  // Check whether the hash set should be extended and add entry.
+  Handle<ObjectHashSet> new_table =
+      ObjectHashSet::EnsureSetCapacity(table, 1, key);
+  entry = new_table->FindInsertionEntry(hash);
+  new_table->set(table->EntryToIndex(entry), *key);

[rafaelw, 2013/11/04 10:58:06]

One question, this probably doesn't matter, but it seemed strange to me that the
original code was:

table->set(EntryToIndex(entry), key);

seems like it should be

table->set(table->EntryToIndex(entry), key);

or here,

new_table->set(new_table->EntryToIndex(entry), *key);

[Michael Starzinger, 2013/11/04 13:46:42]

Hmm, HashTable::EntryToIndex() should be a static function. It shouldn't need a
receiver object.

[rafaelw, 2013/11/04 15:12:01]

That makes sense. The enclosing methods are now static as well, so these calls
are now explicitly namespaced with the classname (e.g.
ObjectHashSet::EntryToIndex, in this case).

On 2013/11/04 13:46:42, Michael Starzinger wrote:

+  new_table->ElementAdded();
+  return new_table;
+}
+
+
+Handle<ObjectHashSet> ObjectHashSet::Remove(Handle<ObjectHashSet> table,
+                                            Handle<Object> key) {
+  ASSERT(table->IsKey(*key));
+
+  Isolate* isolate = table->GetIsolate();
+
+  // Make sure the key object has an identity hash code.
+  if (Object::GetHash(key, isolate, OMIT_CREATION)->IsUndefined()) return table;
+
+  int entry = table->FindEntry(*key);
+
+  // Check whether key is actually present.
+  if (entry == kNotFound) return table;
+
+  // Remove entry and try to shrink this hash set.
+  table->set_the_hole(table->EntryToIndex(entry));
+  table->ElementRemoved();
+  return ObjectHashSet::ShrinkSet(table, key);
+}
+
+
 Object* ObjectHashTable::Lookup(Object* key) {
   ASSERT(IsKey(key));
 
   // If the object does not have an identity hash, it was never used as a key.
   { MaybeObject* maybe_hash = key->GetHash(OMIT_CREATION);
     if (maybe_hash->ToObjectUnchecked()->IsUndefined()) {
       return GetHeap()->the_hole_value();
     }
   }
   int entry = FindEntry(key);
@@ skipping 621 matching lines @@
 #define ERROR_MESSAGES_TEXTS(C, T) T,
   static const char* error_messages_[] = {
       ERROR_MESSAGES_LIST(ERROR_MESSAGES_TEXTS)
   };
 #undef ERROR_MESSAGES_TEXTS
   return error_messages_[reason];
 }
 
 
 } }  // namespace v8::internal