inline api getters 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 5512 matching lines @@
 
 
 bool HOptimizedGraphBuilder::PropertyAccessInfo::LoadResult(Handle<Map> map) {
   if (lookup_.IsField()) {
     access_ = HObjectAccess::ForField(map, &lookup_, name_);
   } else if (lookup_.IsPropertyCallbacks()) {
     Handle<Object> callback(lookup_.GetValueFromMap(*map), isolate());
     if (!callback->IsAccessorPair()) return false;
     Object* getter = Handle<AccessorPair>::cast(callback)->getter();
     if (!getter->IsJSFunction()) return false;
-    Handle<JSFunction> accessor = handle(JSFunction::cast(getter));
-    CallOptimization call_optimization(accessor);
-    // TODO(dcarney): temporary hack unless crankshaft can handle api calls.
-    if (call_optimization.is_simple_api_call()) return false;
-    accessor_ = accessor;
+    accessor_ = handle(JSFunction::cast(getter));
   } else if (lookup_.IsConstant()) {
     constant_ = handle(lookup_.GetConstantFromMap(*map), isolate());
   }
 
   return true;
 }
 
 
 bool HOptimizedGraphBuilder::PropertyAccessInfo::LookupInPrototypes() {
   Handle<Map> map = this->map();
@@ skipping 104 matching lines @@
 
   if (info->lookup()->IsPropertyCallbacks()) {
     if (NeedsWrappingFor(info->type(), info->accessor())) {
       HValue* function = Add<HConstant>(info->accessor());
       Add<HPushArgument>(checked_object);
       return New<HCallFunction>(function, 1, WRAP_AND_CALL);
     } else {
       Push(checked_object);
       if (FLAG_inline_accessors &&
           can_inline_accessor &&
-          TryInlineGetter(info->accessor(), ast_id, return_id)) {
+          TryInlineGetter(info->accessor(),
+                          checked_object,
+                          info->map(),
+                          ast_id,
+                          return_id)) {
         return NULL;
       }
       Add<HPushArgument>(Pop());
       return BuildCallConstantFunction(info->accessor(), 1);
     }
   }
 
   ASSERT(info->lookup()->IsConstant());
   return New<HConstant>(info->constant());
 }
@@ skipping 1927 matching lines @@
   return TryInline(expr->target(),
                    expr->arguments()->length(),
                    implicit_return_value,
                    expr->id(),
                    expr->ReturnId(),
                    CONSTRUCT_CALL_RETURN);
 }
 
 
 bool HOptimizedGraphBuilder::TryInlineGetter(Handle<JSFunction> getter,
+                                             HValue * receiver,

[Toon Verwaest, 2014/02/04 13:25:31]

Remove space between HValue and *

+                                             Handle<Map> receiver_map,
                                              BailoutId ast_id,
                                              BailoutId return_id) {
+  if (TryInlineApiGetter(getter, receiver, receiver_map, ast_id)) return true;
   return TryInline(getter,
                    0,
                    NULL,
                    ast_id,
                    return_id,
                    GETTER_CALL_RETURN);
 }
 
 
 bool HOptimizedGraphBuilder::TryInlineSetter(Handle<JSFunction> setter,
@@ skipping 262 matching lines @@
     default:
       // Not yet supported for inlining.
       break;
   }
   return false;
 }
 
 
 bool HOptimizedGraphBuilder::TryInlineApiFunctionCall(Call* expr,
                                                       HValue* receiver) {
-  return TryInlineApiCall(
-      expr, receiver, Handle<Map>::null(), true);
+  if (!expr->IsMonomorphic()) return false;

[Toon Verwaest, 2014/02/04 13:25:31]

These checks shouldn't be here, but rather in CanLoadMonomorphic. Same thing
below.

+  Handle<JSFunction> function = expr->target();
+  int argc = expr->arguments()->length();
+  Handle<Map> receiver_map = Handle<Map>::null();
+  return TryInlineApiCall(function,
+                          receiver,
+                          receiver_map,
+                          argc,
+                          expr->id(),
+                          kCallApiFunction);
 }
 
 
 bool HOptimizedGraphBuilder::TryInlineApiMethodCall(Call* expr,
                                                     HValue* receiver,
                                                     Handle<Map> receiver_map) {
-  return TryInlineApiCall(expr, receiver, receiver_map, false);
+  if (!expr->IsMonomorphic()) return false;
+  Handle<JSFunction> function = expr->target();
+  int argc = expr->arguments()->length();
+  return TryInlineApiCall(function,
+                          receiver,
+                          receiver_map,
+                          argc,
+                          expr->id(),
+                          kCallApiMethod);
 }
 
-bool HOptimizedGraphBuilder::TryInlineApiCall(Call* expr,
-                                              HValue* receiver,
-                                              Handle<Map> receiver_map,
-                                              bool is_function_call) {
-  if (!expr->IsMonomorphic()) return false;
-  CallOptimization optimization(expr->target());
+
+bool HOptimizedGraphBuilder::TryInlineApiGetter(Handle<JSFunction> function,
+                                                HValue* receiver,
+                                                Handle<Map> receiver_map,
+                                                BailoutId ast_id) {
+  return TryInlineApiCall(function,
+                          receiver,
+                          receiver_map,
+                          0,
+                          ast_id,
+                          kCallApiGetter);
+}
+
+
+bool HOptimizedGraphBuilder::TryInlineApiCall(Handle<JSFunction> function,
+                                               HValue* receiver,
+                                               Handle<Map> receiver_map,
+                                               int argc,
+                                               BailoutId ast_id,
+                                               ApiCallType call_type) {
+  CallOptimization optimization(function);
   if (!optimization.is_simple_api_call()) return false;
   Handle<Map> holder_map;
-  if (is_function_call) {
+  if (call_type == kCallApiFunction) {
     // Cannot embed a direct reference to the global proxy map
     // as it maybe dropped on deserialization.
     CHECK(!Serializer::enabled());
-    receiver_map = Handle<Map>(
-        expr->target()->context()->global_object()->global_receiver()->map());
+    receiver_map = handle(
+        function->context()->global_object()->global_receiver()->map());
   }
   CallOptimization::HolderLookup holder_lookup =
       CallOptimization::kHolderNotFound;
   Handle<JSObject> api_holder = optimization.LookupHolderOfExpectedType(
       receiver_map, &holder_lookup);
   if (holder_lookup == CallOptimization::kHolderNotFound) return false;
 
   if (FLAG_trace_inlining) {
     PrintF("Inlining api function ");
-    expr->target()->ShortPrint();
+    function->ShortPrint();
     PrintF("\n");
   }
 
-  const int argc = expr->arguments()->length();
-  // Includes receiver.
-  PushArgumentsFromEnvironment(argc + 1);
+  if (call_type == kCallApiGetter) {
+    ASSERT_EQ(0, argc);
+    Add<HPushArgument>(Pop());  // Receiver.
+  } else {
+    // Includes receiver.
+    PushArgumentsFromEnvironment(argc + 1);
+  }
 
   // Need to ensure the chain between receiver and api_holder is intact
   AddCheckMap(receiver, receiver_map);
   if (holder_lookup == CallOptimization::kHolderFound) {
     AddCheckPrototypeMaps(api_holder, receiver_map);
   } else {
     ASSERT_EQ(holder_lookup, CallOptimization::kHolderIsReceiver);
   }
 
   HValue* holder = NULL;
@@ skipping 12 matching lines @@
   Handle<Object> call_data_obj(api_call_info->data(), isolate());
   bool call_data_is_undefined = call_data_obj->IsUndefined();
   HValue* call_data = Add<HConstant>(call_data_obj);
   ApiFunction fun(v8::ToCData<Address>(api_call_info->callback()));
   ExternalReference ref = ExternalReference(&fun,
                                             ExternalReference::DIRECT_API_CALL,
                                             isolate());
   HValue* api_function_address = Add<HConstant>(ExternalReference(ref));
 
   HValue* op_vals[] = {
-    // callee
-    Add<HConstant>(expr->target()),
+    Add<HConstant>(function),
     call_data,
     holder,
     api_function_address,
     context()
   };
 
   CallInterfaceDescriptor* descriptor =
       isolate()->call_descriptor(Isolate::ApiFunctionCall);
 
   CallApiFunctionStub stub(true, call_data_is_undefined, argc);
   Handle<Code> code = stub.GetCode(isolate());
   HConstant* code_value = Add<HConstant>(code);
 
   ASSERT((sizeof(op_vals) / kPointerSize) ==
          descriptor->environment_length());
 
   HInstruction* call = New<HCallWithDescriptor>(
       code_value, argc + 1, descriptor,
       Vector<HValue*>(op_vals, descriptor->environment_length()));
 
-  Drop(1);  // Drop function.
-  ast_context()->ReturnInstruction(call, expr->id());
+  switch (call_type) {
+    case kCallApiFunction:
+    case kCallApiMethod:
+      Drop(1);  // Drop function.
+      break;
+    case kCallApiGetter:
+      break;
+  }
+  ast_context()->ReturnInstruction(call, ast_id);
   return true;
 }
 
 
 bool HOptimizedGraphBuilder::TryCallApply(Call* expr) {
   ASSERT(expr->expression()->IsProperty());
 
   if (!expr->IsMonomorphic()) {
     return false;
   }
@@ skipping 3355 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal