inline api setters in crankshaft

test/cctest/test-api.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 21894 matching lines @@
   static Local<Object> receiver;
   static Local<Object> holder;
   static Local<Object> callee;
   static int count;
 
   static void OptimizationCallback(
       const v8::FunctionCallbackInfo<v8::Value>& info) {
     CHECK(callee == info.Callee());
     CHECK(data == info.Data());
     CHECK(receiver == info.This());
+    if (info.Length() == 1) {
+      CHECK_EQ(v8_num(1), info[0]);
+    }
     CHECK(holder == info.Holder());
     count++;
   }
 
   // TODO(dcarney): move this to v8.h
   static void SetAccessorProperty(Local<Object> object,
                                   Local<String> name,
                                   Local<Function> getter,
                                   Local<Function> setter = Local<Function>()) {
     i::Isolate* isolate = CcTest::i_isolate();
@@ skipping 42 matching lines @@
       Local<Object> function_holder =
           Local<Object>::Cast(function_receiver->GetPrototype());
       // Install function on hidden prototype object.
       data = Object::New(isolate);
       Local<FunctionTemplate> function_template = FunctionTemplate::New(
           isolate, OptimizationCallback, data, signature);
       Local<Function> function = function_template->GetFunction();
       Local<Object> global_holder = Local<Object>::Cast(
           inner_global->GetPrototype());
       global_holder->Set(v8_str("g_f"), function);
-      SetAccessorProperty(global_holder, v8_str("g_p1"), function);
+      SetAccessorProperty(global_holder, v8_str("g_acc"), function, function);
       function_holder->Set(v8_str("f"), function);
-      SetAccessorProperty(function_holder, v8_str("p1"), function);
+      SetAccessorProperty(function_holder, v8_str("acc"), function, function);
       // Initialize expected values.
       callee = function;
       count = 0;
       if (global) {
         receiver = context->Global();
         holder = inner_global;
       } else {
         holder = function_receiver;
         // If not using a signature, add something else to the prototype chain
         // to test the case that holder != receiver
@@ skipping 10 matching lines @@
       }
       // With no signature, the holder is not set.
       if (!use_signature) holder = receiver;
       // build wrap_function
       int key = (use_signature ? 1 : 0) + 2 * (global ? 1 : 0);
       i::ScopedVector<char> wrap_function(200);
       if (global) {
         i::OS::SNPrintF(
             wrap_function,
             "function wrap_f_%d() { var f = g_f; return f(); }\n"
-            "function wrap_p1_%d() { return this.g_p1; }\n",
-            key, key);
+            "function wrap_get_%d() { return this.g_acc; }\n"
+            "function wrap_set_%d() { this.g_acc = 1; }\n",
+            key, key, key);
       } else {
         i::OS::SNPrintF(
             wrap_function,
             "function wrap_f_%d() { return receiver_subclass.f(); }\n"
-            "function wrap_p1_%d() { return receiver_subclass.p1; }\n",
-            key, key);
+            "function wrap_get_%d() { return receiver_subclass.acc; }\n"
+            "function wrap_set_%d() { receiver_subclass.acc = 1; }\n",
+            key, key, key);
       }
       // build source string
       i::ScopedVector<char> source(500);
       i::OS::SNPrintF(
           source,
           "%s\n"  // wrap functions
           "function wrap_f() { wrap_f_%d(); }\n"
-          "function wrap_p1() { wrap_p1_%d(); }\n"
+          "function wrap_get() { wrap_get_%d(); }\n"
+          "function wrap_set() { wrap_set_%d(); }\n"
+          "\n"
           "wrap_f();\n"
           "wrap_f();\n"
           "%%OptimizeFunctionOnNextCall(wrap_f_%d);\n"
           "wrap_f();\n"
-          "wrap_p1();\n"
-          "wrap_p1();\n"
-          "%%OptimizeFunctionOnNextCall(wrap_p1_%d);\n"
-          "wrap_p1();\n",
-          wrap_function.start(), key, key, key, key);
+          "\n"
+          "wrap_get();\n"
+          "wrap_get();\n"
+          "%%OptimizeFunctionOnNextCall(wrap_get_%d);\n"
+          "wrap_get();\n"
+          "\n"
+          "wrap_set();\n"
+          "wrap_set();\n"
+          "%%OptimizeFunctionOnNextCall(wrap_set_%d);\n"
+          "wrap_set();\n",
+          wrap_function.start(), key, key, key, key, key, key);
       v8::TryCatch try_catch;
       CompileRun(source.start());
       ASSERT(!try_catch.HasCaught());
-      CHECK_EQ(6, count);
+      CHECK_EQ(9, count);
     }
 };
 
 
 Local<Object> ApiCallOptimizationChecker::data;
 Local<Object> ApiCallOptimizationChecker::receiver;
 Local<Object> ApiCallOptimizationChecker::holder;
 Local<Object> ApiCallOptimizationChecker::callee;
 int ApiCallOptimizationChecker::count = 0;
 
 
 TEST(TestFunctionCallOptimization) {
   i::FLAG_allow_natives_syntax = true;
   ApiCallOptimizationChecker checker;
   checker.Run(true, true);
   checker.Run(false, true);
   checker.Run(true, false);
   checker.Run(false, false);
 }