Backport @10366 to 3.6

src/stub-cache.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 842 matching lines @@
           map_holder->UpdateMapCodeCache(name, Code::cast(code));
       if (!maybe_result->ToObject(&result)) return maybe_result;
     }
   }
   return code;
 }
 
 
 static Object* GetProbeValue(Isolate* isolate, Code::Flags flags) {
   // Use raw_unchecked... so we don't get assert failures during GC.
-  NumberDictionary* dictionary =
+  UnseededNumberDictionary* dictionary =
       isolate->heap()->raw_unchecked_non_monomorphic_cache();
   int entry = dictionary->FindEntry(isolate, flags);
   if (entry != -1) return dictionary->ValueAt(entry);
   return isolate->heap()->raw_unchecked_undefined_value();
 }
 
 
 MUST_USE_RESULT static MaybeObject* ProbeCache(Isolate* isolate,
                                                Code::Flags flags) {
   Heap* heap = isolate->heap();
   Object* probe = GetProbeValue(isolate, flags);
   if (probe != heap->undefined_value()) return probe;
   // Seed the cache with an undefined value to make sure that any
   // generated code object can always be inserted into the cache
   // without causing  allocation failures.
   Object* result;
   { MaybeObject* maybe_result =
         heap->non_monomorphic_cache()->AtNumberPut(flags,
                                                    heap->undefined_value());
     if (!maybe_result->ToObject(&result)) return maybe_result;
   }
-  heap->public_set_non_monomorphic_cache(NumberDictionary::cast(result));
+  heap->public_set_non_monomorphic_cache(
+      UnseededNumberDictionary::cast(result));
   return probe;
 }
 
 
 static MaybeObject* FillCache(Isolate* isolate, MaybeObject* maybe_code) {
   Object* code;
   if (maybe_code->ToObject(&code)) {
     if (code->IsCode()) {
       Heap* heap = isolate->heap();
       int entry = heap->non_monomorphic_cache()->FindEntry(
@@ skipping 937 matching lines @@
       expected_receiver_type_ =
           FunctionTemplateInfo::cast(signature->receiver());
     }
   }
 
   is_simple_api_call_ = true;
 }
 
 
 } }  // namespace v8::internal