[crankshaft] Record inlined shared function infos instead of closures.

src/liveedit.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 #include "src/v8.h"
 
 #include "src/liveedit.h"
 
 #include "src/code-stubs.h"
@@ skipping 1071 matching lines @@
       m_output->set(m_pos, fun);
       m_pos++;
     }
    private:
     Handle<FixedArray> m_output;
     int m_pos;
   };
 };
 
 
+namespace {
+
 // Check whether the code is natural function code (not a lazy-compile stub
 // code).
-static bool IsJSFunctionCode(Code* code) {
-  return code->kind() == Code::FUNCTION;
-}
+bool IsJSFunctionCode(Code* code) { return code->kind() == Code::FUNCTION; }
 
 
 // Returns true if an instance of candidate were inlined into function's code.
-static bool IsInlined(JSFunction* function, SharedFunctionInfo* candidate) {
+bool IsInlined(JSFunction* function, SharedFunctionInfo* candidate) {
   DisallowHeapAllocation no_gc;
 
   if (function->code()->kind() != Code::OPTIMIZED_FUNCTION) return false;
 
-  DeoptimizationInputData* data =
+  DeoptimizationInputData* const data =
       DeoptimizationInputData::cast(function->code()->deoptimization_data());
-
-  if (data == function->GetIsolate()->heap()->empty_fixed_array()) {
-    return false;
-  }
-
-  FixedArray* literals = data->LiteralArray();
-
-  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;
+  if (data != function->GetIsolate()->heap()->empty_fixed_array()) {
+    FixedArray* const literals = data->LiteralArray();
+    int const inlined_count = data->InlinedFunctionCount()->value();
+    for (int i = 0; i < inlined_count; ++i) {
+      if (SharedFunctionInfo::cast(literals->get(i)) == candidate) {
+        return true;
+      }
+    }
   }
 
   return false;
 }
 
+}  // namespace
+
 
 // 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_;
 
   explicit DependentFunctionMarker(SharedFunctionInfo* shared_info)
     : shared_info_(shared_info), found_(false) { }
@@ skipping 922 matching lines @@
 void LiveEditFunctionTracker::RecordRootFunctionInfo(Handle<Code> code) {
   isolate_->active_function_info_listener()->FunctionCode(code);
 }
 
 
 bool LiveEditFunctionTracker::IsActive(Isolate* isolate) {
   return isolate->active_function_info_listener() != NULL;
 }
 
 } }  // namespace v8::internal