Small fixes for the code serializer.

src/serialize.h

 // Copyright 2012 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.
 
 #ifndef V8_SERIALIZE_H_
 #define V8_SERIALIZE_H_
 
 #include "src/compiler.h"
 #include "src/hashmap.h"
 #include "src/heap-profiler.h"
@@ skipping 246 matching lines @@
 
   // Deserialize a single object and the objects reachable from it.
   // We may want to abort gracefully even if deserialization fails.
   void DeserializePartial(Isolate* isolate, Object** root,
                           OnOOM on_oom = FATAL_ON_OOM);
 
   void AddReservation(int space, uint32_t chunk) {
     DCHECK(space >= 0);
     DCHECK(space < kNumberOfSpaces);
     DCHECK(space == LO_SPACE ||
-           chunk < static_cast<uint32_t>(Page::kMaxRegularHeapObjectSize));
+           chunk <= static_cast<uint32_t>(Page::kMaxRegularHeapObjectSize));
     reservations_[space].Add({chunk, NULL, NULL});
   }
 
   void FlushICacheForNewCodeObjects();
 
   // Serialized user code reference certain objects that are provided in a list
   // By calling this method, we assume that we are deserializing user code.
   void SetAttachedObjects(Vector<Handle<Object> >* attached_objects) {
     attached_objects_ = attached_objects;
   }
@@ skipping 334 matching lines @@
   static ScriptData* Serialize(Isolate* isolate,
                                Handle<SharedFunctionInfo> info,
                                Handle<String> source);
 
   MUST_USE_RESULT static MaybeHandle<SharedFunctionInfo> Deserialize(
       Isolate* isolate, ScriptData* data, Handle<String> source);
 
   static const int kSourceObjectIndex = 0;
   static const int kCodeStubsBaseIndex = 1;
 
-  String* source() {
+  String* source() const {
     DCHECK(!AllowHeapAllocation::IsAllowed());
     return source_;
   }
 
   List<uint32_t>* stub_keys() { return &stub_keys_; }
+  int num_internalized_strings() const { return num_internalized_strings_; }
 
  private:
   CodeSerializer(Isolate* isolate, SnapshotByteSink* sink, String* source,
                  Code* main_code)
-      : Serializer(isolate, sink), source_(source), main_code_(main_code) {
+      : Serializer(isolate, sink),
+        source_(source),
+        main_code_(main_code),
+        num_internalized_strings_(0) {
     set_root_index_wave_front(Heap::kStrongRootListLength);
     InitializeCodeAddressMap();
   }
 
   virtual void SerializeObject(Object* o, HowToCode how_to_code,
                                WhereToPoint where_to_point, int skip);
 
   void SerializeBuiltin(int builtin_index, HowToCode how_to_code,
                         WhereToPoint where_to_point);
   void SerializeIC(Code* ic, HowToCode how_to_code,
                    WhereToPoint where_to_point);
   void SerializeCodeStub(uint32_t stub_key, HowToCode how_to_code,
                          WhereToPoint where_to_point);
   void SerializeSourceObject(HowToCode how_to_code,
                              WhereToPoint where_to_point);
   void SerializeHeapObject(HeapObject* heap_object, HowToCode how_to_code,
                            WhereToPoint where_to_point);
   int AddCodeStubKey(uint32_t stub_key);
 
   DisallowHeapAllocation no_gc_;
   String* source_;
   Code* main_code_;
+  int num_internalized_strings_;
   List<uint32_t> stub_keys_;
   DISALLOW_COPY_AND_ASSIGN(CodeSerializer);
 };
 
 
 // Wrapper around ScriptData to provide code-serializer-specific functionality.
 class SerializedCodeData {
  public:
   // Used by when consuming.
   explicit SerializedCodeData(ScriptData* data, String* source)
@@ skipping 22 matching lines @@
    public:
     uint32_t chunk_size() const { return ChunkSizeBits::decode(reservation); }
     bool is_last_chunk() const { return IsLastChunkBits::decode(reservation); }
 
    private:
     uint32_t reservation;
 
     DISALLOW_COPY_AND_ASSIGN(Reservation);
   };
 
+  int NumInternalizedStrings() const {
+    return GetHeaderValue(kNumInternalizedStringsOffset);
+  }
+
   Vector<const Reservation> Reservations() const {
     return Vector<const Reservation>(reinterpret_cast<const Reservation*>(
                                          script_data_->data() + kHeaderSize),
                                      GetHeaderValue(kReservationsOffset));
   }
 
   Vector<const uint32_t> CodeStubKeys() const {
     int reservations_size = GetHeaderValue(kReservationsOffset) * kInt32Size;
     const byte* start = script_data_->data() + kHeaderSize + reservations_size;
     return Vector<const uint32_t>(reinterpret_cast<const uint32_t*>(start),
@@ skipping 23 matching lines @@
   int GetHeaderValue(int offset) const {
     return reinterpret_cast<const int*>(script_data_->data())[offset];
   }
 
   bool IsSane(String* source);
 
   int CheckSum(String* source);
 
   // The data header consists of int-sized entries:
   // [0] version hash
-  // [1] number of code stub keys
-  // [2] payload length
-  // [3..9] reservation sizes for spaces from NEW_SPACE to PROPERTY_CELL_SPACE.
+  // [1] number of internalized strings
+  // [2] number of code stub keys
+  // [3] payload length
+  // [4..10] reservation sizes for spaces from NEW_SPACE to PROPERTY_CELL_SPACE.
   static const int kCheckSumOffset = 0;
-  static const int kReservationsOffset = 1;
-  static const int kNumCodeStubKeysOffset = 2;
-  static const int kPayloadLengthOffset = 3;
+  static const int kNumInternalizedStringsOffset = 1;
+  static const int kReservationsOffset = 2;
+  static const int kNumCodeStubKeysOffset = 3;
+  static const int kPayloadLengthOffset = 4;
   static const int kHeaderSize = (kPayloadLengthOffset + 1) * kIntSize;
 
   class ChunkSizeBits : public BitField<uint32_t, 0, 31> {};
   class IsLastChunkBits : public BitField<bool, 31, 1> {};
 
   // Following the header, we store, in sequential order
   // - code stub keys
   // - serialization payload
 
   ScriptData* script_data_;
   bool owns_script_data_;
 };
 } }  // namespace v8::internal
 
 #endif  // V8_SERIALIZE_H_