[turbofan] Explicitly mark call sites as patchable.

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 46 matching lines @@
 
     // TODO(titzer): refactor TurboFan graph to consider context a value input.
     return new (zone)
         CallDescriptor(CallDescriptor::kCallJSFunction,  // kind
                        return_count,                     // return_count
                        parameter_count,                  // parameter_count
                        input_count - context_count,      // input_count
                        locations,                        // locations
                        Operator::kNoProperties,          // properties
                        kNoCalleeSaved,  // callee-saved registers
-                       CallDescriptor::kLazyDeoptimization);  // deoptimization
+                       CallDescriptor::kLazyDeoptimization);  // 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::DeoptimizationSupport can_deoptimize) {
+      Operator::Property properties, CallDescriptor::Flags flags) {
     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 25 matching lines @@
     locations[index++] = TaggedRegisterLocation(LinkageTraits::ContextReg());
 
     // 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
-                                     can_deoptimize,   // deoptimization
+                                     flags,            // flags
                                      function->name);
   }
 
 
   // TODO(turbofan): cache call descriptors for code stub calls.
   template <typename LinkageTraits>
   static CallDescriptor* GetStubCallDescriptor(
       Zone* zone, CodeStubInterfaceDescriptor* descriptor,
-      int stack_parameter_count,
-      CallDescriptor::DeoptimizationSupport can_deoptimize) {
+      int stack_parameter_count, CallDescriptor::Flags flags) {
     int register_parameter_count = descriptor->GetEnvironmentParameterCount();
     int parameter_count = register_parameter_count + stack_parameter_count;
     const int code_count = 1;
     const int context_count = 1;
     int input_count = code_count + parameter_count + context_count;
 
     const int return_count = 1;
     LinkageLocation* locations =
         zone->NewArray<LinkageLocation>(return_count + input_count);
 
@@ skipping 16 matching lines @@
 
     // 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
                        Operator::kNoProperties,          // properties
                        kNoCalleeSaved,  // callee-saved registers
-                       can_deoptimize,  // deoptimization
+                       flags,           // flags
                        CodeStub::MajorName(descriptor->MajorKey(), false));
   }
 
 
   template <typename LinkageTraits>
   static CallDescriptor* GetSimplifiedCDescriptor(
       Zone* zone, int num_params, MachineType return_type,
       const MachineType* param_types) {
     LinkageLocation* locations =
         zone->NewArray<LinkageLocation>(num_params + 2);
     int index = 0;
     locations[index++] =
         TaggedRegisterLocation(LinkageTraits::ReturnValueReg());
     locations[index++] = LinkageHelper::UnconstrainedRegister(
         MachineOperatorBuilder::pointer_rep());
     // TODO(dcarney): test with lots of parameters.
     int i = 0;
     for (; i < LinkageTraits::CRegisterParametersLength() && i < num_params;
          i++) {
       locations[index++] = LinkageLocation(
           param_types[i],
           Register::ToAllocationIndex(LinkageTraits::CRegisterParameter(i)));
     }
     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::kNoDeoptimization);  // TODO(jarin) should deoptimize!
+        CallDescriptor::kNoFlags);  // TODO(jarin) should deoptimize!
   }
 };
-}
-}
-}  // namespace v8::internal::compiler
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8
 
 #endif  // V8_COMPILER_LINKAGE_IMPL_H_