Reduce the size of a release sample shell by 55k.

src/serialize.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 399 matching lines @@
 
   uint32_t code(int i) { return refs_[i].code; }
 
   const char* name(int i) { return refs_[i].name; }
 
   int max_id(int code) { return max_id_[code]; }
 
  private:
   static ExternalReferenceTable* instance_;
 
-  ExternalReferenceTable();
+  ExternalReferenceTable() : refs_(64) { PopulateTable(); }
+  ~ExternalReferenceTable() { }
 
   struct ExternalReferenceEntry {
     Address address;
     uint32_t code;
     const char* name;
   };
 
-  void Add(Address address, TypeCode type, uint16_t id, const char* name) {
-    CHECK_NE(NULL, address);
-    ExternalReferenceEntry entry;
-    entry.address = address;
-    entry.code = EncodeExternal(type, id);
-    entry.name = name;
-    CHECK_NE(0, entry.code);
-    refs_.Add(entry);
-    if (id > max_id_[type]) max_id_[type] = id;
-  }
+  void PopulateTable();
+
+  // For a few types of references, we can get their address from their id.
+  void AddFromId(TypeCode type, uint16_t id, const char* name);
+
+  // For other types of references, the caller will figure out the address.
+  void Add(Address address, TypeCode type, uint16_t id, const char* name);
 
   List<ExternalReferenceEntry> refs_;
   int max_id_[kTypeCodeCount];
 };
 
 
 ExternalReferenceTable* ExternalReferenceTable::instance_ = NULL;
 
+void ExternalReferenceTable::AddFromId(TypeCode type,
+                                       uint16_t id,
+                                       const char* name) {
+  Address address;
+  switch (type) {
+    case C_BUILTIN:
+      address = Builtins::c_function_address(
+          static_cast<Builtins::CFunctionId>(id));
+      break;
+    case BUILTIN:
+      address = Builtins::builtin_address(static_cast<Builtins::Name>(id));
+      break;
+    case RUNTIME_FUNCTION:
+      address = Runtime::FunctionForId(
+          static_cast<Runtime::FunctionId>(id))->entry;
+      break;
+    case IC_UTILITY:
+      address = IC::AddressFromUtilityId(static_cast<IC::UtilityId>(id));
+      break;
+    default:
+      UNREACHABLE();
+      return;
+  }
+  Add(address, type, id, name);
+}
 
