Lazy deoptimization for comparisons in Turbofan.

src/compiler/linkage-impl.h

 // Copyright 2014 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.
 
 #ifndef V8_COMPILER_LINKAGE_IMPL_H_
 #define V8_COMPILER_LINKAGE_IMPL_H_
 
 namespace v8 {
 namespace internal {
 namespace compiler {
@@ skipping 53 matching lines @@
                        Operator::kNoProperties,          // properties
                        kNoCalleeSaved,  // callee-saved registers
                        CallDescriptor::kNeedsFrameState);  // flags
   }
 
 
   // TODO(turbofan): cache call descriptors for runtime calls.
   template <typename LinkageTraits>
   static CallDescriptor* GetRuntimeCallDescriptor(
       Zone* zone, Runtime::FunctionId function_id, int parameter_count,
-      Operator::Property properties, CallDescriptor::Flags flags) {
+      Operator::Property properties) {
     const int code_count = 1;
     const int function_count = 1;
     const int num_args_count = 1;
     const int context_count = 1;
     const int input_count = code_count + parameter_count + function_count +
                             num_args_count + context_count;
 
     const Runtime::Function* function = Runtime::FunctionForId(function_id);
     const int return_count = function->result_size;
     LinkageLocation* locations =
@@ skipping 17 matching lines @@
       // All parameters to runtime calls go on the stack.
       int spill_slot_index = i - parameter_count;
       locations[index++] = TaggedStackSlot(spill_slot_index);
     }
     locations[index++] =
         TaggedRegisterLocation(LinkageTraits::RuntimeCallFunctionReg());
     locations[index++] =
         WordRegisterLocation(LinkageTraits::RuntimeCallArgCountReg());
     locations[index++] = TaggedRegisterLocation(LinkageTraits::ContextReg());
 
+    CallDescriptor::Flags flags = Linkage::NeedsFrameState(function_id)
+                                      ? CallDescriptor::kNeedsFrameState
+                                      : CallDescriptor::kNoFlags;
+
     // TODO(titzer): refactor TurboFan graph to consider context a value input.
     return new (zone) CallDescriptor(CallDescriptor::kCallCodeObject,  // kind
                                      return_count,     // return_count
                                      parameter_count,  // parameter_count
                                      input_count,      // input_count
                                      locations,        // locations
                                      properties,       // properties
                                      kNoCalleeSaved,   // callee-saved registers
                                      flags,            // flags
                                      function->name);
@@ skipping 67 matching lines @@
     for (; i < num_params; i++) {
       locations[index++] = LinkageLocation(param_types[i], -1 - i);
     }
     return new (zone) CallDescriptor(
         CallDescriptor::kCallAddress, 1, num_params, num_params + 1, locations,
         Operator::kNoProperties, LinkageTraits::CCalleeSaveRegisters(),
         CallDescriptor::kNoFlags);  // TODO(jarin) should deoptimize!
   }
 };
 
+
+bool Linkage::NeedsFrameState(Runtime::FunctionId function) {
+  if (!FLAG_turbo_deoptimization) {
+    return false;
+  }
+  // TODO(jarin) At the moment, we only add frame state for
+  // few chosen runtime functions.
+  switch (function) {
+    case Runtime::kDebugBreak:
+    case Runtime::kDeoptimizeFunction:
+    case Runtime::kSetScriptBreakPoint:
+    case Runtime::kDebugGetLoadedScripts:
+    case Runtime::kStackGuard:
+      return true;
+    default:
+      return false;
+  }
+}
+
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_LINKAGE_IMPL_H_