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 80 matching lines @@
 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;
+    Address entry;
+#define BUILD_CPP(Name)                                                    \
+  entry = FUNCTION_ADDR(Builtin_##Name);                                   \
+  code = BuildAdaptor(isolate, entry, BUILTIN_EXIT, kBuiltinFlags, #Name); \
+  builtins_[index++].code = code;

[Jarin, 2016/08/18 12:11:18]

Instead of just setting the code, should not we construct the descriptor here?
(Just like below, but with code set properly.)

[jgruber, 2016/08/18 12:51:34]

Done.

+#define BUILD_API(Name)                                            \
+  entry = FUNCTION_ADDR(Builtin_##Name);                           \
+  code = BuildAdaptor(isolate, entry, EXIT, kBuiltinFlags, #Name); \
+  builtins_[index++].code = code;
 #define BUILD_TFJ(Name, Argc)                                          \
   code = BuildWithCodeStubAssemblerJS(isolate, &Generate_##Name, Argc, \
                                       kBuiltinFlags, #Name);           \
-  builtins_[index++] = code;
+  builtins_[index++].code = code;
 #define BUILD_TFS(Name, Kind, Extra, InterfaceDescriptor)              \
   { InterfaceDescriptor##Descriptor descriptor(isolate); }             \
   code = BuildWithCodeStubAssemblerCS(                                 \
       isolate, &Generate_##Name, CallDescriptors::InterfaceDescriptor, \
       Code::ComputeFlags(Code::Kind, Extra), #Name);                   \
-  builtins_[index++] = code;
+  builtins_[index++].code = code;
 #define BUILD_ASM(Name)                                                        \
   code =                                                                       \
       BuildWithMacroAssembler(isolate, Generate_##Name, kBuiltinFlags, #Name); \
-  builtins_[index++] = code;
+  builtins_[index++].code = code;
 #define BUILD_ASH(Name, Kind, Extra)                                           \
   code = BuildWithMacroAssembler(                                              \
       isolate, Generate_##Name, Code::ComputeFlags(Code::Kind, Extra), #Name); \
-  builtins_[index++] = code;
+  builtins_[index++].code = code;
 
     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
-    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);
+    for (int i = 0; i < BUILTIN_COUNT; i++) {
+      Code::cast(builtins_[i].code)->set_builtin_index(i);
     }
+  } else {
+    DCHECK(!create_heap_objects);
+    int index = 0;
+    Address entry;
+#define BUILD_CPP(Name)                                                   \
+  entry = FUNCTION_ADDR(Builtin_##Name);                                  \
+  builtins_[index] = {k##Name, API, entry, builtins_[index].code, #Name}; \

[Jarin, 2016/08/18 12:11:18]

Please define a constructor on the Descriptor class and use it here. In the past
we had trouble with the initializer lists.

Also, as discussed offline, we can set the code field to null here (the
deserializer will fill in the right value later).

[jgruber, 2016/08/18 12:51:34]

Done, and refactored this for more code reuse

+  index++;
+#define BUILD_API(Name)                                                   \
+  entry = FUNCTION_ADDR(Builtin_##Name);                                  \
+  builtins_[index] = {k##Name, API, entry, builtins_[index].code, #Name}; \
+  index++;
+#define BUILD_TFJ(Name, Argc)                                               \
+  builtins_[index] = {k##Name, TFJ, nullptr, builtins_[index].code, #Name}; \
+  index++;
+#define BUILD_TFS(Name, Kind, Extra, InterfaceDescriptor)                   \
+  builtins_[index] = {k##Name, TFS, nullptr, builtins_[index].code, #Name}; \
+  index++;
+#define BUILD_ASM(Name)                                                     \
+  builtins_[index] = {k##Name, ASM, nullptr, builtins_[index].code, #Name}; \
+  index++;
+#define BUILD_ASH(Name, Kind, Extra)                                        \
+  builtins_[index] = {k##Name, ASH, nullptr, builtins_[index].code, #Name}; \
+  index++;
+
+    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
+
+    CHECK_EQ(BUILTIN_COUNT, index);
   }
 
   // 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