Refactoring only: Extracted a method for finding optimized code.

src/deoptimizer.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 459 matching lines @@
   }
 #endif
 }
 
 
 void Deoptimizer::ComputeOutputFrames(Deoptimizer* deoptimizer) {
   deoptimizer->DoComputeOutputFrames();
 }
 
 
+static Code* FindOptimizedCode(Isolate* isolate,
+                               JSFunction* function,
+                               Deoptimizer::BailoutType type,
+                               Address from,
+                               Code* optimized_code) {
+  switch (type) {
+    case Deoptimizer::EAGER:
+      ASSERT(from == NULL);
+      return function->code();
+    case Deoptimizer::LAZY: {
+      Code* compiled_code =
+          isolate->deoptimizer_data()->FindDeoptimizingCode(from);
+      return (compiled_code == NULL)
+          ? static_cast<Code*>(isolate->heap()->FindCodeObject(from))
+          : compiled_code;
+    }
+    case Deoptimizer::OSR: {
+      // The function has already been optimized and we're transitioning
+      // from the unoptimized shared version to the optimized one in the
+      // function. The return address (from) points to unoptimized code.
+      Code* compiled_code = function->code();
+      ASSERT(compiled_code->kind() == Code::OPTIMIZED_FUNCTION);
+      ASSERT(!compiled_code->contains(from));
+      return compiled_code;
+    }
+    case Deoptimizer::DEBUGGER:
+      ASSERT(optimized_code->contains(from));
+      return optimized_code;
+  }
+  UNREACHABLE();
+  return NULL;
+}
+
+
 Deoptimizer::Deoptimizer(Isolate* isolate,
                          JSFunction* function,
                          BailoutType type,
                          unsigned bailout_id,
                          Address from,
                          int fp_to_sp_delta,
                          Code* optimized_code)
     : isolate_(isolate),
       function_(function),
       bailout_id_(bailout_id),
@@ skipping 28 matching lines @@
            fp_to_sp_delta - (2 * kPointerSize));
   }
   // For COMPILED_STUBs called from builtins, the function pointer
   // is a SMI indicating an internal frame.
   if (function->IsSmi()) {
     function = NULL;
   }
   if (function != NULL && function->IsOptimized()) {
     function->shared()->increment_deopt_count();
   }
-  // Find the optimized code.
-  if (type == EAGER) {
-    ASSERT(from == NULL);
-    compiled_code_ = function_->code();
-    if (FLAG_trace_deopt) compiled_code_->PrintDeoptLocation(bailout_id);
-  } else if (type == LAZY) {
-    compiled_code_ = isolate->deoptimizer_data()->FindDeoptimizingCode(from);
-    if (compiled_code_ == NULL) {
-      compiled_code_ =
-          static_cast<Code*>(isolate->heap()->FindCodeObject(from));
-    }
-    ASSERT(compiled_code_ != NULL);
-  } else if (type == OSR) {
-    // The function has already been optimized and we're transitioning
-    // from the unoptimized shared version to the optimized one in the
-    // function. The return address (from) points to unoptimized code.
-    compiled_code_ = function_->code();
-    ASSERT(compiled_code_->kind() == Code::OPTIMIZED_FUNCTION);
-    ASSERT(!compiled_code_->contains(from));
-  } else if (type == DEBUGGER) {
-    compiled_code_ = optimized_code;
-    ASSERT(compiled_code_->contains(from));
+  compiled_code_ =
+      FindOptimizedCode(isolate, function, type, from, optimized_code);
+  if (FLAG_trace_deopt && type == EAGER) {
+    compiled_code_->PrintDeoptLocation(bailout_id);
   }
   ASSERT(HEAP->allow_allocation(false));
   unsigned size = ComputeInputFrameSize();
   input_ = new(size) FrameDescription(size, function);
   input_->SetFrameType(StackFrame::JAVA_SCRIPT);
 }
 
 
 Deoptimizer::~Deoptimizer() {
   ASSERT(input_ == NULL && output_ == NULL);
@@ skipping 1511 matching lines @@
 
 void DeoptimizedFrameInfo::Iterate(ObjectVisitor* v) {
   v->VisitPointer(BitCast<Object**>(&function_));
   v->VisitPointers(parameters_, parameters_ + parameters_count_);
   v->VisitPointers(expression_stack_, expression_stack_ + expression_count_);
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal