Add OptimizedCodeList and DeoptimizedCodeList to native contexts. Both lists are weak. This makes i…

src/liveedit.cc

 // 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 1224 matching lines @@
   int inlined_count = data->InlinedFunctionCount()->value();
   for (int i = 0; i < inlined_count; ++i) {
     JSFunction* inlined = JSFunction::cast(literals->get(i));
     if (inlined->shared() == candidate) return true;
   }
 
   return false;
 }
 
 
-class DependentFunctionFilter : public OptimizedFunctionFilter {
- public:
-  explicit DependentFunctionFilter(
-      SharedFunctionInfo* function_info)
-      : function_info_(function_info) {}
+static void DeoptimizeDependentFunctions(SharedFunctionInfo* function_info) {
+  // Marks code that shares the same shared function info or has inlined
+  // code that shares the same function info.
+  class DependentFunctionMarker: public OptimizedFunctionVisitor {
+   public:
+    SharedFunctionInfo* shared_info_;
+    bool found_;
 
-  virtual bool TakeFunction(JSFunction* function) {
-    return (function->shared() == function_info_ ||
-            IsInlined(function, function_info_));
-  }
+    explicit DependentFunctionMarker(SharedFunctionInfo* shared_info)
+      : shared_info_(shared_info), found_(false) { }
 
- private:
-  SharedFunctionInfo* function_info_;
-};
+    virtual void EnterContext(Context* context) { }  // Don't care.
+    virtual void LeaveContext(Context* context)  { }  // Don't care.
+    virtual void VisitFunction(JSFunction* function) {
+      // It should be guaranteed by the iterator that everything is optimized.
+      ASSERT(function->code()->kind() == Code::OPTIMIZED_FUNCTION);
+      if (shared_info_ == function->shared() ||
+          IsInlined(function, shared_info_)) {
+        // mark the code for deoptimization
+        function->code()->set_marked_for_deoptimization(true);
+        found_ = true;
+      }
+    }
+  };
 
 
-static void DeoptimizeDependentFunctions(SharedFunctionInfo* function_info) {
   DisallowHeapAllocation no_allocation;
+  DependentFunctionMarker marker(function_info);
+  // TODO(titzer): need to traverse all optimized code to find OSR code here.
+  Deoptimizer::VisitAllOptimizedFunctions(function_info->GetIsolate(), &marker);
 
-  DependentFunctionFilter filter(function_info);
-  Deoptimizer::DeoptimizeAllFunctionsWith(function_info->GetIsolate(), &filter);
+  if (marker.found_) {
+    // Only go through with the deoptimization if something was found.
+    Deoptimizer::DeoptimizeMarkedCode(function_info->GetIsolate());
+  }
 }
 
 
 MaybeObject* LiveEdit::ReplaceFunctionCode(
     Handle<JSArray> new_compile_info_array,
     Handle<JSArray> shared_info_array) {
   Isolate* isolate = Isolate::Current();
   HandleScope scope(isolate);
 
   if (!SharedInfoWrapper::IsInstance(shared_info_array)) {
@@ skipping 852 matching lines @@
 
 bool LiveEditFunctionTracker::IsActive(Isolate* isolate) {
   return false;
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
 
 } }  // namespace v8::internal