inline api setters in crankshaft

src/hydrogen.cc

 // Copyright 2013 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 5567 matching lines @@
       Push(value);
     }
 
     if (NeedsWrappingFor(info->type(), info->accessor())) {
       HValue* function = Add<HConstant>(info->accessor());
       PushArgumentsFromEnvironment(argument_count);
       return New<HCallFunction>(function, argument_count, WRAP_AND_CALL);
     } else if (FLAG_inline_accessors && can_inline_accessor) {
       bool success = info->IsLoad()
           ? TryInlineGetter(info->accessor(), info->map(), ast_id, return_id)
-          : TryInlineSetter(info->accessor(), ast_id, return_id, value);
+          : TryInlineSetter(
+              info->accessor(), info->map(), ast_id, return_id, value);
       if (success) return NULL;
     }
 
     PushArgumentsFromEnvironment(argument_count);
     return BuildCallConstantFunction(info->accessor(), argument_count);
   }
 
   ASSERT(info->lookup()->IsConstant());
   if (info->IsLoad()) {
     return New<HConstant>(info->constant());
@@ skipping 1814 matching lines @@
   return TryInline(getter,
                    0,
                    NULL,
                    ast_id,
                    return_id,
                    GETTER_CALL_RETURN);
 }
 
 
 bool HOptimizedGraphBuilder::TryInlineSetter(Handle<JSFunction> setter,
+                                             Handle<Map> receiver_map,
                                              BailoutId id,
                                              BailoutId assignment_id,
                                              HValue* implicit_return_value) {
+  if (TryInlineApiSetter(setter, receiver_map, id)) return true;
   return TryInline(setter,
                    1,
                    implicit_return_value,
                    id, assignment_id,
                    SETTER_CALL_RETURN);
 }
 
 
 bool HOptimizedGraphBuilder::TryInlineApply(Handle<JSFunction> function,
                                             Call* expr,
@@ skipping 290 matching lines @@
   receiver_maps.Add(receiver_map, zone());
   return TryInlineApiCall(function,
                           NULL,  // Receiver is on expression stack.
                           &receiver_maps,
                           0,
                           ast_id,
                           kCallApiGetter);
 }
 
 
+bool HOptimizedGraphBuilder::TryInlineApiSetter(Handle<JSFunction> function,
+                                                Handle<Map> receiver_map,
+                                                BailoutId ast_id) {
+  SmallMapList receiver_maps(1, zone());
+  receiver_maps.Add(receiver_map, zone());
+  return TryInlineApiCall(function,
+                          NULL,  // Receiver is on expression stack.
+                          &receiver_maps,
+                          1,
+                          ast_id,
+                          kCallApiSetter);
+}
+
+
 bool HOptimizedGraphBuilder::TryInlineApiCall(Handle<JSFunction> function,
                                                HValue* receiver,
                                                SmallMapList* receiver_maps,
                                                int argc,
                                                BailoutId ast_id,
                                                ApiCallType call_type) {
   CallOptimization optimization(function);
   if (!optimization.is_simple_api_call()) return false;
   Handle<Map> holder_map;
   if (call_type == kCallApiFunction) {
@@ skipping 35 matching lines @@
       drop_extra = true;
       break;
     case kCallApiGetter:
       // Receiver and prototype chain cannot have changed.
       ASSERT_EQ(0, argc);
       ASSERT_EQ(NULL, receiver);
       // Receiver is on expression stack.
       receiver = Pop();
       Add<HPushArgument>(receiver);
       break;
+    case kCallApiSetter:
+      {
+        // Receiver and prototype chain cannot have changed.
+        ASSERT_EQ(1, argc);
+        ASSERT_EQ(NULL, receiver);
+        // Receiver and value are on expression stack.
+        HValue* value = Pop();
+        receiver = Pop();
+        Add<HPushArgument>(receiver);
+        Add<HPushArgument>(value);
+        break;
+     }
   }
 
   HValue* holder = NULL;
   switch (holder_lookup) {
     case CallOptimization::kHolderFound:
       holder = Add<HConstant>(api_holder);
       break;
     case CallOptimization::kHolderIsReceiver:
       holder = receiver;
       break;
@@ skipping 3403 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal