Moved the ExternalReferenceTable class to src/external-reference-table.cc/.h

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/snapshot/serializer-common.h"
+#include "src/external-reference-table.h"
 
 #include "src/accessors.h"
 #include "src/assembler.h"
 #include "src/counters.h"
 #include "src/deoptimizer.h"
 #include "src/ic/stub-cache.h"
-#include "src/list-inl.h"
 
 namespace v8 {
 namespace internal {
 
 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);
@@ skipping 320 matching lines @@
   // 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");
   }
 }
 
-ExternalReferenceEncoder::ExternalReferenceEncoder(Isolate* isolate) {
-  map_ = isolate->external_reference_map();
-  if (map_ != NULL) return;
-  map_ = new HashMap(HashMap::PointersMatch);
-  ExternalReferenceTable* table = ExternalReferenceTable::instance(isolate);
-  for (int i = 0; i < table->size(); ++i) {
-    Address addr = table->address(i);
-    if (addr == ExternalReferenceTable::NotAvailable()) continue;
-    // We expect no duplicate external references entries in the table.
-    DCHECK_NULL(map_->Lookup(addr, Hash(addr)));
-    map_->LookupOrInsert(addr, Hash(addr))->value = reinterpret_cast<void*>(i);
-  }
-  isolate->set_external_reference_map(map_);
-}
-
-uint32_t ExternalReferenceEncoder::Encode(Address address) const {
-  DCHECK_NOT_NULL(address);
-  HashMap::Entry* entry =
-      const_cast<HashMap*>(map_)->Lookup(address, Hash(address));
-  DCHECK_NOT_NULL(entry);
-  return static_cast<uint32_t>(reinterpret_cast<intptr_t>(entry->value));
-}
-
-const char* ExternalReferenceEncoder::NameOfAddress(Isolate* isolate,
-                                                    Address address) const {
-  HashMap::Entry* entry =
-      const_cast<HashMap*>(map_)->Lookup(address, Hash(address));
-  if (entry == NULL) return "<unknown>";
-  uint32_t i = static_cast<uint32_t>(reinterpret_cast<intptr_t>(entry->value));
-  return ExternalReferenceTable::instance(isolate)->name(i);
-}
-
-void SerializedData::AllocateData(int size) {
-  DCHECK(!owns_data_);
-  data_ = NewArray<byte>(size);
-  size_ = size;
-  owns_data_ = true;
-  DCHECK(IsAligned(reinterpret_cast<intptr_t>(data_), kPointerAlignment));
-}
-
-// The partial snapshot cache is terminated by undefined. We visit the
-// partial snapshot...
-//  - during deserialization to populate it.
-//  - during normal GC to keep its content alive.
-//  - not during serialization. The partial serializer adds to it explicitly.
-void SerializerDeserializer::Iterate(Isolate* isolate, ObjectVisitor* visitor) {
-  List<Object*>* cache = isolate->partial_snapshot_cache();
-  for (int i = 0;; ++i) {
-    // Extend the array ready to get a value when deserializing.
-    if (cache->length() <= i) cache->Add(Smi::FromInt(0));
-    // During deserialization, the visitor populates the partial snapshot cache
-    // and eventually terminates the cache with undefined.
-    visitor->VisitPointer(&cache->at(i));
-    if (cache->at(i)->IsUndefined()) break;
-  }
-}
-
-bool SerializerDeserializer::CanBeDeferred(HeapObject* o) {
-  return !o->IsString() && !o->IsScript();
-}
-
 }  // namespace internal
 }  // namespace v8