Handlify KeyedIC::ComputeStub.

src/objects.cc

 // Copyright 2011 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 2172 matching lines @@
 
 // If |map| is contained in |maps_list|, returns |map|; otherwise returns NULL.
 static bool ContainsMap(MapList* maps_list, Map* map) {
   for (int i = 0; i < maps_list->length(); ++i) {
     if (maps_list->at(i) == map) return true;
   }
   return false;
 }
 
 
+Handle<Map> Map::FindTransitionedMap(MapHandleList* candidates) {
+  MapList raw_candidates(candidates->length());
+  Map* result = FindTransitionedMap(UnwrapHandleList(&raw_candidates,
+                                                     candidates));
+  return (result == NULL) ? Handle<Map>::null() : Handle<Map>(result);
+}
+
+
 Map* Map::FindTransitionedMap(MapList* candidates) {
   ElementsKind elms_kind = elements_kind();
   if (elms_kind == FAST_DOUBLE_ELEMENTS) {
     bool dummy = true;
     Map* fast_map = LookupElementsTransitionMap(FAST_ELEMENTS, &dummy);
     if (fast_map == NULL) return NULL;
     if (ContainsMap(candidates, fast_map)) return fast_map;
     return NULL;
   }
   if (elms_kind == FAST_SMI_ONLY_ELEMENTS) {
@@ skipping 187 matching lines @@
   MaybeObject* maybe_new_descriptors =
       instance_descriptors()->CopyInsert(&desc, KEEP_TRANSITIONS);
   if (!maybe_new_descriptors->ToObject(&new_descriptors)) {
     return maybe_new_descriptors;
   }
   set_instance_descriptors(DescriptorArray::cast(new_descriptors));
   return this;
 }
 
 
+Handle<Map> JSObject::GetElementsTransitionMap(Handle<JSObject> object,
+                                               ElementsKind to_kind) {
+  Isolate* isolate = object->GetIsolate();
+  CALL_HEAP_FUNCTION(isolate,
+                     object->GetElementsTransitionMap(to_kind),
+                     Map);
+}
+
+
 MaybeObject* JSObject::GetElementsTransitionMap(ElementsKind to_kind) {
   Map* current_map = map();
   ElementsKind from_kind = current_map->elements_kind();
 
   if (from_kind == to_kind) return current_map;
 
   // Only objects with FastProperties can have DescriptorArrays and can track
   // element-related maps. Also don't add descriptors to maps that are shared.
   bool safe_to_add_transition = HasFastProperties() &&
       !current_map->IsUndefined() &&
@@ skipping 2707 matching lines @@
 
 void CodeCacheHashTable::RemoveByIndex(int index) {
   ASSERT(index >= 0);
   Heap* heap = GetHeap();
   set(EntryToIndex(index), heap->null_value());
   set(EntryToIndex(index) + 1, heap->null_value());
   ElementRemoved();
 }
 
 
+void PolymorphicCodeCache::Update(Handle<PolymorphicCodeCache> cache,
+                                  MapHandleList* maps,
+                                  Code::Flags flags,
+                                  Handle<Code> code) {
+  Isolate* isolate = cache->GetIsolate();
+  List<Map*> raw_maps(maps->length());
+  CALL_HEAP_FUNCTION_VOID(
+      isolate,
+      (raw_maps.Clear(),

[Kevin Millikin (Chromium), 2011/10/21 10:13:48]

That's a bit annoying, but unavoidable.  I suppose you could give
UnwrapHandleList the semantics of clearing destination, but that seems wrong.

+       cache->Update(UnwrapHandleList(&raw_maps, maps), flags, *code)));
+}
+
+
 MaybeObject* PolymorphicCodeCache::Update(MapList* maps,
                                           Code::Flags flags,
                                           Code* code) {
   // Initialize cache if necessary.
   if (cache()->IsUndefined()) {
     Object* result;
     { MaybeObject* maybe_result =
           PolymorphicCodeCacheHashTable::Allocate(
               PolymorphicCodeCacheHashTable::kInitialSize);
       if (!maybe_result->ToObject(&result)) return maybe_result;
     }
     set_cache(result);
   } else {
     // This entry shouldn't be contained in the cache yet.
     ASSERT(PolymorphicCodeCacheHashTable::cast(cache())
                ->Lookup(maps, flags)->IsUndefined());
   }
   PolymorphicCodeCacheHashTable* hash_table =
       PolymorphicCodeCacheHashTable::cast(cache());
   Object* new_cache;
   { MaybeObject* maybe_new_cache = hash_table->Put(maps, flags, code);
     if (!maybe_new_cache->ToObject(&new_cache)) return maybe_new_cache;
   }
   set_cache(new_cache);
   return this;
 }
 
 
+Handle<Object> PolymorphicCodeCache::Lookup(MapHandleList* maps,
+                                            Code::Flags flags) {
+  List<Map*> raw_maps(maps->length());
+  return Handle<Object>(Lookup(UnwrapHandleList(&raw_maps, maps), flags));
+}
+
+
 Object* PolymorphicCodeCache::Lookup(MapList* maps, Code::Flags flags) {
   if (!cache()->IsUndefined()) {
     PolymorphicCodeCacheHashTable* hash_table =
         PolymorphicCodeCacheHashTable::cast(cache());
     return hash_table->Lookup(maps, flags);
   } else {
     return GetHeap()->undefined_value();
   }
 }
 
@@ skipping 7417 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single break point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
 } }  // namespace v8::internal