Shrink AOT snapshot size and memory usage.

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 502 matching lines @@
     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::kAppNoJIT) {
       s->Push(func->ptr()->code_);
     } else if (s->kind() == Snapshot::kAppWithJIT) {
-      s->Push(func->ptr()->unoptimized_code_);
+      NOT_IN_PRECOMPILED(s->Push(func->ptr()->unoptimized_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::kAppNoJIT) {
         s->WriteRef(func->ptr()->code_);
       } else if (s->kind() == Snapshot::kAppWithJIT) {
-        s->WriteRef(func->ptr()->unoptimized_code_);
+        NOT_IN_PRECOMPILED(s->WriteRef(func->ptr()->unoptimized_code_));
         s->WriteRef(func->ptr()->ic_data_array_);
       }
 
-      s->WriteTokenPosition(func->ptr()->token_pos_);
-      s->WriteTokenPosition(func->ptr()->end_token_pos_);
+#if !defined(DART_PRECOMPILED_RUNTIME)
+      if (kind != Snapshot::kAppNoJIT) {
+        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::kAppNoJIT) {
         // Omit fields used to support de/reoptimization.
       } else {
+#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);
         }
         s->Write<int8_t>(func->ptr()->deoptimization_counter_);
         s->Write<uint16_t>(func->ptr()->optimized_instruction_count_);
         s->Write<uint16_t>(func->ptr()->optimized_call_site_count_);
+#endif
       }
     }
   }
 
  private:
   GrowableArray<RawFunction*> objects_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
 
@@ skipping 26 matching lines @@
       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::kAppNoJIT) {
         func->ptr()->code_ = reinterpret_cast<RawCode*>(d->ReadRef());
       } else if (kind == Snapshot::kAppWithJIT) {
-        func->ptr()->unoptimized_code_ =
-            reinterpret_cast<RawCode*>(d->ReadRef());
+        NOT_IN_PRECOMPILED(func->ptr()->unoptimized_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
 
-      func->ptr()->token_pos_ = d->ReadTokenPosition();
-      func->ptr()->end_token_pos_ = d->ReadTokenPosition();
+#if !defined(DART_PRECOMPILED_RUNTIME)
+      if (kind != Snapshot::kAppNoJIT) {
+        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::kAppNoJIT) {
         // Omit fields used to support de/reoptimization.
       } else {
+#if !defined(DART_PRECOMPILED_RUNTIME)
         func->ptr()->usage_counter_ = d->Read<int32_t>();
         func->ptr()->deoptimization_counter_ = d->Read<int8_t>();
         func->ptr()->optimized_instruction_count_ = d->Read<uint16_t>();
         func->ptr()->optimized_call_site_count_ = d->Read<uint16_t>();
+#endif
       }
     }
   }
 
   void PostLoad(const Array& refs, Snapshot::Kind kind, Zone* zone) {
     NOT_IN_PRODUCT(TimelineDurationScope tds(Thread::Current(),
         Timeline::GetIsolateStream(), "PostLoadFunction"));
 
     if (kind == Snapshot::kAppNoJIT) {
       Function& func = Function::Handle(zone);
@@ skipping 34 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);
 
-    RawObject** from = data->from();
-    RawObject** to = data->to();
-    for (RawObject** p = from; p <= to; p++) {
-      s->Push(*p);
+    if (s->kind() != Snapshot::kAppNoJIT) {
+      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];
-      RawObject** from = data->from();
-      RawObject** to = data->to();
-      for (RawObject** p = from; p <= to; p++) {
-        s->WriteRef(*p);
+      if (s->kind() != Snapshot::kAppNoJIT) {
+        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_;
 };
 #endif  // !DART_PRECOMPILED_RUNTIME
 
 
 class ClosureDataDeserializationCluster : public DeserializationCluster {
@@ skipping 11 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);
-      RawObject** from = data->from();
-      RawObject** to = data->to();
-      for (RawObject** p = from; p <= to; p++) {
-        *p = d->ReadRef();
+                                     ClosureData::InstanceSize(),
+                                     is_vm_object);
+      if (d->kind() == Snapshot::kAppNoJIT) {
+        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());
     }
   }
 };
 
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class RedirectionDataSerializationCluster : public SerializationCluster {
  public:
   RedirectionDataSerializationCluster() { }
   virtual ~RedirectionDataSerializationCluster() { }
@@ skipping 716 matching lines @@
     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::kAppNoJIT) {
         // No disabled code in precompilation.
-        ASSERT(code->ptr()->instructions_ == code->ptr()->active_instructions_);
+        NOT_IN_PRECOMPILED(ASSERT(
+            code->ptr()->instructions_ == code->ptr()->active_instructions_));
       } else {
         ASSERT(kind == Snapshot::kAppWithJIT);
         // We never include optimized code in JIT precompilation. Deoptimization
         // requires code patching and we cannot patch code that is shared
         // between isolates and should not mutate memory allocated by the
         // embedder.
         bool is_optimized = Code::PtrOffBits::decode(code->ptr()->state_bits_);
         if (is_optimized) {
           FATAL("Cannot include optimized code in a JIT snapshot");
         }
@@ skipping 42 matching lines @@
       Deserializer::InitializeHeader(code, kCodeCid,
                                      Code::InstanceSize(0), is_vm_object);
 
       int32_t text_offset = d->Read<int32_t>();
       RawInstructions* instr = reinterpret_cast<RawInstructions*>(
           d->GetInstructionsAt(text_offset) + kHeapObjectTag);
 
       code->ptr()->entry_point_ = Instructions::UncheckedEntryPoint(instr);
       code->ptr()->checked_entry_point_ =
           Instructions::CheckedEntryPoint(instr);
-      code->ptr()->active_instructions_ = instr;
+      NOT_IN_PRECOMPILED(code->ptr()->active_instructions_ = instr);
       code->ptr()->instructions_ = instr;
       code->ptr()->object_pool_ =
           reinterpret_cast<RawObjectPool*>(d->ReadRef());
       code->ptr()->owner_ = d->ReadRef();
       code->ptr()->exception_handlers_ =
           reinterpret_cast<RawExceptionHandlers*>(d->ReadRef());
       code->ptr()->pc_descriptors_ =
           reinterpret_cast<RawPcDescriptors*>(d->ReadRef());
       code->ptr()->stackmaps_ =
           reinterpret_cast<RawArray*>(d->ReadRef());
 
+#if !defined(DART_PRECOMPILED_RUNTIME)
       code->ptr()->deopt_info_array_ = Array::null();
       code->ptr()->static_calls_target_table_ = Array::null();
       code->ptr()->var_descriptors_ = LocalVarDescriptors::null();
       code->ptr()->inlined_metadata_ = Array::null();
       code->ptr()->code_source_map_ = CodeSourceMap::null();
       code->ptr()->comments_ = Array::null();
       code->ptr()->return_address_metadata_ = Object::null();
 
       code->ptr()->compile_timestamp_ = 0;
+#endif
       code->ptr()->state_bits_ = d->Read<int32_t>();
+#if !defined(DART_PRECOMPILED_RUNTIME)
       code->ptr()->lazy_deopt_pc_offset_ = -1;
+#endif
     }
   }
 };
 
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 class ObjectPoolSerializationCluster : public SerializationCluster {
  public:
   ObjectPoolSerializationCluster() { }
   virtual ~ObjectPoolSerializationCluster() { }
@@ skipping 505 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);
       }
-      s->Write<int32_t>(ic->ptr()->deopt_id_);
+      if (kind != Snapshot::kAppNoJIT) {
+        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:
   GrowableArray<RawICData*> objects_;
 };
@@ skipping 25 matching lines @@
                                      ICData::InstanceSize(), is_vm_object);
       RawObject** from = ic->from();
       RawObject** to_snapshot = ic->to_snapshot(kind);
       RawObject** to = ic->to();
       for (RawObject** p = from; p <= to_snapshot; p++) {
         *p = d->ReadRef();
       }
       for (RawObject** p = to_snapshot + 1; p <= to; p++) {
         *p = Object::null();
       }
-      ic->ptr()->deopt_id_ = d->Read<int32_t>();
+      NOT_IN_PRECOMPILED(ic->ptr()->deopt_id_ = d->Read<int32_t>());
       ic->ptr()->state_bits_ = d->Read<int32_t>();
 #if defined(TAG_IC_DATA)
       ic->ptr()->tag_ = d->Read<int32_t>();
 #endif
     }
   }
 };
 
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
@@ skipping 2933 matching lines @@
 
   deserializer.ReadVMSnapshot();
 
   Dart::set_instructions_snapshot_buffer(instructions_buffer_);
   Dart::set_data_snapshot_buffer(data_buffer_);
 
   return ApiError::null();
 }
 
 }  // namespace dart