Refactor LoadIC into Handler Frontend and Backends.

src/stub-cache.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 982 matching lines @@
       }
     }
   }
 }
 
 
 // ------------------------------------------------------------------------
 // StubCompiler implementation.
 
 
-RUNTIME_FUNCTION(MaybeObject*, LoadCallbackProperty) {
-  ASSERT(args[0]->IsJSObject());
-  ASSERT(args[1]->IsJSObject());
-  ASSERT(args[3]->IsSmi());
-  AccessorInfo* callback = AccessorInfo::cast(args[4]);
-  Address getter_address = v8::ToCData<Address>(callback->getter());
-  v8::AccessorGetter fun = FUNCTION_CAST<v8::AccessorGetter>(getter_address);
-  ASSERT(fun != NULL);
-  ASSERT(callback->IsCompatibleReceiver(args[0]));
-  v8::AccessorInfo info(&args[0]);
-  HandleScope scope(isolate);
-  v8::Handle<v8::Value> result;
-  {
-    // Leaving JavaScript.
-    VMState state(isolate, EXTERNAL);
-    ExternalCallbackScope call_scope(isolate, getter_address);
-    result = fun(v8::Utils::ToLocal(args.at<String>(5)), info);
-  }
-  RETURN_IF_SCHEDULED_EXCEPTION(isolate);
-  if (result.IsEmpty()) return HEAP->undefined_value();
-  Handle<Object> result_internal = v8::Utils::OpenHandle(*result);
-  result_internal->VerifyApiCallResultType();
-  return *result_internal;
-}
-
-
 RUNTIME_FUNCTION(MaybeObject*, StoreCallbackProperty) {
   JSObject* recv = JSObject::cast(args[0]);
   AccessorInfo* callback = AccessorInfo::cast(args[1]);
   Address setter_address = v8::ToCData<Address>(callback->setter());
   v8::AccessorSetter fun = FUNCTION_CAST<v8::AccessorSetter>(setter_address);
   ASSERT(fun != NULL);
   ASSERT(callback->IsCompatibleReceiver(recv));
   Handle<String> name = args.at<String>(2);
   Handle<Object> value = args.at<Object>(3);
   HandleScope scope(isolate);
@@ skipping 351 matching lines @@
 }
 
 
 #define __ ACCESS_MASM(masm())
 
 
 Handle<Code> BaseLoadStubCompiler::CompileLoadField(Handle<JSObject> object,
                                                     Handle<JSObject> holder,
                                                     Handle<String> name,
                                                     PropertyIndex index) {
-  Label miss;
-
-  GenerateNameCheck(name, this->name(), &miss);
-  GenerateLoadField(object, holder, receiver(),
-                    scratch1(), scratch2(), scratch3(),
-                    index, name, &miss);
-  __ bind(&miss);
-  GenerateLoadMiss(masm(), kind());
+  Label success;
+  Register reg = GenerateHandlerFrontend(
+      object, receiver(), holder, name,
+      &success, Handle<AccessorInfo>::null(), true);
+  __ bind(&success);
+  GenerateLoadField(reg, holder, index);
 
   // Return the generated code.
   return GetCode(Code::FIELD, name);
 }
 
 
+Handle<Code> BaseLoadStubCompiler::CompileLoadConstant(
+    Handle<JSObject> object,
+    Handle<JSObject> holder,
+    Handle<String> name,
+    Handle<JSFunction> value) {
+  Label success;
+  GenerateHandlerFrontend(object, receiver(), holder, name,
+                          &success, Handle<AccessorInfo>::null(), true);
+  __ bind(&success);
+  GenerateLoadConstant(value);
+
+  // Return the generated code.
+  return GetCode(Code::CONSTANT_FUNCTION, name);
+}
+
+
 Handle<Code> BaseLoadStubCompiler::CompileLoadCallback(
     Handle<JSObject> object,
     Handle<JSObject> holder,
     Handle<String> name,
     Handle<AccessorInfo> callback) {
-  Label miss;
+  Label success;
 
-  GenerateNameCheck(name, this->name(), &miss);
-  GenerateLoadCallback(object, holder, receiver(), this->name(),
-                       scratch1(), scratch2(), scratch3(), scratch4(),
-                       callback, name, &miss);
-  __ bind(&miss);
-  GenerateLoadMiss(masm(), kind());
+  Register reg = GenerateHandlerFrontend(object, receiver(), holder, name,
+                                         &success, callback, true);
+  __ bind(&success);
+  GenerateLoadCallback(reg, callback);
 
   // Return the generated code.
   return GetCode(Code::CALLBACKS, name);
 }
 
 
-Handle<Code> BaseLoadStubCompiler::CompileLoadConstant(
-    Handle<JSObject> object,
-    Handle<JSObject> holder,
-    Handle<String> name,
-    Handle<JSFunction> value) {
-  Label miss;
-
-  GenerateNameCheck(name, this->name(), &miss);
-  GenerateLoadConstant(object, holder, receiver(),
-                       scratch1(), scratch2(), scratch3(),
-                       value, name, &miss);
-  __ bind(&miss);
-  GenerateLoadMiss(masm(), kind());
-
-  // Return the generated code.
-  return GetCode(Code::CONSTANT_FUNCTION, name);
-}
-
-
 Handle<Code> BaseLoadStubCompiler::CompileLoadInterceptor(
     Handle<JSObject> object,
     Handle<JSObject> holder,
     Handle<String> name) {
-  Label miss;
+  Label success;
 
   LookupResult lookup(isolate());
   LookupPostInterceptor(holder, name, &lookup);
 
-  GenerateNameCheck(name, this->name(), &miss);
+  Register reg = GenerateHandlerFrontend(
+      object, receiver(), holder, name,
+      &success, Handle<AccessorInfo>::null(), true);
+  __ bind(&success);
   // TODO(368): Compile in the whole chain: all the interceptors in
   // prototypes and ultimate answer.
-  GenerateLoadInterceptor(object, holder, &lookup, receiver(), this->name(),
-                          scratch1(), scratch2(), scratch3(),
-                          name, &miss);
-
-  __ bind(&miss);
-  GenerateLoadMiss(masm(), kind());
+  GenerateLoadInterceptor(reg, object, holder, &lookup, name);
 
   // Return the generated code.
   return GetCode(Code::INTERCEPTOR, name);
 }
 
 
 #undef __
 
 
 Handle<Code> LoadStubCompiler::GetCode(Code::StubType type,
@@ skipping 282 matching lines @@
           Handle<FunctionTemplateInfo>(
               FunctionTemplateInfo::cast(signature->receiver()));
     }
   }
 
   is_simple_api_call_ = true;
 }
 
 
 } }  // namespace v8::internal