Store information about builtins in descriptors

src/builtins/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/builtins.h"
 #include "src/code-events.h"
 #include "src/code-stub-assembler.h"
 #include "src/ic/ic-state.h"
 #include "src/interface-descriptors.h"
 #include "src/isolate.h"
 #include "src/macro-assembler.h"
 #include "src/objects.h"
 
 namespace v8 {
 namespace internal {
 
 // Forward declarations for C++ builtins.
 #define FORWARD_DECLARE(Name) \
   Object* Builtin_##Name(int argc, Object** args, Isolate* isolate);
 BUILTIN_LIST_C(FORWARD_DECLARE)
 
 Builtins::Builtins() : initialized_(false) {
-  memset(builtins_, 0, sizeof(builtins_[0]) * builtin_count);
+  memset(builtins_, 0, sizeof(builtins_[0]) * BUILTIN_COUNT);
 }
 
 Builtins::~Builtins() {}
 
 namespace {
 void PostBuildProfileAndTracing(Isolate* isolate, Code* code,
                                 const char* name) {
   PROFILE(isolate, CodeCreateEvent(CodeEventListener::BUILTIN_TAG,
                                    AbstractCode::cast(code), name));
 #ifdef ENABLE_DISASSEMBLER
@@ skipping 76 matching lines @@
   return *code;
 }
 }  // anonymous namespace
 
 void Builtins::SetUp(Isolate* isolate, bool create_heap_objects) {
   DCHECK(!initialized_);
 
   // Create a scope for the handles in the builtins.
   HandleScope scope(isolate);
 
-  if (create_heap_objects) {
-    int index = 0;
-    const Code::Flags kBuiltinFlags = Code::ComputeFlags(Code::BUILTIN);
-    Code* code;
-#define BUILD_CPP(Name)                                                     \
-  code = BuildAdaptor(isolate, FUNCTION_ADDR(Builtin_##Name), BUILTIN_EXIT, \
-                      kBuiltinFlags, #Name);                                \
-  builtins_[index++] = code;
-#define BUILD_API(Name)                                             \
-  code = BuildAdaptor(isolate, FUNCTION_ADDR(Builtin_##Name), EXIT, \
-                      kBuiltinFlags, #Name);                        \
-  builtins_[index++] = code;
-#define BUILD_TFJ(Name, Argc)                                          \
-  code = BuildWithCodeStubAssemblerJS(isolate, &Generate_##Name, Argc, \
-                                      kBuiltinFlags, #Name);           \
-  builtins_[index++] = code;
+  int index = 0;
+  const Code::Flags kBuiltinFlags = Code::ComputeFlags(Code::BUILTIN);
+  Code* code;
+  Address entry;
+
+// If setting up a snapshot (or running without a snapshot), the code objects
+// are created here. Otherwise, we simply leave the code pointer unset as it
+// will be written later by the deserializer.
+
+#define MAYBE_CODE(call) (create_heap_objects ? (call) : nullptr)
+#define BUILD_CPP(Name)                                                  \
+  entry = FUNCTION_ADDR(Builtin_##Name);                                 \
+  code = MAYBE_CODE(                                                     \
+      BuildAdaptor(isolate, entry, BUILTIN_EXIT, kBuiltinFlags, #Name)); \
+  builtins_[index++] = Descriptor(k##Name, API, entry, code, #Name);
+#define BUILD_API(Name)                                                        \
+  entry = FUNCTION_ADDR(Builtin_##Name);                                       \
+  code = MAYBE_CODE(BuildAdaptor(isolate, entry, EXIT, kBuiltinFlags, #Name)); \
+  builtins_[index++] = Descriptor(k##Name, API, entry, code, #Name);
+#define BUILD_TFJ(Name, Argc)                                                  \
+  code = MAYBE_CODE(BuildWithCodeStubAssemblerJS(isolate, &Generate_##Name,    \
+                                                 Argc, kBuiltinFlags, #Name)); \
+  builtins_[index++] = Descriptor(k##Name, TFJ, nullptr, code, #Name);
 #define BUILD_TFS(Name, Kind, Extra, InterfaceDescriptor)              \
   { InterfaceDescriptor##Descriptor descriptor(isolate); }             \
-  code = BuildWithCodeStubAssemblerCS(                                 \
+  code = MAYBE_CODE(BuildWithCodeStubAssemblerCS(                      \
       isolate, &Generate_##Name, CallDescriptors::InterfaceDescriptor, \
-      Code::ComputeFlags(Code::Kind, Extra), #Name);                   \
-  builtins_[index++] = code;
-#define BUILD_ASM(Name)                                                        \
-  code =                                                                       \
-      BuildWithMacroAssembler(isolate, Generate_##Name, kBuiltinFlags, #Name); \
-  builtins_[index++] = code;
-#define BUILD_ASH(Name, Kind, Extra)                                           \
-  code = BuildWithMacroAssembler(                                              \
-      isolate, Generate_##Name, Code::ComputeFlags(Code::Kind, Extra), #Name); \
-  builtins_[index++] = code;
+      Code::ComputeFlags(Code::Kind, Extra), #Name));                  \
+  builtins_[index++] = Descriptor(k##Name, TFS, nullptr, code, #Name);
+#define BUILD_ASM(Name)                                               \
+  code = MAYBE_CODE(BuildWithMacroAssembler(isolate, Generate_##Name, \
+                                            kBuiltinFlags, #Name));   \
+  builtins_[index++] = Descriptor(k##Name, ASM, nullptr, code, #Name);
+#define BUILD_ASH(Name, Kind, Extra)                                          \
+  code = MAYBE_CODE(                                                          \
+      BuildWithMacroAssembler(isolate, Generate_##Name,                       \
+                              Code::ComputeFlags(Code::Kind, Extra), #Name)); \
+  builtins_[index++] = Descriptor(k##Name, ASH, nullptr, code, #Name);
 
-    BUILTIN_LIST(BUILD_CPP, BUILD_API, BUILD_TFJ, BUILD_TFS, BUILD_ASM,
-                 BUILD_ASH, BUILD_ASM);
+  BUILTIN_LIST(BUILD_CPP, BUILD_API, BUILD_TFJ, BUILD_TFS, BUILD_ASM, BUILD_ASH,
+               BUILD_ASM);
 
 #undef BUILD_CPP
 #undef BUILD_API
 #undef BUILD_TFJ
 #undef BUILD_TFS
 #undef BUILD_ASM
 #undef BUILD_ASH

[Jarin, 2016/08/18 14:10:43]

For consistency, could you say "#undef MAYBE_CODE" here?

[jgruber, 2016/08/18 14:41:32]

Good catch, thanks. Done.

-    CHECK_EQ(builtin_count, index);
-    for (int i = 0; i < builtin_count; i++) {
-      Code::cast(builtins_[i])->set_builtin_index(i);
+
+  CHECK_EQ(BUILTIN_COUNT, index);
+
+  if (create_heap_objects) {
+    for (int i = 0; i < BUILTIN_COUNT; i++) {
+      Code::cast(builtins_[i].code)->set_builtin_index(i);
     }
   }
 
   // Mark as initialized.
   initialized_ = true;
 }
 
 void Builtins::TearDown() { initialized_ = false; }
 
 void Builtins::IterateBuiltins(ObjectVisitor* v) {
-  v->VisitPointers(&builtins_[0], &builtins_[0] + builtin_count);
+  for (int i = 0; i < BUILTIN_COUNT; i++) {
+    v->VisitPointer(&builtins_[i].code);
+  }
 }
 
 const char* Builtins::Lookup(byte* pc) {
   // may be called during initialization (disassembler!)
   if (initialized_) {
-    for (int i = 0; i < builtin_count; i++) {
-      Code* entry = Code::cast(builtins_[i]);
+    for (int i = 0; i < BUILTIN_COUNT; i++) {
+      Code* entry = Code::cast(builtins_[i].code);
       if (entry->contains(pc)) return name(i);
     }
   }
   return NULL;
 }
 
 const char* Builtins::name(int index) {
   switch (index) {
 #define CASE(Name, ...) \
   case k##Name:         \
@@ skipping 27 matching lines @@
     if (responsible_context.is_null()) {
       return true;
     }
   }
   if (*responsible_context == target->context()) return true;
   return isolate->MayAccess(responsible_context, target_global_proxy);
 }
 
 }  // namespace internal
 }  // namespace v8