CoreJIT snapshots without training.

runtime/vm/clustered_snapshot.cc

 // Copyright (c) 2016, 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.
 
 #include "vm/clustered_snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
@@ skipping 499 matching lines @@
 
   void Trace(Serializer* s, RawObject* object) {
     RawFunction* func = Function::RawCast(object);
     objects_.Add(func);
 
     RawObject** from = func->from();
     RawObject** to = func->to_snapshot();
     for (RawObject** p = from; p <= to; p++) {
       s->Push(*p);
     }
-    if (s->kind() == Snapshot::kAppAOT) {
+    if (s->kind() == Snapshot::kFullAOT) {
       s->Push(func->ptr()->code_);
-    } else if (s->kind() == Snapshot::kAppJIT) {
+    } else if (s->kind() == Snapshot::kFullJIT) {
       NOT_IN_PRECOMPILED(s->Push(func->ptr()->unoptimized_code_));
       s->Push(func->ptr()->code_);
       s->Push(func->ptr()->ic_data_array_);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kFunctionCid);
     intptr_t count = objects_.length();
     s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawFunction* func = objects_[i];
       s->AssignRef(func);
     }
   }
 
   void WriteFill(Serializer* s) {
     Snapshot::Kind kind = s->kind();
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawFunction* func = objects_[i];
       RawObject** from = func->from();
       RawObject** to = func->to_snapshot();
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
-      if (kind == Snapshot::kAppAOT) {
+      if (kind == Snapshot::kFullAOT) {
         s->WriteRef(func->ptr()->code_);
-      } else if (s->kind() == Snapshot::kAppJIT) {
+      } else if (s->kind() == Snapshot::kFullJIT) {
         NOT_IN_PRECOMPILED(s->WriteRef(func->ptr()->unoptimized_code_));
         s->WriteRef(func->ptr()->code_);
         s->WriteRef(func->ptr()->ic_data_array_);
       }
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
-      if (kind != Snapshot::kAppAOT) {
+      if (kind != Snapshot::kFullAOT) {
         s->WriteTokenPosition(func->ptr()->token_pos_);
         s->WriteTokenPosition(func->ptr()->end_token_pos_);
       }
 #endif
       s->Write<int16_t>(func->ptr()->num_fixed_parameters_);
       s->Write<int16_t>(func->ptr()->num_optional_parameters_);
       s->Write<uint32_t>(func->ptr()->kind_tag_);
-      if (kind == Snapshot::kAppAOT) {
+      if (kind == Snapshot::kFullAOT) {
         // Omit fields used to support de/reoptimization.
       } else if (!Snapshot::IncludesCode(kind)) {
 #if !defined(DART_PRECOMPILED_RUNTIME)
         bool is_optimized = Code::IsOptimized(func->ptr()->code_);
         if (is_optimized) {
           s->Write<int32_t>(FLAG_optimization_counter_threshold);
         } else {
           s->Write<int32_t>(0);
         }
 #endif
@@ skipping 32 matching lines @@
                                      Function::InstanceSize(), is_vm_object);
       RawObject** from = func->from();
       RawObject** to_snapshot = func->to_snapshot();
       RawObject** to = func->to();
       for (RawObject** p = from; p <= to_snapshot; p++) {
         *p = d->ReadRef();
       }
       for (RawObject** p = to_snapshot + 1; p <= to; p++) {
         *p = Object::null();
       }
-      if (kind == Snapshot::kAppAOT) {
+      if (kind == Snapshot::kFullAOT) {
         func->ptr()->code_ = reinterpret_cast<RawCode*>(d->ReadRef());
-      } else if (kind == Snapshot::kAppJIT) {
+      } else if (kind == Snapshot::kFullJIT) {
         NOT_IN_PRECOMPILED(func->ptr()->unoptimized_code_ =
                                reinterpret_cast<RawCode*>(d->ReadRef()));
         func->ptr()->code_ = reinterpret_cast<RawCode*>(d->ReadRef());
         func->ptr()->ic_data_array_ = reinterpret_cast<RawArray*>(d->ReadRef());
       }
 
 #if defined(DEBUG)
       func->ptr()->entry_point_ = 0;
 #endif
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
-      if (kind != Snapshot::kAppAOT) {
+      if (kind != Snapshot::kFullAOT) {
         func->ptr()->token_pos_ = d->ReadTokenPosition();
         func->ptr()->end_token_pos_ = d->ReadTokenPosition();
       }
 #endif
       func->ptr()->num_fixed_parameters_ = d->Read<int16_t>();
       func->ptr()->num_optional_parameters_ = d->Read<int16_t>();
       func->ptr()->kind_tag_ = d->Read<uint32_t>();
-      if (kind == Snapshot::kAppAOT) {
+      if (kind == Snapshot::kFullAOT) {
         // Omit fields used to support de/reoptimization.
       } else {
 #if !defined(DART_PRECOMPILED_RUNTIME)
         if (Snapshot::IncludesCode(kind)) {
           func->ptr()->usage_counter_ = 0;
         } else {
           func->ptr()->usage_counter_ = d->Read<int32_t>();
         }
         func->ptr()->deoptimization_counter_ = 0;
         func->ptr()->optimized_instruction_count_ = 0;
         func->ptr()->optimized_call_site_count_ = 0;
 #endif
       }
     }
   }
 
   void PostLoad(const Array& refs, Snapshot::Kind kind, Zone* zone) {
     NOT_IN_PRODUCT(TimelineDurationScope tds(
         Thread::Current(), Timeline::GetIsolateStream(), "PostLoadFunction"));
 
-    if (kind == Snapshot::kAppAOT) {
+    if (kind == Snapshot::kFullAOT) {
       Function& func = Function::Handle(zone);
       for (intptr_t i = start_index_; i < stop_index_; i++) {
         func ^= refs.At(i);
         ASSERT(func.raw()->ptr()->code_->IsCode());
         uword entry_point = func.raw()->ptr()->code_->ptr()->entry_point_;
         ASSERT(entry_point != 0);
         func.raw()->ptr()->entry_point_ = entry_point;
       }
-    } else if (kind == Snapshot::kAppJIT) {
+    } else if (kind == Snapshot::kFullJIT) {
       Function& func = Function::Handle(zone);
       Code& code = Code::Handle(zone);
       for (intptr_t i = start_index_; i < stop_index_; i++) {
         func ^= refs.At(i);
         code ^= func.CurrentCode();
         if (func.HasCode() && !code.IsDisabled()) {
           func.SetInstructions(code);
           func.set_was_compiled(true);
         } else {
           func.ClearCode();
@@ skipping 16 matching lines @@
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class ClosureDataSerializationCluster : public SerializationCluster {
  public:
   ClosureDataSerializationCluster() {}
   virtual ~ClosureDataSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
     RawClosureData* data = ClosureData::RawCast(object);
     objects_.Add(data);
 
-    if (s->kind() != Snapshot::kAppAOT) {
+    if (s->kind() != Snapshot::kFullAOT) {
       s->Push(data->ptr()->context_scope_);
     }
     s->Push(data->ptr()->parent_function_);
     s->Push(data->ptr()->signature_type_);
     s->Push(data->ptr()->closure_);
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kClosureDataCid);
     intptr_t count = objects_.length();
     s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawClosureData* data = objects_[i];
       s->AssignRef(data);
     }
   }
 
   void WriteFill(Serializer* s) {
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawClosureData* data = objects_[i];
-      if (s->kind() != Snapshot::kAppAOT) {
+      if (s->kind() != Snapshot::kFullAOT) {
         s->WriteRef(data->ptr()->context_scope_);
       }
       s->WriteRef(data->ptr()->parent_function_);
       s->WriteRef(data->ptr()->signature_type_);
       s->WriteRef(data->ptr()->closure_);
     }
   }
 
  private:
   GrowableArray<RawClosureData*> objects_;
@@ skipping 17 matching lines @@
     stop_index_ = d->next_index();
   }
 
   void ReadFill(Deserializer* d) {
     bool is_vm_object = d->isolate() == Dart::vm_isolate();
 
     for (intptr_t id = start_index_; id < stop_index_; id++) {
       RawClosureData* data = reinterpret_cast<RawClosureData*>(d->Ref(id));
       Deserializer::InitializeHeader(data, kClosureDataCid,
                                      ClosureData::InstanceSize(), is_vm_object);
-      if (d->kind() == Snapshot::kAppAOT) {
+      if (d->kind() == Snapshot::kFullAOT) {
         data->ptr()->context_scope_ = ContextScope::null();
       } else {
         data->ptr()->context_scope_ =
             static_cast<RawContextScope*>(d->ReadRef());
       }
       data->ptr()->parent_function_ = static_cast<RawFunction*>(d->ReadRef());
       data->ptr()->signature_type_ = static_cast<RawType*>(d->ReadRef());
       data->ptr()->closure_ = static_cast<RawInstance*>(d->ReadRef());
       data->ptr()->hash_ = Object::null();
     }
@@ skipping 169 matching lines @@
     RawField* field = Field::RawCast(object);
     objects_.Add(field);
 
     Snapshot::Kind kind = s->kind();
 
     s->Push(field->ptr()->name_);
     s->Push(field->ptr()->owner_);
     s->Push(field->ptr()->type_);
     // Write out the initial static value or field offset.
     if (Field::StaticBit::decode(field->ptr()->kind_bits_)) {
-      if (kind == Snapshot::kAppAOT) {
+      if (kind == Snapshot::kFullAOT) {
         // For precompiled static fields, the value was already reset and
         // initializer_ now contains a Function.
         s->Push(field->ptr()->value_.static_value_);
       } else if (Field::ConstBit::decode(field->ptr()->kind_bits_)) {
         // Do not reset const fields.
         s->Push(field->ptr()->value_.static_value_);
       } else {
         // Otherwise, for static fields we write out the initial static value.
         s->Push(field->ptr()->initializer_.saved_value_);
       }
     } else {
       s->Push(field->ptr()->value_.offset_);
     }
     // Write out the initializer function or saved initial value.
-    if (kind == Snapshot::kAppAOT) {
+    if (kind == Snapshot::kFullAOT) {
       s->Push(field->ptr()->initializer_.precompiled_);
     } else {
       s->Push(field->ptr()->initializer_.saved_value_);
     }
-    if (kind != Snapshot::kAppAOT) {
+    if (kind != Snapshot::kFullAOT) {
       // Write out the guarded list length.
       s->Push(field->ptr()->guarded_list_length_);
     }
-    if (kind == Snapshot::kAppJIT) {
+    if (kind == Snapshot::kFullJIT) {
       s->Push(field->ptr()->dependent_code_);
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kFieldCid);
     intptr_t count = objects_.length();
     s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawField* field = objects_[i];
       s->AssignRef(field);
     }
   }
 
   void WriteFill(Serializer* s) {
     Snapshot::Kind kind = s->kind();
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawField* field = objects_[i];
 
       s->WriteRef(field->ptr()->name_);
       s->WriteRef(field->ptr()->owner_);
       s->WriteRef(field->ptr()->type_);
       // Write out the initial static value or field offset.
       if (Field::StaticBit::decode(field->ptr()->kind_bits_)) {
-        if (kind == Snapshot::kAppAOT) {
+        if (kind == Snapshot::kFullAOT) {
           // For precompiled static fields, the value was already reset and
           // initializer_ now contains a Function.
           s->WriteRef(field->ptr()->value_.static_value_);
         } else if (Field::ConstBit::decode(field->ptr()->kind_bits_)) {
           // Do not reset const fields.
           s->WriteRef(field->ptr()->value_.static_value_);
         } else {
           // Otherwise, for static fields we write out the initial static value.
           s->WriteRef(field->ptr()->initializer_.saved_value_);
         }
       } else {
         s->WriteRef(field->ptr()->value_.offset_);
       }
       // Write out the initializer function or saved initial value.
-      if (kind == Snapshot::kAppAOT) {
+      if (kind == Snapshot::kFullAOT) {
         s->WriteRef(field->ptr()->initializer_.precompiled_);
       } else {
         s->WriteRef(field->ptr()->initializer_.saved_value_);
       }
-      if (kind != Snapshot::kAppAOT) {
+      if (kind != Snapshot::kFullAOT) {
         // Write out the guarded list length.
         s->WriteRef(field->ptr()->guarded_list_length_);
       }
-      if (kind == Snapshot::kAppJIT) {
+      if (kind == Snapshot::kFullJIT) {
         s->WriteRef(field->ptr()->dependent_code_);
       }
 
-      if (kind != Snapshot::kAppAOT) {
+      if (kind != Snapshot::kFullAOT) {
         s->WriteTokenPosition(field->ptr()->token_pos_);
         s->WriteCid(field->ptr()->guarded_cid_);
         s->WriteCid(field->ptr()->is_nullable_);
       }
       s->Write<uint8_t>(field->ptr()->kind_bits_);
     }
   }
 
  private:
   GrowableArray<RawField*> objects_;
@@ skipping 27 matching lines @@
       RawObject** from = field->from();
       RawObject** to_snapshot = field->to_snapshot(kind);
       RawObject** to = field->to();
       for (RawObject** p = from; p <= to_snapshot; p++) {
         *p = d->ReadRef();
       }
       for (RawObject** p = to_snapshot + 1; p <= to; p++) {
         *p = Object::null();
       }
 
-      if (kind != Snapshot::kAppAOT) {
+      if (kind != Snapshot::kFullAOT) {
         field->ptr()->token_pos_ = d->ReadTokenPosition();
         field->ptr()->guarded_cid_ = d->ReadCid();
         field->ptr()->is_nullable_ = d->ReadCid();
       }
       field->ptr()->kind_bits_ = d->Read<uint8_t>();
     }
   }
 
   void PostLoad(const Array& refs, Snapshot::Kind kind, Zone* zone) {
     NOT_IN_PRODUCT(TimelineDurationScope tds(
@@ skipping 444 matching lines @@
 };
 
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class CodeSerializationCluster : public SerializationCluster {
  public:
   CodeSerializationCluster() {}
   virtual ~CodeSerializationCluster() {}
 
   void Trace(Serializer* s, RawObject* object) {
+    OS::Print("C");

[zra, 2017/05/31 17:10:31]

leftover debug print?

[rmacnak, 2017/05/31 19:53:01]

Removed.

     RawCode* code = Code::RawCast(object);
     objects_.Add(code);
 
     s->Push(code->ptr()->object_pool_);
     s->Push(code->ptr()->owner_);
     s->Push(code->ptr()->exception_handlers_);
     s->Push(code->ptr()->pc_descriptors_);
 #if defined(DART_PRECOMPILED_RUNTIME) || defined(DART_PRECOMPILER)
     s->Push(code->ptr()->catch_entry_.catch_entry_state_maps_);
 #else
     s->Push(code->ptr()->catch_entry_.variables_);
 #endif
     s->Push(code->ptr()->stackmaps_);
     if (!FLAG_dwarf_stack_traces) {
       s->Push(code->ptr()->inlined_id_to_function_);
       s->Push(code->ptr()->code_source_map_);
     }
-    if (s->kind() != Snapshot::kAppAOT) {
+    if (s->kind() != Snapshot::kFullAOT) {
       s->Push(code->ptr()->await_token_positions_);
     }
 
-    if (s->kind() == Snapshot::kAppJIT) {
+    if (s->kind() == Snapshot::kFullJIT) {
       s->Push(code->ptr()->deopt_info_array_);
       s->Push(code->ptr()->static_calls_target_table_);
       NOT_IN_PRODUCT(s->Push(code->ptr()->return_address_metadata_));
     }
   }
 
   void WriteAlloc(Serializer* s) {
     s->WriteCid(kCodeCid);
     intptr_t count = objects_.length();
     s->Write<int32_t>(count);
     for (intptr_t i = 0; i < count; i++) {
       RawCode* code = objects_[i];
       s->AssignRef(code);
     }
   }
 
   void WriteFill(Serializer* s) {
     Snapshot::Kind kind = s->kind();
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawCode* code = objects_[i];
 
       intptr_t pointer_offsets_length =
           Code::PtrOffBits::decode(code->ptr()->state_bits_);
       if (pointer_offsets_length != 0) {
         FATAL("Cannot serialize code with embedded pointers");
       }
-      if (kind == Snapshot::kAppAOT) {
+      if (kind == Snapshot::kFullAOT) {
         // No disabled code in precompilation.
         NOT_IN_PRECOMPILED(ASSERT(code->ptr()->instructions_ ==
                                   code->ptr()->active_instructions_));
       }
 
       RawInstructions* instr = code->ptr()->instructions_;
       int32_t text_offset = s->GetTextOffset(instr, code);
       s->Write<int32_t>(text_offset);
-      if (s->kind() == Snapshot::kAppJIT) {
+      if (s->kind() == Snapshot::kFullJIT) {
         // TODO(rmacnak): Fix references to disabled code before serializing.
         if (code->ptr()->active_instructions_ != code->ptr()->instructions_) {
           instr = code->ptr()->active_instructions_;
           text_offset = s->GetTextOffset(instr, code);
         }
         s->Write<int32_t>(text_offset);
       }
 
       s->WriteRef(code->ptr()->object_pool_);
       s->WriteRef(code->ptr()->owner_);
       s->WriteRef(code->ptr()->exception_handlers_);
       s->WriteRef(code->ptr()->pc_descriptors_);
 #if defined(DART_PRECOMPILED_RUNTIME) || defined(DART_PRECOMPILER)
       s->WriteRef(code->ptr()->catch_entry_.catch_entry_state_maps_);
 #else
       s->WriteRef(code->ptr()->catch_entry_.variables_);
 #endif
       s->WriteRef(code->ptr()->stackmaps_);
       if (FLAG_dwarf_stack_traces) {
         s->WriteRef(Array::null());
         s->WriteRef(CodeSourceMap::null());
       } else {
         s->WriteRef(code->ptr()->inlined_id_to_function_);
         s->WriteRef(code->ptr()->code_source_map_);
       }
-      if (s->kind() != Snapshot::kAppAOT) {
+      if (s->kind() != Snapshot::kFullAOT) {
         s->WriteRef(code->ptr()->await_token_positions_);
       }
-      if (s->kind() == Snapshot::kAppJIT) {
+      if (s->kind() == Snapshot::kFullJIT) {
         s->WriteRef(code->ptr()->deopt_info_array_);
         s->WriteRef(code->ptr()->static_calls_target_table_);
         NOT_IN_PRODUCT(s->WriteRef(code->ptr()->return_address_metadata_));
       }
 
       s->Write<int32_t>(code->ptr()->state_bits_);
     }
   }
 
  private:
@@ skipping 28 matching lines @@
       int32_t text_offset = d->Read<int32_t>();
       RawInstructions* instr = d->GetInstructionsAt(text_offset);
 
       code->ptr()->entry_point_ = Instructions::UncheckedEntryPoint(instr);
       code->ptr()->checked_entry_point_ =
           Instructions::CheckedEntryPoint(instr);
       NOT_IN_PRECOMPILED(code->ptr()->active_instructions_ = instr);
       code->ptr()->instructions_ = instr;
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
-      if (d->kind() == Snapshot::kAppJIT) {
+      if (d->kind() == Snapshot::kFullJIT) {
         int32_t text_offset = d->Read<int32_t>();
         RawInstructions* instr = d->GetInstructionsAt(text_offset);
         code->ptr()->active_instructions_ = instr;
         code->ptr()->entry_point_ = Instructions::UncheckedEntryPoint(instr);
         code->ptr()->checked_entry_point_ =
             Instructions::CheckedEntryPoint(instr);
       }
 #endif  // !DART_PRECOMPILED_RUNTIME
 
       code->ptr()->object_pool_ =
@@ skipping 13 matching lines @@
       code->ptr()->stackmaps_ = reinterpret_cast<RawArray*>(d->ReadRef());
       code->ptr()->inlined_id_to_function_ =
           reinterpret_cast<RawArray*>(d->ReadRef());
       code->ptr()->code_source_map_ =
           reinterpret_cast<RawCodeSourceMap*>(d->ReadRef());
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
       code->ptr()->await_token_positions_ =
           reinterpret_cast<RawArray*>(d->ReadRef());
 
-      if (d->kind() == Snapshot::kAppJIT) {
+      if (d->kind() == Snapshot::kFullJIT) {
         code->ptr()->deopt_info_array_ =
             reinterpret_cast<RawArray*>(d->ReadRef());
         code->ptr()->static_calls_target_table_ =
             reinterpret_cast<RawArray*>(d->ReadRef());
 #if defined(PRODUCT)
         code->ptr()->return_address_metadata_ = Object::null();
 #else
         code->ptr()->return_address_metadata_ = d->ReadRef();
 #endif
       } else {
@@ skipping 605 matching lines @@
   void WriteFill(Serializer* s) {
     Snapshot::Kind kind = s->kind();
     intptr_t count = objects_.length();
     for (intptr_t i = 0; i < count; i++) {
       RawICData* ic = objects_[i];
       RawObject** from = ic->from();
       RawObject** to = ic->to_snapshot(kind);
       for (RawObject** p = from; p <= to; p++) {
         s->WriteRef(*p);
       }
-      if (kind != Snapshot::kAppAOT) {
+      if (kind != Snapshot::kFullAOT) {
         NOT_IN_PRECOMPILED(s->Write<int32_t>(ic->ptr()->deopt_id_));
       }
       s->Write<uint32_t>(ic->ptr()->state_bits_);
 #if defined(TAG_IC_DATA)
       s->Write<int32_t>(ic->ptr()->tag_);
 #endif
     }
   }
 
  private:
@@ skipping 2285 matching lines @@
       if (Snapshot::IncludesCode(kind_)) {
         return new (Z) RODataSerializationCluster(kTwoByteStringCid);
       } else {
         return new (Z) TwoByteStringSerializationCluster();
       }
     }
     default:
       break;
   }
 
-  FATAL1("No cluster defined for cid %" Pd, cid);
+  FATAL2("No cluster defined for cid %" Pd ", kind %s", cid,
+         Snapshot::KindToCString(kind_));
   return NULL;
 #endif  // !DART_PRECOMPILED_RUNTIME
 }
 
 
 void Serializer::Push(RawObject* object) {
   if (!object->IsHeapObject()) {
     RawSmi* smi = Smi::RawCast(object);
     if (smi_ids_.Lookup(smi) == NULL) {
       SmiObjectIdPair pair;
@@ skipping 770 matching lines @@
   isolate()->ValidateClassTable();
 #endif
   // Can't have any mutation happening while we're serializing.
   ASSERT(isolate()->background_compiler() == NULL);
 
   // TODO(rmacnak): The special case for AOT causes us to always generate the
   // same VM isolate snapshot for every app. AOT snapshots should be cleaned up
   // so the VM isolate snapshot is generated separately and each app is
   // generated from a VM that has loaded this snapshots, much like app-jit
   // snapshots.
-  if ((vm_snapshot_data_buffer != NULL) && (kind != Snapshot::kAppAOT)) {
+  if ((vm_snapshot_data_buffer != NULL) && (kind != Snapshot::kFullAOT)) {
     NOT_IN_PRODUCT(TimelineDurationScope tds(
         thread(), Timeline::GetIsolateStream(), "PrepareNewVMIsolate"));
 
     // Collect all the token stream objects into an array so that we can write
     // it out as part of the VM isolate snapshot. We first count the number of
     // token streams, allocate an array and then fill it up with the token
     // streams.
     SnapshotTokenStreamVisitor token_streams_counter(thread());
     heap()->IterateOldObjects(&token_streams_counter);
     Dart::vm_isolate()->heap()->IterateOldObjects(&token_streams_counter);
@@ skipping 128 matching lines @@
 
 FullSnapshotReader::FullSnapshotReader(const Snapshot* snapshot,
                                        const uint8_t* instructions_buffer,
                                        Thread* thread)
     : kind_(snapshot->kind()),
       thread_(thread),
       buffer_(snapshot->content()),
       size_(snapshot->length()),
       instructions_buffer_(instructions_buffer),
       data_buffer_(DataBuffer(snapshot)) {
-  thread->isolate()->set_compilation_allowed(kind_ != Snapshot::kAppAOT);
+  thread->isolate()->set_compilation_allowed(kind_ != Snapshot::kFullAOT);
 }
 
 
 RawApiError* FullSnapshotReader::ReadVMSnapshot() {
   Deserializer deserializer(thread_, kind_, buffer_, size_,
                             instructions_buffer_, data_buffer_);
 
   RawApiError* error = deserializer.VerifyVersionAndFeatures(/*isolate=*/NULL);
   if (error != ApiError::null()) {
     return error;
@@ skipping 32 matching lines @@
     thread_->isolate()->SetupImagePage(data_buffer_,
                                        /* is_executable */ false);
   }
 
   deserializer.ReadIsolateSnapshot(thread_->isolate()->object_store());
 
   return ApiError::null();
 }
 
 }  // namespace dart