[builtins] remove redundant builtins lists.

src/external-reference-table.cc

 // Copyright 2016 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/external-reference-table.h"
 
 #include "src/accessors.h"
 #include "src/assembler.h"
+#include "src/builtins/builtins.h"
 #include "src/counters.h"
 #include "src/deoptimizer.h"
 #include "src/ic/stub-cache.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)
+#undef FORWARD_DECLARE
+
 ExternalReferenceTable* ExternalReferenceTable::instance(Isolate* isolate) {
   ExternalReferenceTable* external_reference_table =
       isolate->external_reference_table();
   if (external_reference_table == NULL) {
     external_reference_table = new ExternalReferenceTable(isolate);
     isolate->set_external_reference_table(external_reference_table);
   }
   return external_reference_table;
 }
 
 ExternalReferenceTable::ExternalReferenceTable(Isolate* isolate) {
+  AddReferences(isolate);
+  AddBuiltins(isolate);
+  AddRuntimeFunctions(isolate);
+  AddStatCounters(isolate);
+  AddIsolateAddresses(isolate);
+  AddAccessors(isolate);
+  AddStubCache(isolate);
+  AddDeoptEntries(isolate);
+  AddApiReferences(isolate);
+}
+
+void ExternalReferenceTable::AddReferences(Isolate* isolate) {
   // Miscellaneous
   Add(ExternalReference::roots_array_start(isolate).address(),
       "Heap::roots_array_start()");
   Add(ExternalReference::address_of_stack_limit(isolate).address(),
       "StackGuard::address_of_jslimit()");
   Add(ExternalReference::address_of_real_stack_limit(isolate).address(),
       "StackGuard::address_of_real_jslimit()");
   Add(ExternalReference::new_space_allocation_limit_address(isolate).address(),
       "Heap::NewSpaceAllocationLimitAddress()");
   Add(ExternalReference::new_space_allocation_top_address(isolate).address(),
@@ skipping 190 matching lines @@
       "RegExpStack::limit_address()");
   Add(ExternalReference::address_of_regexp_stack_memory_address(isolate)
           .address(),
       "RegExpStack::memory_address()");
   Add(ExternalReference::address_of_regexp_stack_memory_size(isolate).address(),
       "RegExpStack::memory_size()");
   Add(ExternalReference::address_of_static_offsets_vector(isolate).address(),
       "OffsetsVector::static_offsets_vector");
 #endif  // V8_INTERPRETED_REGEXP
 
-  // The following populates all of the different type of external references
-  // into the ExternalReferenceTable.
-  //
-  // NOTE: This function was originally 100k of code.  It has since been
-  // rewritten to be mostly table driven, as the callback macro style tends to
-  // very easily cause code bloat.  Please be careful in the future when adding
-  // new references.
+  // Runtime entries
+  Add(ExternalReference::delete_handle_scope_extensions(isolate).address(),
+      "HandleScope::DeleteExtensions");
+  Add(ExternalReference::incremental_marking_record_write_function(isolate)
+          .address(),
+      "IncrementalMarking::RecordWrite");
+  Add(ExternalReference::incremental_marking_record_write_code_entry_function(
+          isolate)
+          .address(),
+      "IncrementalMarking::RecordWriteOfCodeEntryFromCode");
+  Add(ExternalReference::store_buffer_overflow_function(isolate).address(),
+      "StoreBuffer::StoreBufferOverflow");
+}
 
-  struct RefTableEntry {
-    uint16_t id;
+void ExternalReferenceTable::AddBuiltins(Isolate* isolate) {
+  struct CBuiltinEntry {
+    Address address;
+    const char* name;
+  };
+  static const CBuiltinEntry c_builtins[] = {
+#define DEF_ENTRY(Name, ...) {FUNCTION_ADDR(&Builtin_##Name), "Builtin_" #Name},
+      BUILTIN_LIST_C(DEF_ENTRY)
+#undef DEF_ENTRY
+  };
+  for (unsigned i = 0; i < arraysize(c_builtins); ++i) {
+    Add(ExternalReference(c_builtins[i].address, isolate).address(),
+        c_builtins[i].name);
+  }
+
+  struct BuiltinEntry {
+    Builtins::Name id;
+    const char* name;
+  };
+  static const BuiltinEntry builtins[] = {
+#define DEF_ENTRY(Name, ...) {Builtins::k##Name, "Builtin_" #Name},
+      BUILTIN_LIST_C(DEF_ENTRY) BUILTIN_LIST_A(DEF_ENTRY)
+#undef DEF_ENTRY
+  };
+  for (unsigned i = 0; i < arraysize(builtins); ++i) {
+    Add(isolate->builtins()->builtin_address(builtins[i].id), builtins[i].name);
+  }
+}
+
+void ExternalReferenceTable::AddRuntimeFunctions(Isolate* isolate) {
+  struct RuntimeEntry {
+    Runtime::FunctionId id;
     const char* name;
   };
 
-  static const RefTableEntry c_builtins[] = {
-#define DEF_ENTRY(name) {Builtins::c_##name, "Builtins::" #name},
-      BUILTIN_LIST_C(DEF_ENTRY)
-#undef DEF_ENTRY
-  };
-
-  for (unsigned i = 0; i < arraysize(c_builtins); ++i) {
-    ExternalReference ref(static_cast<Builtins::CFunctionId>(c_builtins[i].id),
-                          isolate);
-    Add(ref.address(), c_builtins[i].name);
-  }
-
-  static const RefTableEntry builtins[] = {
-#define DEF_ENTRY(name, ...) {Builtins::k##name, "Builtins::" #name},
-      BUILTIN_LIST_C(DEF_ENTRY) BUILTIN_LIST_A(DEF_ENTRY)
-#undef DEF_ENTRY
-  };
-
-  for (unsigned i = 0; i < arraysize(builtins); ++i) {
-    ExternalReference ref(static_cast<Builtins::Name>(builtins[i].id), isolate);
-    Add(ref.address(), builtins[i].name);
-  }
-
-  static const RefTableEntry runtime_functions[] = {
+  static const RuntimeEntry runtime_functions[] = {
 #define RUNTIME_ENTRY(name, i1, i2) {Runtime::k##name, "Runtime::" #name},
       FOR_EACH_INTRINSIC(RUNTIME_ENTRY)
 #undef RUNTIME_ENTRY
   };
 
   for (unsigned i = 0; i < arraysize(runtime_functions); ++i) {
-    ExternalReference ref(
-        static_cast<Runtime::FunctionId>(runtime_functions[i].id), isolate);
+    ExternalReference ref(runtime_functions[i].id, isolate);
     Add(ref.address(), runtime_functions[i].name);
   }
+}
 
+void ExternalReferenceTable::AddStatCounters(Isolate* isolate) {
   // Stat counters
   struct StatsRefTableEntry {
     StatsCounter* (Counters::*counter)();
     const char* name;
   };
 
   static const StatsRefTableEntry stats_ref_table[] = {
 #define COUNTER_ENTRY(name, caption) {&Counters::name, "Counters::" #name},
       STATS_COUNTER_LIST_1(COUNTER_ENTRY) STATS_COUNTER_LIST_2(COUNTER_ENTRY)
 #undef COUNTER_ENTRY
   };
 
   Counters* counters = isolate->counters();
   for (unsigned i = 0; i < arraysize(stats_ref_table); ++i) {
     // To make sure the indices are not dependent on whether counters are
     // enabled, use a dummy address as filler.
     Address address = NotAvailable();
     StatsCounter* counter = (counters->*(stats_ref_table[i].counter))();
     if (counter->Enabled()) {
       address = reinterpret_cast<Address>(counter->GetInternalPointer());
     }
     Add(address, stats_ref_table[i].name);
   }
+}
 
+void ExternalReferenceTable::AddIsolateAddresses(Isolate* isolate) {
   // Top addresses
   static const char* address_names[] = {
 #define BUILD_NAME_LITERAL(Name, name) "Isolate::" #name "_address",
       FOR_EACH_ISOLATE_ADDRESS_NAME(BUILD_NAME_LITERAL) NULL
 #undef BUILD_NAME_LITERAL
   };
 
   for (int i = 0; i < Isolate::kIsolateAddressCount; ++i) {
     Add(isolate->get_address_from_id(static_cast<Isolate::AddressId>(i)),
         address_names[i]);
   }
+}
 
+void ExternalReferenceTable::AddAccessors(Isolate* isolate) {
   // Accessors
   struct AccessorRefTable {
     Address address;
     const char* name;
   };
 
   static const AccessorRefTable getters[] = {
 #define ACCESSOR_INFO_DECLARATION(name) \
   {FUNCTION_ADDR(&Accessors::name##Getter), "Accessors::" #name "Getter"},
       ACCESSOR_INFO_LIST(ACCESSOR_INFO_DECLARATION)
 #undef ACCESSOR_INFO_DECLARATION
   };
   static const AccessorRefTable setters[] = {
 #define ACCESSOR_SETTER_DECLARATION(name) \
   {FUNCTION_ADDR(&Accessors::name), "Accessors::" #name},
       ACCESSOR_SETTER_LIST(ACCESSOR_SETTER_DECLARATION)
 #undef ACCESSOR_INFO_DECLARATION
   };
 
   for (unsigned i = 0; i < arraysize(getters); ++i) {
     Add(getters[i].address, getters[i].name);
     Add(AccessorInfo::redirect(isolate, getters[i].address, ACCESSOR_GETTER),
         "");
   }
 
   for (unsigned i = 0; i < arraysize(setters); ++i) {
     Add(setters[i].address, setters[i].name);
   }
+}
 
+void ExternalReferenceTable::AddStubCache(Isolate* isolate) {
   StubCache* load_stub_cache = isolate->load_stub_cache();
 
   // Stub cache tables
   Add(load_stub_cache->key_reference(StubCache::kPrimary).address(),
       "Load StubCache::primary_->key");
   Add(load_stub_cache->value_reference(StubCache::kPrimary).address(),
       "Load StubCache::primary_->value");
   Add(load_stub_cache->map_reference(StubCache::kPrimary).address(),
       "Load StubCache::primary_->map");
   Add(load_stub_cache->key_reference(StubCache::kSecondary).address(),
@@ skipping 11 matching lines @@
   Add(store_stub_cache->value_reference(StubCache::kPrimary).address(),
       "Store StubCache::primary_->value");
   Add(store_stub_cache->map_reference(StubCache::kPrimary).address(),
       "Store StubCache::primary_->map");
   Add(store_stub_cache->key_reference(StubCache::kSecondary).address(),
       "Store StubCache::secondary_->key");
   Add(store_stub_cache->value_reference(StubCache::kSecondary).address(),
       "Store StubCache::secondary_->value");
   Add(store_stub_cache->map_reference(StubCache::kSecondary).address(),
       "Store StubCache::secondary_->map");
+}
 
-  // Runtime entries
-  Add(ExternalReference::delete_handle_scope_extensions(isolate).address(),
-      "HandleScope::DeleteExtensions");
-  Add(ExternalReference::incremental_marking_record_write_function(isolate)
-          .address(),
-      "IncrementalMarking::RecordWrite");
-  Add(ExternalReference::incremental_marking_record_write_code_entry_function(
-          isolate)
-          .address(),
-      "IncrementalMarking::RecordWriteOfCodeEntryFromCode");
-  Add(ExternalReference::store_buffer_overflow_function(isolate).address(),
-      "StoreBuffer::StoreBufferOverflow");
-
-  // Add a small set of deopt entry addresses to encoder without generating the
+void ExternalReferenceTable::AddDeoptEntries(Isolate* isolate) {
+  // Add a small set of deopt entry addresses to encoder without generating
+  // the
   // deopt table code, which isn't possible at deserialization time.
   HandleScope scope(isolate);
   for (int entry = 0; entry < kDeoptTableSerializeEntryCount; ++entry) {
     Address address = Deoptimizer::GetDeoptimizationEntry(
         isolate, entry, Deoptimizer::LAZY,
         Deoptimizer::CALCULATE_ENTRY_ADDRESS);
     Add(address, "lazy_deopt");
   }
+}
 
-  // Add external references provided by the embedder (a null-terminated array).
+void ExternalReferenceTable::AddApiReferences(Isolate* isolate) {
+  // Add external references provided by the embedder (a null-terminated
+  // array).
   intptr_t* api_external_references = isolate->api_external_references();
   if (api_external_references != nullptr) {
     while (*api_external_references != 0) {
       Add(reinterpret_cast<Address>(*api_external_references), "<embedder>");
       api_external_references++;
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8