[csa] Add CSA::CallBuiltin and Builtins::CallableFor

src/code-factory.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_CODE_FACTORY_H_
 #define V8_CODE_FACTORY_H_
 
 #include "src/allocation.h"
 #include "src/assembler.h"
+#include "src/callable.h"
 #include "src/codegen.h"
 #include "src/globals.h"
 #include "src/interface-descriptors.h"
 
 namespace v8 {
 namespace internal {
 
-// Associates a body of code with an interface descriptor.
-class Callable final BASE_EMBEDDED {
- public:
-  Callable(Handle<Code> code, CallInterfaceDescriptor descriptor)
-      : code_(code), descriptor_(descriptor) {}
-
-  Handle<Code> code() const { return code_; }
-  CallInterfaceDescriptor descriptor() const { return descriptor_; }
-
- private:
-  const Handle<Code> code_;
-  const CallInterfaceDescriptor descriptor_;
-};
-
 class V8_EXPORT_PRIVATE CodeFactory final {
  public:
   // CEntryStub has var-args semantics (all the arguments are passed on the
   // stack and the arguments count is passed via register) which currently
   // can't be expressed in CallInterfaceDescriptor. Therefore only the code
   // is exported here.
   static Handle<Code> RuntimeCEntry(Isolate* isolate, int result_size = 1);
 
   // Initial states for ICs.
   static Callable LoadIC(Isolate* isolate);
@@ skipping 135 matching lines @@
   static Callable CallForwardVarargs(Isolate* isolate);
   static Callable CallFunctionForwardVarargs(Isolate* isolate);
   static Callable Construct(Isolate* isolate);
   static Callable ConstructWithSpread(Isolate* isolate);
   static Callable ConstructFunction(Isolate* isolate);
   static Callable CreateIterResultObject(Isolate* isolate);
   static Callable HasProperty(Isolate* isolate);
   static Callable ForInFilter(Isolate* isolate);
 
   static Callable InterpreterPushArgsAndCall(Isolate* isolate,
                                              TailCallMode tail_call_mode,

[Yang, 2017/03/16 11:45:38]

Can we extend this for builtins implemented in MacroAssembler?

[jgruber, 2017/03/16 12:35:27]

Not sure it's beneficial since many (if not most) ASM builtins are not called as
stubs (see e.g. CompileBaseline, OnStackReplacement, AllocateInNewSpace, ...).
CodeFactory seems like the right place to handle the exceptions.

                                              InterpreterPushArgsMode mode);
   static Callable InterpreterPushArgsAndConstruct(Isolate* isolate,
                                                   InterpreterPushArgsMode mode);
   static Callable InterpreterPushArgsAndConstructArray(Isolate* isolate);
   static Callable InterpreterCEntry(Isolate* isolate, int result_size = 1);
   static Callable InterpreterOnStackReplacement(Isolate* isolate);
 
   static Callable ArrayConstructor(Isolate* isolate);
   static Callable ArrayPush(Isolate* isolate);
   static Callable FunctionPrototypeBind(Isolate* isolate);
   static Callable PromiseHandleReject(Isolate* isolate);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_CODE_FACTORY_H_