Encode any deoptimizer entry in serialized data.

src/snapshot/deserializer.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/deserializer.h"
 
 #include "src/api.h"
 #include "src/assembler-inl.h"
 #include "src/bootstrapper.h"
 #include "src/external-reference-table.h"
@@ skipping 444 matching lines @@
   UnalignedCopy(write_back, &write_back_obj);
 #ifdef DEBUG
   if (obj->IsCode()) {
     DCHECK(space_number == CODE_SPACE || space_number == LO_SPACE);
   } else {
     DCHECK(space_number != CODE_SPACE);
   }
 #endif  // DEBUG
 }
 
+Address Deserializer::DecodeExternalReference(uint32_t reference_id) {
+  if (!(reference_id & ExternalReferenceTable::kSpecialIdMask))
+    return external_reference_table_->address(reference_id);
+  const uint32_t special_flags =
+      reference_id & ExternalReferenceTable::kSpecialIdMask;
+  Deoptimizer::BailoutType deopt_type;
+  switch (special_flags) {
+    case ExternalReferenceTable::kEagerDeoptFlag:
+      deopt_type = Deoptimizer::EAGER;
+      break;
+    case ExternalReferenceTable::kLazyDeoptFlag:
+      deopt_type = Deoptimizer::LAZY;
+      break;
+    case ExternalReferenceTable::kSoftDeoptFlag:
+      deopt_type = Deoptimizer::SOFT;
+      break;
+    default:
+      CHECK(false);
+      return nullptr;
+  }
+  int entry_id = reference_id & ~ExternalReferenceTable::kSpecialIdMask;
+  max_deopt_entry_ids_[deopt_type] =
+      std::max(max_deopt_entry_ids_[deopt_type], entry_id);
+  return Deoptimizer::GetDeoptimizationEntry(
+      isolate_, entry_id, deopt_type, Deoptimizer::CALCULATE_ENTRY_ADDRESS);
+}
 // We know the space requirements before deserialization and can
 // pre-allocate that reserved space. During deserialization, all we need
 // to do is to bump up the pointer for each space in the reserved
 // space. This is also used for fixing back references.
 // We may have to split up the pre-allocation into several chunks
 // because it would not fit onto a single page. We do not have to keep
 // track of when to move to the next chunk. An opcode will signal this.
 // Since multiple large objects cannot be folded into one large object
 // space allocation, we have to do an actual allocation when deserializing
 // each large object. Instead of tracking offset for back references, we
@@ skipping 86 matching lines @@
         hot_objects_.Add(HeapObject::cast(new_object));                        \
       } else if (where == kPartialSnapshotCache) {                             \
         int cache_index = source_.GetInt();                                    \
         new_object = isolate->partial_snapshot_cache()->at(cache_index);       \
         emit_write_barrier = isolate->heap()->InNewSpace(new_object);          \
       } else if (where == kExternalReference) {                                \
         int skip = source_.GetInt();                                           \
         current = reinterpret_cast<Object**>(                                  \
             reinterpret_cast<Address>(current) + skip);                        \
         uint32_t reference_id = static_cast<uint32_t>(source_.GetInt());       \
-        Address address = external_reference_table_->address(reference_id);    \
+        Address address = DecodeExternalReference(reference_id);               \
         new_object = reinterpret_cast<Object*>(address);                       \
       } else if (where == kAttachedReference) {                                \
         int index = source_.GetInt();                                          \
         new_object = *attached_objects_[index];                                \
         emit_write_barrier = isolate->heap()->InNewSpace(new_object);          \
       } else {                                                                 \
         DCHECK(where == kBuiltin);                                             \
         DCHECK(deserializing_user_code());                                     \
         int builtin_id = source_.GetInt();                                     \
         DCHECK_LE(0, builtin_id);                                              \
@@ skipping 308 matching lines @@
 
       default:
         CHECK(false);
     }
   }
   CHECK_EQ(limit, current);
   return true;
 }
 }  // namespace internal
 }  // namespace v8