* Add the partial context snapshot to the VM executable if...

src/serialize.h

 // Copyright 2006-2009 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 155 matching lines @@
   f(14, 32) \
   f(15, 36)
 
 // The Serializer/Deserializer class is a common superclass for Serializer and
 // Deserializer which is used to store common constants and methods used by
 // both.
 class SerializerDeserializer: public ObjectVisitor {
  public:
   static void Iterate(ObjectVisitor* visitor);
   static void SetSnapshotCacheSize(int size);
-#ifdef DEBUG
-  static void StartTracing() { tracing_ = true; }
-  static void StopTracing() { tracing_ = false; }
-  static void Trace(const char *msg, int arg) { if (tracing_) printf("%s %d\n", msg, arg); }
-  static void Trace(const char *msg, const char* arg) { if (tracing_) printf("%s %s\n", msg, arg); }
-  static void Trace(const char *msg, const char* arg1, int arg2) { if (tracing_) printf("%s %s %d\n", msg, arg1, arg2); }
-  static bool tracing() { return tracing_; }
-#else
-  static void StartTracing() { }
-  static void StopTracing() { }
-  static void Trace(const char *msg, int arg) { }
-  static void Trace(const char *msg, const char* arg) { }
-  static void Trace(const char *msg, const char* arg1, int arg2) { }
-  static bool tracing() { return false; }
-#endif
 
  protected:
   enum DataType {
     RAW_DATA_SERIALIZATION = 0,
     // And 15 common raw lengths.
     OBJECT_SERIALIZATION = 16,
     // One variant per space.
     CODE_OBJECT_SERIALIZATION = 25,
     // One per space (only code spaces in use).
     EXTERNAL_REFERENCE_SERIALIZATION = 34,
@@ skipping 25 matching lines @@
   static const int kSpaceMask = 15;
 
   static inline bool SpaceIsLarge(int space) { return space >= kLargeData; }
   static inline bool SpaceIsPaged(int space) {
     return space >= FIRST_PAGED_SPACE && space <= LAST_PAGED_SPACE;
   }
 
   static int partial_snapshot_cache_length_;
   static const int kPartialSnapshotCacheCapacity = 1300;
   static Object* partial_snapshot_cache_[];
-  static bool tracing_;
 };
 
 
 int SnapshotByteSource::GetInt() {
   // A little unwind to catch the really small ints.
   int snapshot_byte = Get();
   if ((snapshot_byte & 0x80) == 0) {
-    SerializerDeserializer::Trace("Tag IntLastPart", snapshot_byte);
     return snapshot_byte;
   }
-  SerializerDeserializer::Trace("Tag IntPart", snapshot_byte);
   int accumulator = (snapshot_byte & 0x7f) << 7;
   while (true) {
     snapshot_byte = Get();
     if ((snapshot_byte & 0x80) == 0) {
-      SerializerDeserializer::Trace("Tag IntLastPart", snapshot_byte);
       return accumulator | snapshot_byte;
     }
-    SerializerDeserializer::Trace("Tag IntPart", snapshot_byte);
     accumulator = (accumulator | (snapshot_byte & 0x7f)) << 7;
   }
   UNREACHABLE();
   return accumulator;
 }
 
 
 void SnapshotByteSource::CopyRaw(byte* to, int number_of_bytes) {
-  if (SerializerDeserializer::tracing()) {
-    for (int i = 0; i < number_of_bytes; i++) {
-      SerializerDeserializer::Trace("Tag Byte", data_[position_ + i]);
-    }
-  }
   memcpy(to, data_ + position_, number_of_bytes);
   position_ += number_of_bytes;
 }
 
 
 // A Deserializer reads a snapshot and reconstructs the Object graph it defines.
 class Deserializer: public SerializerDeserializer {
  public:
   // Create a deserializer from a snapshot byte source.
   explicit Deserializer(SnapshotByteSource* source);
@@ skipping 278 matching lines @@
   virtual int RootIndex(HeapObject* o) { return kInvalidRootIndex; }
   virtual bool ShouldBeInThePartialSnapshotCache(HeapObject* o) {
     return false;
   }
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SERIALIZE_H_