Remove calls to JSObject::SetLocalPropertyIgnoreAttributesTrampoline within objects.cc

src/objects.h

 // Copyright 2012 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 1494 matching lines @@
   MUST_USE_RESULT MaybeObject* GetElementWithReceiver(Isolate* isolate,
                                                       Object* receiver,
                                                       uint32_t index);
 
   // Return the object's prototype (might be Heap::null_value()).
   Object* GetPrototype(Isolate* isolate);
 
   // Returns the permanent hash code associated with this object depending on
   // the actual object type.  Might return a failure in case no hash was
   // created yet or GC was caused by creation.
+  static Handle<Object> GetHash(Handle<Object> object, Isolate* isolate,

[Michael Starzinger, 2013/11/04 10:29:11]

nit: The current implementation as a wrapper requires the isolate parameter.
Once the implementation is fully handlified the isolate parameter is no longer
needed. Let's add a TODO to keep that in mind.

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

Done (although this todo is now on GetOrCreateHash

+                                CreationFlag flag);
+
   MUST_USE_RESULT MaybeObject* GetHash(CreationFlag flag);
 
   // Checks whether this object has the same value as the given one.  This
   // function is implemented according to ES5, section 9.12 and can be used
   // to implement the Harmony "egal" function.
   bool SameValue(Object* other);
 
   // Tries to convert an object to an array index.  Returns true and sets
   // the output parameter if it succeeds.
   inline bool ToArrayIndex(uint32_t* index);
@@ skipping 2528 matching lines @@
 // ObjectHashSet holds keys that are arbitrary objects by using the identity
 // hash of the key for hashing purposes.
 class ObjectHashSet: public HashTable<ObjectHashTableShape<1>, Object*> {
  public:
   static inline ObjectHashSet* cast(Object* obj) {
     ASSERT(obj->IsHashTable());
     return reinterpret_cast<ObjectHashSet*>(obj);
   }
 
   // Looks up whether the given key is part of this hash set.
-  bool Contains(Object* key);
+  static bool Contains(Handle<ObjectHashSet> table, Handle<Object> key);

[Michael Starzinger, 2013/11/04 10:29:11]

The ObjectHashSet::Contains method should never cause an allocation, it should
be possible to leave this one un-handlified.

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

Done.

+
+  static Handle<ObjectHashSet> EnsureSetCapacity(

[rafaelw, 2013/10/29 19:14:51]

Note that I've named this "EnsureSetCapacity" because I can't figure out how to
get the C++ compiler to stop complaining because in the CALL_HEAP_FUNCTION
implementation, it seems to be trying to invoke the static method (forgetting
about the inherted templatized method from HashTable.

I'm hoping you know what the solution to this is. Same problem below with
ShrinkSet.

[Michael Starzinger, 2013/11/04 10:29:11]

One way to address that I can think of would be to add an explicit up-cast into
the implementation of ObjectHashSet::EnsureSetCapacity like this ...

Handle<HashTable<ObjectHashTableShape<1>, Object*> > table_base = table;

Unfortunately this will lead to access violations because
HashTable::EnsureSetCapacity is protected. But I think we can bake ObjectHashSet
a friend of HashTable to resolve this.

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

Done. Applied to ObjectHash(Set/Table)::(EnsureCapacity/Shrink)

On 2013/11/04 10:29:11, Michael Starzinger wrote:

+      Handle<ObjectHashSet> table,
+      int n,
+      Handle<Object> key,
+      PretenureFlag pretenure = NOT_TENURED);
+
+  // Attempt to shrink hash table after removal of key.
+  static Handle<ObjectHashSet> ShrinkSet(Handle<ObjectHashSet> table,
+                                         Handle<Object> key);
 
   // Adds the given key to this hash set.
-  MUST_USE_RESULT MaybeObject* Add(Object* key);
+  static Handle<ObjectHashSet> Add(Handle<ObjectHashSet> table,
+                                   Handle<Object> key);
 
   // Removes the given key from this hash set.
-  MUST_USE_RESULT MaybeObject* Remove(Object* key);
+  static Handle<ObjectHashSet> Remove(Handle<ObjectHashSet> table,
+                                      Handle<Object> key);
 };
 
 
 // ObjectHashTable maps keys that are arbitrary objects to object values by
 // using the identity hash of the key for hashing purposes.
 class ObjectHashTable: public HashTable<ObjectHashTableShape<2>, Object*> {
  public:
   static inline ObjectHashTable* cast(Object* obj) {
     ASSERT(obj->IsHashTable());
     return reinterpret_cast<ObjectHashTable*>(obj);
@@ skipping 6360 matching lines @@
     } else {
       value &= ~(1 << bit_position);
     }
     return value;
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_H_