Split Snapshot::kFull into kCore, kAppWithJIT, and kAppNoJIT. Remove snapshot_code flag.

runtime/vm/snapshot.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_SNAPSHOT_H_
 #define VM_SNAPSHOT_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/bitfield.h"
@@ skipping 133 matching lines @@
 
 
 // Structure capturing the raw snapshot.
 //
 // TODO(turnidge): Remove this class once the snapshot does not have a
 // header anymore.  This is pending on making the embedder pass in the
 // length of their snapshot.
 class Snapshot {
  public:
   enum Kind {
-    kFull = 0,  // Full snapshot of the current dart heap.
-    kScript,    // A partial snapshot of only the application script.
-    kMessage,   // A partial snapshot used only for isolate messaging.
+    kCore = 0,    // Full snapshot of core libraries. No root library, no code.
+    kAppWithJIT,  // Full snapshot of core libraries and application. Has some
+                  // code, but may compile in the future because we haven't
+                  // necessarily included code for every function or to
+                  // (de)optimize.
+    kAppNoJIT,    // Full snapshot of core libraries and application. Has
+                  // complete code for the application that never deopts. Will
+                  // not compile in the future.
+    kScript,      // A partial snapshot of only the application script.
+    kMessage,     // A partial snapshot used only for isolate messaging.
   };
 
   static const int kHeaderSize = 2 * sizeof(int64_t);
   static const int kLengthIndex = 0;
   static const int kSnapshotFlagIndex = 1;
 
   static const Snapshot* SetupFromBuffer(const void* raw_memory);
 
   // Getters.
   const uint8_t* content() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
   intptr_t length() const {
     return static_cast<intptr_t>(ReadUnaligned(&unaligned_length_));
   }
   Kind kind() const {
     return static_cast<Kind>(ReadUnaligned(&unaligned_kind_));
   }
 
+  static bool IsFull(Kind kind) {
+    return (kind == kCore) || (kind == kAppWithJIT) || (kind == kAppNoJIT);
+  }
+  static bool IncludesCode(Kind kind) {
+    return (kind == kAppWithJIT) || (kind == kAppNoJIT);
+  }
+
   bool IsMessageSnapshot() const { return kind() == kMessage; }
   bool IsScriptSnapshot() const { return kind() == kScript; }
-  bool IsFullSnapshot() const { return kind() == kFull; }
+  bool IsCoreSnapshot() const { return kind() == kCore; }
+  bool IsAppSnapshotWithJIT() const { return kind() == kAppWithJIT; }
+  bool IsAppSnapshotNoJIT() const { return kind() == kAppNoJIT; }
   uint8_t* Addr() { return reinterpret_cast<uint8_t*>(this); }
 
   static intptr_t length_offset() {
     return OFFSET_OF(Snapshot, unaligned_length_);
   }
   static intptr_t kind_offset() {
     return OFFSET_OF(Snapshot, unaligned_kind_);
   }
 
  private:
@@ skipping 209 matching lines @@
   AbstractType* TypeHandle() { return &type_; }
   TypeArguments* TypeArgumentsHandle() { return &type_arguments_; }
   GrowableObjectArray* TokensHandle() { return &tokens_; }
   TokenStream* StreamHandle() { return &stream_; }
   ExternalTypedData* DataHandle() { return &data_; }
   TypedData* TypedDataHandle() { return &typed_data_; }
   Code* CodeHandle() { return &code_; }
   Function* FunctionHandle() { return &function_; }
   MegamorphicCache* MegamorphicCacheHandle() { return &megamorphic_cache_; }
   Snapshot::Kind kind() const { return kind_; }
-  bool snapshot_code() const { return snapshot_code_; }
 
   // Reads an object.
   RawObject* ReadObject();
 
   // Add object to backward references.
   void AddBackRef(intptr_t id,
                   Object* obj,
                   DeserializeState state,
                   bool defer_canonicalization = false);
 
@@ skipping 143 matching lines @@
 
   intptr_t NextAvailableObjectId() const;
 
   void SetReadException(const char* msg);
 
   RawObject* VmIsolateSnapshotObject(intptr_t index) const;
 
   bool is_vm_isolate() const;
 
   Snapshot::Kind kind_;  // Indicates type of snapshot(full, script, message).
-  bool snapshot_code_;
   Thread* thread_;  // Current thread.
   Zone* zone_;  // Zone for allocations while reading snapshot.
   Heap* heap_;  // Heap of the current isolate.
   PageSpace* old_space_;  // Old space of the current isolate.
   Class& cls_;  // Temporary Class handle.
   Object& obj_;  // Temporary Object handle.
   PassiveObject& pobj_;  // Temporary PassiveObject handle.
   Array& array_;  // Temporary Array handle.
   Field& field_;  // Temporary Field handle.
   String& str_;  // Temporary String handle.
@@ skipping 53 matching lines @@
   friend class TypeRef;
   friend class UnhandledException;
   friend class UnresolvedClass;
   friend class WeakProperty;
   DISALLOW_COPY_AND_ASSIGN(SnapshotReader);
 };
 
 
 class VmIsolateSnapshotReader : public SnapshotReader {
  public:
-  VmIsolateSnapshotReader(const uint8_t* buffer,
+  VmIsolateSnapshotReader(Snapshot::Kind kind,
+                          const uint8_t* buffer,
                           intptr_t size,
                           const uint8_t* instructions_buffer,
                           const uint8_t* data_buffer,
                           Thread* thread);
   ~VmIsolateSnapshotReader();
 
   RawApiError* ReadVmIsolateSnapshot();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VmIsolateSnapshotReader);
 };
 
 
 class IsolateSnapshotReader : public SnapshotReader {
  public:
-  IsolateSnapshotReader(const uint8_t* buffer,
+  IsolateSnapshotReader(Snapshot::Kind kind,
+                        const uint8_t* buffer,
                         intptr_t size,
                         const uint8_t* instructions_buffer,
                         const uint8_t* data_buffer,
                         Thread* thread);
   ~IsolateSnapshotReader();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IsolateSnapshotReader);
 };
 
@@ skipping 284 matching lines @@
  private:
   WriteStream instructions_blob_stream_;
   WriteStream rodata_blob_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(BlobInstructionsWriter);
 };
 
 
 class SnapshotWriter : public BaseWriter {
  protected:
-  SnapshotWriter(Snapshot::Kind kind,
-                 Thread* thread,
+  SnapshotWriter(Thread* thread,
+                 Snapshot::Kind kind,
                  uint8_t** buffer,
                  ReAlloc alloc,
                  intptr_t initial_size,
                  ForwardList* forward_list,
                  InstructionsWriter* instructions_writer,
                  bool can_send_any_object,
-                 bool snapshot_code,
                  bool vm_isolate_is_symbolic);
 
  public:
   // Snapshot kind.
   Snapshot::Kind kind() const { return kind_; }
   Thread* thread() const { return thread_; }
   Zone* zone() const { return thread_->zone(); }
   Isolate* isolate() const { return thread_->isolate(); }
   Heap* heap() const { return isolate()->heap(); }
 
   // Serialize an object into the buffer.
   void WriteObject(RawObject* raw);
 
   uword GetObjectTags(RawObject* raw);
 
   Exceptions::ExceptionType exception_type() const {
     return exception_type_;
   }
   void set_exception_type(Exceptions::ExceptionType type) {
     exception_type_ = type;
   }
   const char* exception_msg() const { return exception_msg_; }
   void set_exception_msg(const char* msg) {
     exception_msg_ = msg;
   }
   bool can_send_any_object() const { return can_send_any_object_; }
-  bool snapshot_code() const { return snapshot_code_; }
   bool vm_isolate_is_symbolic() const { return vm_isolate_is_symbolic_; }
   void ThrowException(Exceptions::ExceptionType type, const char* msg);
 
   // Write a version string for the snapshot.
   void WriteVersion();
 
   static intptr_t FirstObjectId();
 
   int32_t GetInstructionsId(RawInstructions* instructions, RawCode* code) {
     return instructions_writer_->GetOffsetFor(instructions, code);
@@ skipping 45 matching lines @@
     forward_list_ = forward_list;
   }
   void ResetForwardList() {
     ASSERT(forward_list_ != NULL);
     forward_list_ = NULL;
   }
 
   ObjectStore* object_store() const { return object_store_; }
 
  private:
+  Thread* thread_;
   Snapshot::Kind kind_;
-  Thread* thread_;
   ObjectStore* object_store_;  // Object store for common classes.
   ClassTable* class_table_;  // Class table for the class index to class lookup.
   ForwardList* forward_list_;
   InstructionsWriter* instructions_writer_;
   Exceptions::ExceptionType exception_type_;  // Exception type.
   const char* exception_msg_;  // Message associated with exception.
   bool unmarked_objects_;  // True if marked objects have been unmarked.
   bool can_send_any_object_;  // True if any Dart instance can be sent.
-  bool snapshot_code_;
   bool vm_isolate_is_symbolic_;
 
   friend class FullSnapshotWriter;
   friend class RawArray;
   friend class RawClass;
   friend class RawClosureData;
   friend class RawCode;
   friend class RawContextScope;
   friend class RawExceptionHandlers;
   friend class RawField;
@@ skipping 17 matching lines @@
   friend class RawUserTag;
   friend class SnapshotWriterVisitor;
   friend class WriteInlinedObjectVisitor;
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriter);
 };
 
 
 class FullSnapshotWriter {
  public:
   static const intptr_t kInitialSize = 64 * KB;
-  FullSnapshotWriter(uint8_t** vm_isolate_snapshot_buffer,
+  FullSnapshotWriter(Snapshot::Kind kind,
+                     uint8_t** vm_isolate_snapshot_buffer,
                      uint8_t** isolate_snapshot_buffer,
                      ReAlloc alloc,
                      InstructionsWriter* instructions_writer,
-                     bool snapshot_code,
                      bool vm_isolate_is_symbolic);
   ~FullSnapshotWriter();
 
   uint8_t** vm_isolate_snapshot_buffer() {
     return vm_isolate_snapshot_buffer_;
   }
 
   uint8_t** isolate_snapshot_buffer() {
     return isolate_snapshot_buffer_;
   }
@@ skipping 14 matching lines @@
   }
 
  private:
   // Writes a snapshot of the VM Isolate.
   void WriteVmIsolateSnapshot();
 
   // Writes a full snapshot of a regular Dart Isolate.
   void WriteIsolateFullSnapshot();
 
   Thread* thread_;
+  Snapshot::Kind kind_;
   uint8_t** vm_isolate_snapshot_buffer_;
   uint8_t** isolate_snapshot_buffer_;
   ReAlloc alloc_;
   intptr_t vm_isolate_snapshot_size_;
   intptr_t isolate_snapshot_size_;
   ForwardList* forward_list_;
   InstructionsWriter* instructions_writer_;
   Array& scripts_;
   Array& symbol_table_;
-  bool snapshot_code_;
   bool vm_isolate_is_symbolic_;
 
   DISALLOW_COPY_AND_ASSIGN(FullSnapshotWriter);
 };
 
 
 class PrecompiledSnapshotWriter : public FullSnapshotWriter {
  public:
   PrecompiledSnapshotWriter(uint8_t** vm_isolate_snapshot_buffer,
                             uint8_t** isolate_snapshot_buffer,
@@ skipping 48 matching lines @@
  private:
   SnapshotWriter* writer_;
   bool as_references_;
 
   DISALLOW_COPY_AND_ASSIGN(SnapshotWriterVisitor);
 };
 
 }  // namespace dart
 
 #endif  // VM_SNAPSHOT_H_