Include metadata in AOT to expand inline frames in stack traces and provide line numbers.

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
@@ skipping 477 matching lines @@
       I->object_store()->set_compiletime_error_class(null_class);
     }
     DropClasses();
     DropLibraries();
 
     BindStaticCalls();
     SwitchICCalls();
 
     ShareMegamorphicBuckets();
     DedupStackMaps();
+    DedupCodeSourceMaps();
     DedupLists();
 
     if (FLAG_dedup_instructions) {
       // Reduces binary size but obfuscates profiler results.
       DedupInstructions();
     }
 
     zone_ = NULL;
   }
 
@@ skipping 469 matching lines @@
         target_code ^= entry.raw();
         if (target_code.IsAllocationStubCode()) {
           cls ^= target_code.owner();
           AddInstantiatedClass(cls);
         }
       } else if (entry.IsTypeArguments()) {
         AddTypeArguments(TypeArguments::Cast(entry));
       }
     }
   }
+
+  const Array& inlined_functions =
+      Array::Handle(Z, code.inlined_id_to_function());
+  for (intptr_t i = 0; i < inlined_functions.Length(); i++) {
+    target ^= inlined_functions.At(i);
+    AddTypesOf(target);
+  }
 }
 
 
 void Precompiler::AddTypesOf(const Class& cls) {
   if (cls.IsNull()) return;
   if (classes_to_retain_.Lookup(&cls) != NULL) return;
   classes_to_retain_.Insert(&Class::ZoneHandle(Z, cls.raw()));
 
   Array& interfaces = Array::Handle(Z, cls.interfaces());
   AbstractType& type = AbstractType::Handle(Z);
@@ skipping 1337 matching lines @@
     Code& code_;
     Array& stackmaps_;
     StackMap& stackmap_;
   };
 
   DedupStackMapsVisitor visitor(Z);
   ProgramVisitor::VisitFunctions(&visitor);
 }
 
 
+void Precompiler::DedupCodeSourceMaps() {
+  class DedupCodeSourceMapsVisitor : public FunctionVisitor {
+   public:
+    explicit DedupCodeSourceMapsVisitor(Zone* zone)
+        : zone_(zone),
+          canonical_code_source_maps_(),
+          code_(Code::Handle(zone)),
+          code_source_map_(CodeSourceMap::Handle(zone)) {}
+
+    void Visit(const Function& function) {
+      if (!function.HasCode()) {
+        return;
+      }
+      code_ = function.CurrentCode();
+      code_source_map_ = code_.code_source_map();
+      ASSERT(!code_source_map_.IsNull());
+      code_source_map_ = DedupCodeSourceMap(code_source_map_);
+      code_.set_code_source_map(code_source_map_);
+    }
+
+    RawCodeSourceMap* DedupCodeSourceMap(const CodeSourceMap& code_source_map) {
+      const CodeSourceMap* canonical_code_source_map =
+          canonical_code_source_maps_.LookupValue(&code_source_map);
+      if (canonical_code_source_map == NULL) {
+        canonical_code_source_maps_.Insert(
+            &CodeSourceMap::ZoneHandle(zone_, code_source_map.raw()));
+        return code_source_map.raw();
+      } else {
+        return canonical_code_source_map->raw();
+      }
+    }
+
+   private:
+    Zone* zone_;
+    CodeSourceMapSet canonical_code_source_maps_;
+    Code& code_;
+    CodeSourceMap& code_source_map_;
+  };
+
+  DedupCodeSourceMapsVisitor visitor(Z);
+  ProgramVisitor::VisitFunctions(&visitor);
+}
+
+
 void Precompiler::DedupLists() {
   class DedupListsVisitor : public FunctionVisitor {
    public:
     explicit DedupListsVisitor(Zone* zone)
         : zone_(zone),
           canonical_lists_(),
           code_(Code::Handle(zone)),
           list_(Array::Handle(zone)) {}
 
     void Visit(const Function& function) {
       code_ = function.CurrentCode();
       if (!code_.IsNull()) {
         list_ = code_.stackmaps();
         if (!list_.IsNull()) {
           list_ = DedupList(list_);
           code_.set_stackmaps(list_);
         }
+        list_ = code_.inlined_id_to_function();
+        if (!list_.IsNull()) {
+          list_ = DedupList(list_);
+          code_.set_inlined_id_to_function(list_);
+        }
       }
 
       list_ = function.parameter_types();
       if (!list_.IsNull()) {
         if (!function.IsSignatureFunction() && !function.IsClosureFunction() &&
             (function.name() != Symbols::Call().raw()) && !list_.InVMHeap()) {
           // Parameter types not needed for function type tests.
           for (intptr_t i = 0; i < list_.Length(); i++) {
             list_.SetAt(i, Object::dynamic_type());
           }
@@ skipping 1377 matching lines @@
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   DartPrecompilationPipeline pipeline(zone, field_type_map);
   return PrecompileFunctionHelper(precompiler, &pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart