Check that external references are registered in the serializer.

src/serialize.cc

Index: src/serialize.cc
diff --git a/src/serialize.cc b/src/serialize.cc
index 5a54543910883b3aee59865838fb4d3fe2b1e0e5..e3c0294cd22922bab234a731b4f0c1c631918cc5 100644
--- a/src/serialize.cc
+++ b/src/serialize.cc
@@ -398,10 +398,6 @@ void ExternalReferenceTable::PopulateTable(Isolate* isolate) {
       UNCLASSIFIED,
       38,
       "isolate");
-  Add(ExternalReference::address_of_minus_zero().address(),
-      UNCLASSIFIED,
-      39,
-      "LDoubleConstant::minus_zero");
   Add(ExternalReference::address_of_negative_infinity().address(),
       UNCLASSIFIED,
       40,
@@ -527,6 +523,31 @@ void ExternalReferenceTable::PopulateTable(Isolate* isolate) {
       67,
       "Debug::restarter_frame_function_pointer_address()");
 
+  Add(ExternalReference::flush_icache_function(isolate).address(), UNCLASSIFIED,
+      68, "CpuFeatures::FlushICache");
+
+  Add(ExternalReference::log_enter_external_function(isolate).address(),
+      UNCLASSIFIED, 69, "Logger::EnterExternal");
+
+  Add(ExternalReference::log_leave_external_function(isolate).address(),
+      UNCLASSIFIED, 70, "Logger::LeaveExternal");
+
+  Add(ExternalReference::address_of_minus_one_half().address(), UNCLASSIFIED,
+      71, "double_constants.minus_one_half");
+
+  Add(ExternalReference::stress_deopt_count(isolate).address(), UNCLASSIFIED,
+      72, "Isolate::stress_deopt_count_address()");
+
+  Add(ExternalReference::debug_is_active_address(isolate).address(),
+      UNCLASSIFIED, 73, "Debug::is_active_address()");
+
+  Add(ExternalReference::incremental_marking_record_write_function(isolate)
+          .address(),
+      UNCLASSIFIED, 74, "IncrementalMarking::RecordWriteFromCode");
+
+  Add(ExternalReference::math_log_double_function(isolate).address(),
+      UNCLASSIFIED, 75, "std::log");
+
   // 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);
@@ -538,6 +559,12 @@ void ExternalReferenceTable::PopulateTable(Isolate* isolate) {
         Deoptimizer::CALCULATE_ENTRY_ADDRESS);
     Add(address, LAZY_DEOPTIMIZATION, entry, "lazy_deopt");
   }
+
+#ifdef DEBUG
+  // Make sure that we do not have duplicate codes.
+  refs_.Sort(&Compare);
+  for (int i = 0; i < refs_.length() - 1; i++) CHECK(code(i) != code(i + 1));

[Jakob Kummerow, 2014/08/05 13:12:07]

With a little reordering of the TypeCode enum, you could guarantee ascending
(and, hence, unique) codes in linear time without sorting:

int last_seen = -1;
for(int i = 0; i < refs.length(); i++) {
  CHECK(code(i) > last_seen);
  last_seen = code(i);
}

Just for your consideration, I'm fine with either approach.

+#endif  // DEBUG
 }