Clear optimized code cache in shared function info when code gets deoptimized

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 9613 matching lines @@
   if (!code_map->get(kNextMapIndex)->IsUndefined()) {
     CodeFlusher* flusher = GetHeap()->mark_compact_collector()->code_flusher();
     flusher->EvictOptimizedCodeMap(this);
   }
 
   ASSERT(code_map->get(kNextMapIndex)->IsUndefined());
   set_optimized_code_map(Smi::FromInt(0));
 }
 
 
-void SharedFunctionInfo::EvictFromOptimizedCodeMap(Context* context,
+void SharedFunctionInfo::EvictFromOptimizedCodeMap(Code* optimized_code,
                                                    const char* reason) {
-  ASSERT(context->IsNativeContext());
   if (optimized_code_map()->IsSmi()) return;
 
+  int i;
+  bool removed_entry = false;
   FixedArray* code_map = FixedArray::cast(optimized_code_map());
-  int dst = kEntriesStart;
-  int length = code_map->length();
-  for (int src = kEntriesStart; src < length; src += kEntryLength) {
-    Context* context_key = Context::cast(code_map->get(src));
-    ASSERT(context->IsNativeContext());
-    if (context_key == context) {
+  for (i = kEntriesStart; i < code_map->length(); i += kEntryLength) {

[titzer, 2014/03/03 12:02:44]

This code is relying on the code appearing only once in this optimized code map,
which is an invariant that should hold, but based on my investigation, looks
quite fragile.

Can we put an extra level of checking in this loop?

I.e. either go through the entire map and remove _all_ occurrences, or assert
there is only one.

I would prefer the former, since we have to loop over the entire array anyway,
even if we found it.

+    ASSERT(code_map->get(i)->IsNativeContext());
+    if (Code::cast(code_map->get(i + 1)) == optimized_code) {

[titzer, 2014/03/03 12:02:44]

Please use kCachedCodeOffset here.

       if (FLAG_trace_opt) {
         PrintF("[evicting entry from optimizing code map (%s) for ", reason);
         ShortPrint();
-        BailoutId osr(Smi::cast(code_map->get(src + kOsrAstIdOffset))->value());
-        if (osr.IsNone()) {
-          PrintF("]\n");
-        } else {
-          PrintF(" (osr ast id %d)]\n", osr.ToInt());
-        }
+        PrintF("]\n");
       }
-      continue;
+      removed_entry = true;
+      break;
     }
-    if (dst != src) {
-      code_map->set(dst + kContextOffset,
-                    code_map->get(src + kContextOffset));
-      code_map->set(dst + kCachedCodeOffset,
-                    code_map->get(src + kCachedCodeOffset));
-      code_map->set(dst + kLiteralsOffset,
-                    code_map->get(src + kLiteralsOffset));
-      code_map->set(dst + kOsrAstIdOffset,
-                    code_map->get(src + kOsrAstIdOffset));
+  }
+  while (i < (code_map->length() - kEntryLength)) {
+    code_map->set(i + kContextOffset,
+                  code_map->get(i + kContextOffset + kEntryLength));
+    code_map->set(i + kCachedCodeOffset,
+                  code_map->get(i + kCachedCodeOffset + kEntryLength));
+    code_map->set(i + kLiteralsOffset,
+                  code_map->get(i + kLiteralsOffset + kEntryLength));
+    code_map->set(i + kOsrAstIdOffset,
+                  code_map->get(i + kOsrAstIdOffset + kEntryLength));
+    i += kEntryLength;
+  }
+  if (removed_entry) {
+    // Always trim even when array is cleared because of heap verifier.
+    RightTrimFixedArray<FROM_MUTATOR>(GetHeap(), code_map, kEntryLength);
+    if (code_map->length() == kEntriesStart) {
+      ClearOptimizedCodeMap();
     }
-    dst += kEntryLength;
-  }
-  if (dst != length) {
-    // Always trim even when array is cleared because of heap verifier.
-    RightTrimFixedArray<FROM_MUTATOR>(GetHeap(), code_map, length - dst);
-    if (code_map->length() == kEntriesStart) ClearOptimizedCodeMap();
   }
 }
 
 
 void SharedFunctionInfo::TrimOptimizedCodeMap(int shrink_by) {
   FixedArray* code_map = FixedArray::cast(optimized_code_map());
   ASSERT(shrink_by % kEntryLength == 0);
   ASSERT(shrink_by <= code_map->length() - kEntriesStart);
   // Always trim even when array is cleared because of heap verifier.
   RightTrimFixedArray<FROM_GC>(GetHeap(), code_map, shrink_by);
@@ skipping 6812 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