-ExternalReferenceTable::ExternalReferenceTable() : refs_(64) {
+void ExternalReferenceTable::Add(Address address,
+                                 TypeCode type,
+                                 uint16_t id,
+                                 const char* name) {
+  CHECK_NE(NULL, address);
+  ExternalReferenceEntry entry;
+  entry.address = address;
+  entry.code = EncodeExternal(type, id);
+  entry.name = name;
+  CHECK_NE(0, entry.code);
+  refs_.Add(entry);
+  if (id > max_id_[type]) max_id_[type] = id;
+}
+
+
+void ExternalReferenceTable::PopulateTable() {
   for (int type_code = 0; type_code < kTypeCodeCount; type_code++) {
     max_id_[type_code] = 0;
   }
 
-  // Define all entries in the table.
+  // 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.
 
+  struct RefTableEntry {
+    TypeCode type;
+    uint16_t id;
+    const char* name;
+  };
+
+  static const RefTableEntry ref_table[] = {
   // Builtins
 #define DEF_ENTRY_C(name) \
-  Add(Builtins::c_function_address(Builtins::c_##name), \
-      C_BUILTIN, \
-      Builtins::c_##name, \
-      "Builtins::" #name);
+  { C_BUILTIN, \
+    Builtins::c_##name, \
+    "Builtins::" #name },
 
   BUILTIN_LIST_C(DEF_ENTRY_C)
 #undef DEF_ENTRY_C
 
 #define DEF_ENTRY_C(name) \
-  Add(Builtins::builtin_address(Builtins::name), \
-      BUILTIN, \
-      Builtins::name, \
-      "Builtins::" #name);
+  { BUILTIN, \
+    Builtins::name, \
+    "Builtins::" #name },
 #define DEF_ENTRY_A(name, kind, state) DEF_ENTRY_C(name)
 
   BUILTIN_LIST_C(DEF_ENTRY_C)
   BUILTIN_LIST_A(DEF_ENTRY_A)
   BUILTIN_LIST_DEBUG_A(DEF_ENTRY_A)
 #undef DEF_ENTRY_C
 #undef DEF_ENTRY_A
 
   // Runtime functions
 #define RUNTIME_ENTRY(name, nargs) \
-  Add(Runtime::FunctionForId(Runtime::k##name)->entry, \
-      RUNTIME_FUNCTION, \
-      Runtime::k##name, \
-      "Runtime::" #name);
+  { RUNTIME_FUNCTION, \
+    Runtime::k##name, \
+    "Runtime::" #name },
 
   RUNTIME_FUNCTION_LIST(RUNTIME_ENTRY)
 #undef RUNTIME_ENTRY
 
   // IC utilities
 #define IC_ENTRY(name) \
-  Add(IC::AddressFromUtilityId(IC::k##name), \
-      IC_UTILITY, \
-      IC::k##name, \
-      "IC::" #name);
+  { IC_UTILITY, \
+    IC::k##name, \
+    "IC::" #name },
 
   IC_UTIL_LIST(IC_ENTRY)
 #undef IC_ENTRY
 
+  };  // end of ref_table[].
+
+  for (size_t i = 0; i < ARRAY_SIZE(ref_table); ++i) {
+    AddFromId(ref_table[i].type, ref_table[i].id, ref_table[i].name);
+  }
+
   // Debug addresses
   Add(Debug_Address(Debug::k_after_break_target_address).address(),
       DEBUG_ADDRESS,
       Debug::k_after_break_target_address << kDebugIdShift,
       "Debug::after_break_target_address()");
   Add(Debug_Address(Debug::k_debug_break_return_address).address(),
       DEBUG_ADDRESS,
       Debug::k_debug_break_return_address << kDebugIdShift,
       "Debug::debug_break_return_address()");
   const char* debug_register_format = "Debug::register_address(%i)";
   size_t dr_format_length = strlen(debug_register_format);
   for (int i = 0; i < kNumJSCallerSaved; ++i) {
     Vector<char> name = Vector<char>::New(dr_format_length + 1);
     OS::SNPrintF(name, debug_register_format, i);
     Add(Debug_Address(Debug::k_register_address, i).address(),
         DEBUG_ADDRESS,
         Debug::k_register_address << kDebugIdShift | i,
         name.start());
   }
 
   // Stat counters
+  struct StatsRefTableEntry {
+    StatsCounter* counter;
+    uint16_t id;
+    const char* name;
+  };
+
+  static const StatsRefTableEntry stats_ref_table[] = {
+
 #define COUNTER_ENTRY(name, caption) \
-  Add(reinterpret_cast<Address>(GetInternalPointer(&Counters::name)), \
-      STATS_COUNTER, \
-      Counters::k_##name, \
-      "Counters::" #name);
+  { &Counters::name, \
+    Counters::k_##name, \
+      "Counters::" #name },
 
   STATS_COUNTER_LIST_1(COUNTER_ENTRY)
   STATS_COUNTER_LIST_2(COUNTER_ENTRY)
 #undef COUNTER_ENTRY
 
+  };  // end of stats_ref_table[].
+
+  for (size_t i = 0; i < ARRAY_SIZE(stats_ref_table); ++i) {
+    Add(reinterpret_cast<Address>(
+            GetInternalPointer(stats_ref_table[i].counter)),
+        STATS_COUNTER,
+        stats_ref_table[i].id,
+        stats_ref_table[i].name);
+  }
+
   // Top addresses
   const char* top_address_format = "Top::get_address_from_id(%i)";
   size_t top_format_length = strlen(top_address_format);
   for (uint16_t i = 0; i < Top::k_top_address_count; ++i) {
     Vector<char> name = Vector<char>::New(top_format_length + 1);
     const char* chars = name.start();
     OS::SNPrintF(name, top_address_format, i);
     Add(Top::get_address_from_id((Top::AddressId)i), TOP_ADDRESS, i, chars);
   }
 
@@ skipping 980 matching lines @@
         ASSERT(index < large_objects_.length());
       }
       return large_objects_[index];  // s.page_offset() is ignored.
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 } }  // namespace v8::internal