Encode inlining information in CodeSourceMap and remove inlining interval arrays.

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 531 matching lines @@
   const Code& code =
       Code::Handle(Code::FinalizeCode(function, assembler, optimized()));
   code.set_is_optimized(optimized());
   code.set_owner(function);
   if (!function.IsOptimizable()) {
     // A function with huge unoptimized code can become non-optimizable
     // after generating unoptimized code.
     function.set_usage_counter(INT_MIN);
   }
 
-  const Array& intervals = graph_compiler->inlined_code_intervals();
-  INC_STAT(thread(), total_code_size, intervals.Length() * sizeof(uword));
-  code.SetInlinedIntervals(intervals);
-
-  const Array& inlined_id_array =
-      Array::Handle(zone, graph_compiler->InliningIdToFunction());
-  INC_STAT(thread(), total_code_size,
-           inlined_id_array.Length() * sizeof(uword));
-  code.SetInlinedIdToFunction(inlined_id_array);
-
-  const Array& caller_inlining_id_map_array =
-      Array::Handle(zone, graph_compiler->CallerInliningIdMap());
-  INC_STAT(thread(), total_code_size,
-           caller_inlining_id_map_array.Length() * sizeof(uword));
-  code.SetInlinedCallerIdMap(caller_inlining_id_map_array);
-
-  const Array& inlined_id_to_token_pos =
-      Array::Handle(zone, graph_compiler->InliningIdToTokenPos());
-  INC_STAT(thread(), total_code_size,
-           inlined_id_to_token_pos.Length() * sizeof(uword));
-  code.SetInlinedIdToTokenPos(inlined_id_to_token_pos);
-
   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 !defined(PRODUCT)
-  // Set the code source map after setting the inlined information because
-  // we use the inlined information when printing.
-  const CodeSourceMap& code_source_map = CodeSourceMap::Handle(
-      zone, graph_compiler->code_source_map_builder()->Finalize());
-  code.set_code_source_map(code_source_map);
-  if (FLAG_print_code_source_map) {
-    CodeSourceMap::Dump(code_source_map, code, function);
-  }
-#endif  // !defined(PRODUCT)
+  graph_compiler->FinalizeCodeSourceMap(code);
 
   if (optimized()) {
     bool code_was_installed = false;
     // Installs code while at safepoint.
     if (thread()->IsMutatorThread()) {
       const bool is_osr = osr_id() != Compiler::kNoOSRDeoptId;
       function.InstallOptimizedCode(code, is_osr);
       code_was_installed = true;
     } else {
       // Background compilation.
@@ skipping 594 matching lines @@
       }
       is_compiled = false;
     }
     // Reset global isolate state.
     thread()->set_deopt_id(prev_deopt_id);
   }
   return is_compiled;
 }
 
 
-#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  // defined(DEBUG)
-
 static RawError* CompileFunctionHelper(CompilationPipeline* pipeline,
                                        const Function& function,
                                        bool optimized,
                                        intptr_t osr_id) {
   ASSERT(!FLAG_precompiled_mode);
   ASSERT(!optimized || function.was_compiled());
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* const thread = Thread::Current();
     Isolate* const isolate = thread->isolate();
@@ skipping 118 matching lines @@
       isolate->debugger()->NotifyCompilation(function);
     }
 
     if (FLAG_disassemble && FlowGraphPrinter::ShouldPrint(function)) {
       Disassembler::DisassembleCode(function, optimized);
     } else if (FLAG_disassemble_optimized && optimized &&
                FlowGraphPrinter::ShouldPrint(function)) {
       Disassembler::DisassembleCode(function, true);
     }
 
-    DEBUG_ONLY(CheckInliningIntervals(function));
     return Error::null();
   } else {
     Thread* const thread = Thread::Current();
     StackZone stack_zone(thread);
     Error& error = Error::Handle();
     // We got an error during compilation or it is a bailout from background
     // compilation (e.g., during parsing with EnsureIsFinalized).
     error = thread->sticky_error();
     thread->clear_sticky_error();
     if (error.raw() == Object::background_compilation_error().raw()) {
@@ skipping 943 matching lines @@
 
 
 bool BackgroundCompiler::IsDisabled() {
   UNREACHABLE();
   return true;
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart