Use a filter instead of a visitor to deoptimize selected functions in a context.

src/deoptimizer.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 69 matching lines @@
   virtual void EnterContext(Context* context) = 0;
 
   virtual void VisitFunction(JSFunction* function) = 0;
 
   // Function which is called after iteration of all optimized functions
   // from given native context.
   virtual void LeaveContext(Context* context) = 0;
 };
 
 
+class OptimizedFunctionFilter BASE_EMBEDDED {

[Sven Panne, 2012/12/12 14:31:48]

This is what is commonly called a predicate (even in STL ;-), and it might be
nicer to move this in a templatized version to utils.h. Perhaps we should even
add a unary_function template there from which can subclass.
OptimizedFunctionFilter can be a typedef if it is needed at all then.

Anyway, overloading function invocation (i.e. operator()) seems to be more
natural than making up a name like TakeFunction.

[Michael Starzinger, 2012/12/12 14:39:42]

I am fine with both solutions (a templetized filter/predicate or a type-specific
filter). Given that we already have several of these home-grown filters (e.g.
HeapObjectsFilter) I have no problem with adding another one. Having one
templetized class is also fine with me. My opinion is not strong enough to sway
either way.

[ulan_google, 2012/12/12 15:00:46]

After offline discussion, I am leaving this as it is for now.

+ public:
+  virtual ~OptimizedFunctionFilter() {}
+
+  virtual bool TakeFunction(JSFunction* function) = 0;
+};
+
+
 class Deoptimizer;
 
 
 class DeoptimizerData {
  public:
   DeoptimizerData();
   ~DeoptimizerData();
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
   void Iterate(ObjectVisitor* v);
@@ skipping 70 matching lines @@
 
   // Iterate over all the functions which share the same code object
   // and make them use unoptimized version.
   static void ReplaceCodeForRelatedFunctions(JSFunction* function, Code* code);
 
   // Deoptimize all functions in the heap.
   static void DeoptimizeAll();
 
   static void DeoptimizeGlobalObject(JSObject* object);
 
+  static void DeoptimizeAllFunctionsWith(OptimizedFunctionFilter* filter);
+
+  static void DeoptimizeAllFunctionsForContext(
+      Context* context, OptimizedFunctionFilter* filter);
+
   static void VisitAllOptimizedFunctionsForContext(
       Context* context, OptimizedFunctionVisitor* visitor);
 
-  static void VisitAllOptimizedFunctionsForGlobalObject(
-      JSObject* object, OptimizedFunctionVisitor* visitor);
-
   static void VisitAllOptimizedFunctions(OptimizedFunctionVisitor* visitor);
 
   // The size in bytes of the code required at a lazy deopt patch site.
   static int patch_size();
 
   // Patch all stack guard checks in the unoptimized code to
   // unconditionally call replacement_code.
   static void PatchStackCheckCode(Code* unoptimized_code,
                                   Code* check_code,
                                   Code* replacement_code);
@@ skipping 150 matching lines @@
                                                int max_entry_id);
   static void GenerateDeoptimizationEntries(
       MacroAssembler* masm, int count, BailoutType type);
 
   // Weak handle callback for deoptimizing code objects.
   static void HandleWeakDeoptimizedCode(
       v8::Persistent<v8::Value> obj, void* data);
   static Code* FindDeoptimizingCodeFromAddress(Address addr);
   static void RemoveDeoptimizingCode(Code* code);
 
+  // Deoptimize function assuming that function->next_function_link() points
+  // to a list that contains all functions that share the same optimized code.
+  static void DeoptimizeFunctionWithPreparedFunctionList(JSFunction* function);
+
   // Fill the input from from a JavaScript frame. This is used when
   // the debugger needs to inspect an optimized frame. For normal
   // deoptimizations the input frame is filled in generated code.
   void FillInputFrame(Address tos, JavaScriptFrame* frame);
 
   Isolate* isolate_;
   JSFunction* function_;
   Code* optimized_code_;
   unsigned bailout_id_;
   BailoutType bailout_type_;
@@ skipping 480 matching lines @@
   Object** expression_stack_;
   int source_position_;
 
   friend class Deoptimizer;
 };
 #endif
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEOPTIMIZER_H_