Fix inlining information:

runtime/vm/compiler.cc

 // 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.
 
 #include "vm/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 726 matching lines @@
         INC_STAT(isolate, total_code_size,
                  intervals.Length() * sizeof(uword));
         code.SetInlinedIntervals(intervals);
 
         const Array& inlined_id_array =
             Array::Handle(isolate, graph_compiler.InliningIdToFunction());
         INC_STAT(isolate, total_code_size,
                  inlined_id_array.Length() * sizeof(uword));
         code.SetInlinedIdToFunction(inlined_id_array);
 
+        const Array& caller_inlining_id_map_array =
+            Array::Handle(isolate, graph_compiler.CallerInliningIdMap());
+        INC_STAT(isolate, total_code_size,
+                 caller_inlining_id_map_array.Length() * sizeof(uword));
+        code.SetInlinedCallerIdMap(caller_inlining_id_map_array);
+
         graph_compiler.FinalizePcDescriptors(code);
         code.set_deopt_info_array(deopt_info_array);
 
         graph_compiler.FinalizeStackmaps(code);
         graph_compiler.FinalizeVarDescriptors(code);
         graph_compiler.FinalizeExceptionHandlers(code);
         graph_compiler.FinalizeStaticCallTargetsTable(code);
 
         if (optimized) {
           // We may not have previous code if 'always_optimize' is set.
@@ skipping 207 matching lines @@
       }
     }
     ISL_Print("}\n");
   }
   if (optimized && FLAG_trace_inlining_intervals) {
     code.DumpInlinedIntervals();
   }
 }
 
 
+#if defined(DEBUG)
+// Verifies that the inliner is always in the list of inlined functions.
+// If this fails run with --trace-inlining-intervals to get more information.
+static void CheckInliningIntervals(const Function& function) {
+  const Code& code = Code::Handle(function.CurrentCode());
+  const Array& intervals = Array::Handle(code.GetInlinedIntervals());
+  if (intervals.IsNull() || (intervals.Length() == 0)) return;
+  Smi& start = Smi::Handle();
+  GrowableArray<Function*> inlined_functions;
+  for (intptr_t i = 0; i < intervals.Length(); i += Code::kInlIntNumEntries) {
+    start ^= intervals.At(i + Code::kInlIntStart);
+    ASSERT(!start.IsNull());
+    if (start.IsNull()) continue;
+    code.GetInlinedFunctionsAt(start.Value(), &inlined_functions);
+    ASSERT(inlined_functions[inlined_functions.length() - 1]->raw() ==
+           function.raw());
+  }
+}
+#endif
+
+
 static RawError* CompileFunctionHelper(CompilationPipeline* pipeline,
                                        const Function& function,
                                        bool optimized,
                                        intptr_t osr_id) {
   // Check that we optimize if 'Compiler::always_optimize()' is set to true,
   // except if the function is marked as not optimizable.
   ASSERT(!function.IsOptimizable() ||
          !Compiler::always_optimize() || optimized);
   ASSERT(Compiler::allow_recompilation() || !function.HasCode());
   LongJumpScope jump;
@@ skipping 68 matching lines @@
     if (FLAG_disassemble && FlowGraphPrinter::ShouldPrint(function)) {
       DisassembleCode(function, optimized);
     } else if (FLAG_disassemble_optimized &&
                optimized &&
                FlowGraphPrinter::ShouldPrint(function)) {
       // TODO(fschneider): Print unoptimized code along with the optimized code.
       ISL_Print("*** BEGIN CODE\n");
       DisassembleCode(function, true);
       ISL_Print("*** END CODE\n");
     }
+#if defined(DEBUG)
+    CheckInliningIntervals(function);
+#endif
     return Error::null();
   } else {
     Thread* const thread = Thread::Current();
     Isolate* const isolate = thread->isolate();
     StackZone stack_zone(isolate);
     Error& error = Error::Handle();
     // We got an error during compilation.
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     return error.raw();
@@ skipping 270 matching lines @@
     const Object& result =
       PassiveObject::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart