inline api getters 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 21855 matching lines @@
 
   static void OptimizationCallback(
       const v8::FunctionCallbackInfo<v8::Value>& info) {
     CHECK(callee == info.Callee());
     CHECK(data == info.Data());
     CHECK(receiver == info.This());
     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();
+    v8::AccessControl settings = v8::DEFAULT;
+    v8::PropertyAttribute attribute = v8::None;
+    i::Handle<i::Object> getter_i = v8::Utils::OpenHandle(*getter);
+    i::Handle<i::Object> setter_i = v8::Utils::OpenHandle(*setter, true);
+    if (setter_i.is_null()) setter_i = isolate->factory()->null_value();
+    i::JSObject::DefineAccessor(v8::Utils::OpenHandle(*object),
+                                v8::Utils::OpenHandle(*name),
+                                getter_i,
+                                setter_i,
+                                static_cast<PropertyAttributes>(attribute),
+                                settings);
+  }
+
   public:
     void Run(bool use_signature, bool global) {
       v8::Isolate* isolate = CcTest::isolate();
       v8::HandleScope scope(isolate);
       // Build a template for signature checks.
       Local<v8::ObjectTemplate> signature_template;
       Local<v8::Signature> signature;
       {
         Local<v8::FunctionTemplate> parent_template =
           FunctionTemplate::New(isolate);
@@ skipping 16 matching lines @@
       // Get the holder objects.
       Local<Object> inner_global =
           Local<Object>::Cast(context->Global()->GetPrototype());
       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>::Cast(
-          inner_global->GetPrototype())->Set(v8_str("global_f"), function);
+      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);
       function_holder->Set(v8_str("f"), function);
+      SetAccessorProperty(function_holder, v8_str("p1"), 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
         if (!use_signature) {
           receiver = Local<Object>::Cast(CompileRun(
               "var receiver_subclass = {};\n"
               "receiver_subclass.__proto__ = function_receiver;\n"
               "receiver_subclass"));
         } else {
           receiver = Local<Object>::Cast(CompileRun(
             "var receiver_subclass = function_receiver;\n"
             "receiver_subclass"));
         }
       }
       // 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(100);
+      i::ScopedVector<char> wrap_function(200);
       if (global) {
         i::OS::SNPrintF(
             wrap_function,
-           "function wrap_%d() { var f = global_f; return f(); }\n",
-            key);
+            "function wrap_f_%d() { var f = g_f; return f(); }\n"
+            "function wrap_p1_%d() { return this.g_p1; }\n",
+            key, key);
       } else {
         i::OS::SNPrintF(
             wrap_function,
-            "function wrap_%d() { return receiver_subclass.f(); }\n",
-            key);
+            "function wrap_f_%d() { return receiver_subclass.f(); }\n"
+            "function wrap_p1_%d() { return receiver_subclass.p1; }\n",
+            key, key);
       }
       // build source string
       i::ScopedVector<char> source(500);
       i::OS::SNPrintF(
           source,
-          "%s\n"  // wrap_function
-          "function wrap2() { wrap_%d(); }\n"
-          "wrap2();\n"
-          "wrap2();\n"
-          "%%OptimizeFunctionOnNextCall(wrap_%d);\n"
-          "wrap2();\n",
-          wrap_function.start(), key, key);
-      v8::TryCatch try_catch;
+          "%s\n"  // wrap functions
+          "function wrap_f() { wrap_f_%d(); }\n"
+          "function wrap_p1() { wrap_p1_%d(); }\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);
+      // v8::TryCatch try_catch;
+      // fprintf(stderr, "%s", source.start());
       CompileRun(source.start());
-      ASSERT(!try_catch.HasCaught());
-      CHECK_EQ(3, count);
+      // ASSERT(!try_catch.HasCaught());
+      CHECK_EQ(6, 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);
 }