[builtins] New frame type for exits to C++ builtins

src/builtins.cc

 // 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.
 
 #include "src/builtins.h"
 
 #include "src/api-arguments.h"
 #include "src/api-natives.h"
 #include "src/api.h"
 #include "src/base/ieee754.h"
@@ skipping 5699 matching lines @@
 
 Builtins::Builtins() : initialized_(false) {
   memset(builtins_, 0, sizeof(builtins_[0]) * builtin_count);
   memset(names_, 0, sizeof(names_[0]) * builtin_count);
 }
 
 
 Builtins::~Builtins() {
 }
 
-#define DEF_ENUM_C(name) FUNCTION_ADDR(Builtin_##name),
+#define DEF_ENUM_C(name, ignore) FUNCTION_ADDR(Builtin_##name),
 Address const Builtins::c_functions_[cfunction_count] = {
   BUILTIN_LIST_C(DEF_ENUM_C)
 };
 #undef DEF_ENUM_C
 
 
 struct BuiltinDesc {
   Handle<Code> (*builder)(Isolate*, struct BuiltinDesc const*);
   byte* generator;
   byte* c_code;
   const char* s_name;  // name is only used for generating log information.
   int name;
   Code::Flags flags;
+  Builtins::ExitFrameType exit_frame_type;
   int argc;
 };
 
 #define BUILTIN_FUNCTION_TABLE_INIT { V8_ONCE_INIT, {} }
 
 class BuiltinFunctionTable {
  public:
   BuiltinDesc* functions() {
     base::CallOnce(&once_, &Builtins::InitBuiltinFunctionTable);
     return functions_;
@@ skipping 24 matching lines @@
   const size_t buffer_size = 8 * KB;
 #endif
   union {
     int force_alignment;
     byte buffer[buffer_size];  // NOLINT(runtime/arrays)
   } u;
 
   MacroAssembler masm(isolate, u.buffer, sizeof(u.buffer),
                       CodeObjectRequired::kYes);
   // Generate the code/adaptor.
-  typedef void (*Generator)(MacroAssembler*, int);
+  typedef void (*Generator)(MacroAssembler*, int, Builtins::ExitFrameType);
   Generator g = FUNCTION_CAST<Generator>(builtin_desc->generator);
   // We pass all arguments to the generator, but it may not use all of
   // them.  This works because the first arguments are on top of the
   // stack.
   DCHECK(!masm.has_frame());
-  g(&masm, builtin_desc->name);
+  g(&masm, builtin_desc->name, builtin_desc->exit_frame_type);
   // Move the code into the object heap.
   CodeDesc desc;
   masm.GetCode(&desc);
   Code::Flags flags = builtin_desc->flags;
   return isolate->factory()->NewCode(desc, flags, masm.CodeObject());
 }
 
 // Builder for builtins implemented in TurboFan with JS linkage.
 Handle<Code> CodeStubAssemblerBuilderJS(Isolate* isolate,
                                         BuiltinDesc const* builtin_desc) {
@@ skipping 33 matching lines @@
 // within the lexical scope of Builtins:: and within a context where
 // Code::Flags names a non-abstract type.
 void Builtins::InitBuiltinFunctionTable() {
   BuiltinDesc* functions = builtin_function_table.functions_;
   functions[builtin_count].builder = nullptr;
   functions[builtin_count].generator = nullptr;
   functions[builtin_count].c_code = nullptr;
   functions[builtin_count].s_name = nullptr;
   functions[builtin_count].name = builtin_count;
   functions[builtin_count].flags = static_cast<Code::Flags>(0);
+  functions[builtin_count].exit_frame_type = EXIT;
   functions[builtin_count].argc = 0;
 
-#define DEF_FUNCTION_PTR_C(aname)                         \
+#define DEF_FUNCTION_PTR_C(aname, aexit_frame_type)       \
   functions->builder = &MacroAssemblerBuilder;            \
   functions->generator = FUNCTION_ADDR(Generate_Adaptor); \
   functions->c_code = FUNCTION_ADDR(Builtin_##aname);     \
   functions->s_name = #aname;                             \
   functions->name = c_##aname;                            \
   functions->flags = Code::ComputeFlags(Code::BUILTIN);   \
+  functions->exit_frame_type = aexit_frame_type;          \
   functions->argc = 0;                                    \
   ++functions;
 
 #define DEF_FUNCTION_PTR_A(aname, kind, extra)              \
   functions->builder = &MacroAssemblerBuilder;              \
   functions->generator = FUNCTION_ADDR(Generate_##aname);   \
   functions->c_code = NULL;                                 \
   functions->s_name = #aname;                               \
   functions->name = k##aname;                               \
   functions->flags = Code::ComputeFlags(Code::kind, extra); \
+  functions->exit_frame_type = EXIT;                        \
   functions->argc = 0;                                      \
   ++functions;
 
 #define DEF_FUNCTION_PTR_T(aname, aargc)                  \
   functions->builder = &CodeStubAssemblerBuilderJS;       \
   functions->generator = FUNCTION_ADDR(Generate_##aname); \
   functions->c_code = NULL;                               \
   functions->s_name = #aname;                             \
   functions->name = k##aname;                             \
   functions->flags = Code::ComputeFlags(Code::BUILTIN);   \
+  functions->exit_frame_type = EXIT;                      \
   functions->argc = aargc;                                \
   ++functions;
 
 #define DEF_FUNCTION_PTR_S(aname, kind, extra, interface_descriptor) \
   functions->builder = &CodeStubAssemblerBuilderCS;                  \
   functions->generator = FUNCTION_ADDR(Generate_##aname);            \
   functions->c_code = NULL;                                          \
   functions->s_name = #aname;                                        \
   functions->name = k##aname;                                        \
   functions->flags = Code::ComputeFlags(Code::kind, extra);          \
+  functions->exit_frame_type = EXIT;                                 \
   functions->argc = CallDescriptors::interface_descriptor;           \
   ++functions;
 
 #define DEF_FUNCTION_PTR_H(aname, kind)                     \
   functions->builder = &MacroAssemblerBuilder;              \
   functions->generator = FUNCTION_ADDR(Generate_##aname);   \
   functions->c_code = NULL;                                 \
   functions->s_name = #aname;                               \
   functions->name = k##aname;                               \
   functions->flags = Code::ComputeHandlerFlags(Code::kind); \
+  functions->exit_frame_type = EXIT;                        \
   functions->argc = 0;                                      \
   ++functions;
 
   BUILTIN_LIST_C(DEF_FUNCTION_PTR_C)
   BUILTIN_LIST_A(DEF_FUNCTION_PTR_A)
   BUILTIN_LIST_T(DEF_FUNCTION_PTR_T)
   BUILTIN_LIST_S(DEF_FUNCTION_PTR_S)
   BUILTIN_LIST_H(DEF_FUNCTION_PTR_H)
   BUILTIN_LIST_DEBUG_A(DEF_FUNCTION_PTR_A)
 
@@ skipping 313 matching lines @@
   a->Bind(&u32);
   a->AtomicStore(MachineRepresentation::kWord32, backing_store,
                  a->WordShl(index_word, 2), value_word32);
   a->Return(value_integer);
 
   // This shouldn't happen, we've already validated the type.
   a->Bind(&other);
   a->Return(a->Int32Constant(0));
 }
 
-#define DEFINE_BUILTIN_ACCESSOR_C(name)                                       \
+#define DEFINE_BUILTIN_ACCESSOR_C(name, ignore)                               \
   Handle<Code> Builtins::name() {                                             \
     Code** code_address = reinterpret_cast<Code**>(builtin_address(k##name)); \
     return Handle<Code>(code_address);                                        \
   }
 #define DEFINE_BUILTIN_ACCESSOR_A(name, kind, extra)                          \
   Handle<Code> Builtins::name() {                                             \
     Code** code_address = reinterpret_cast<Code**>(builtin_address(k##name)); \
     return Handle<Code>(code_address);                                        \
   }
 #define DEFINE_BUILTIN_ACCESSOR_T(name, argc)                                 \
@@ skipping 19 matching lines @@
 BUILTIN_LIST_H(DEFINE_BUILTIN_ACCESSOR_H)
 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A)
 #undef DEFINE_BUILTIN_ACCESSOR_C
 #undef DEFINE_BUILTIN_ACCESSOR_A
 #undef DEFINE_BUILTIN_ACCESSOR_T
 #undef DEFINE_BUILTIN_ACCESSOR_S
 #undef DEFINE_BUILTIN_ACCESSOR_H
 
 }  // namespace internal
 }  // namespace v8