Encode inlining information in CodeSourceMap and remove inlining interval arrays.

runtime/vm/flow_graph_compiler.h

 // 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.
 
 #ifndef RUNTIME_VM_FLOW_GRAPH_COMPILER_H_
 #define RUNTIME_VM_FLOW_GRAPH_COMPILER_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/code_descriptors.h"
 #include "vm/code_generator.h"
 #include "vm/intermediate_language.h"
 
 namespace dart {
 
 // Forward declarations.
 class Code;
 class DeoptInfoBuilder;
 class FlowGraph;
 class FlowGraphCompiler;
 class Function;
 template <typename T>
 class GrowableArray;
 class ParsedFunction;
 
-
 class ParallelMoveResolver : public ValueObject {
  public:
   explicit ParallelMoveResolver(FlowGraphCompiler* compiler);
 
   // Resolve a set of parallel moves, emitting assembler instructions.
   void EmitNativeCode(ParallelMoveInstr* parallel_move);
 
  private:
   class ScratchFpuRegisterScope : public ValueObject {
    public:
@@ skipping 482 matching lines @@
   CompilerDeoptInfo* AddDeoptIndexAtCall(intptr_t deopt_id);
 
   void AddSlowPathCode(SlowPathCode* slow_path);
 
   void FinalizeExceptionHandlers(const Code& code);
   void FinalizePcDescriptors(const Code& code);
   RawArray* CreateDeoptInfo(Assembler* assembler);
   void FinalizeStackMaps(const Code& code);
   void FinalizeVarDescriptors(const Code& code);
   void FinalizeStaticCallTargetsTable(const Code& code);
+  void FinalizeCodeSourceMap(const Code& code);
 
   const Class& double_class() const { return double_class_; }
   const Class& mint_class() const { return mint_class_; }
   const Class& float32x4_class() const { return float32x4_class_; }
   const Class& float64x2_class() const { return float64x2_class_; }
   const Class& int32x4_class() const { return int32x4_class_; }
 
   const Class& BoxClassFor(Representation rep);
 
   void SaveLiveRegisters(LocationSummary* locs);
@@ skipping 32 matching lines @@
   const ZoneGrowableArray<const ICData*>& deopt_id_to_ic_data() const {
     return *deopt_id_to_ic_data_;
   }
 
   Thread* thread() const { return thread_; }
   Isolate* isolate() const { return thread_->isolate(); }
   Zone* zone() const { return zone_; }
 
   void AddStubCallTarget(const Code& code);
 
-  const Array& inlined_code_intervals() const {
-    return inlined_code_intervals_;
-  }
-
   RawArray* edge_counters_array() const { return edge_counters_array_.raw(); }
 
   RawArray* InliningIdToFunction() const;
-  RawArray* InliningIdToTokenPos() const;
-  RawArray* CallerInliningIdMap() const;
-
-  CodeSourceMapBuilder* code_source_map_builder() {
-    if (code_source_map_builder_ == NULL) {
-      code_source_map_builder_ = new CodeSourceMapBuilder();
-    }
-    ASSERT(code_source_map_builder_ != NULL);
-    return code_source_map_builder_;
-  }
 
   void BeginCodeSourceRange();
-  bool EndCodeSourceRange(TokenPosition token_pos);
+  void EndCodeSourceRange(TokenPosition token_pos);
 
 #if defined(TARGET_ARCH_DBC)
   enum CallResult {
     kHasResult,
     kNoResult,
   };
   void RecordAfterCallHelper(TokenPosition token_pos,
                              intptr_t deopt_id,
                              intptr_t argument_count,
                              CallResult result,
@@ skipping 158 matching lines @@
 #endif
 
   // Compiler specific per-block state.  Indexed by postorder block number
   // for convenience.  This is not the block's index in the block order,
   // which is reverse postorder.
   BlockEntryInstr* current_block_;
   ExceptionHandlerList* exception_handlers_list_;
   DescriptorList* pc_descriptors_list_;
   StackMapTableBuilder* stackmap_table_builder_;
   CodeSourceMapBuilder* code_source_map_builder_;
-  intptr_t saved_code_size_;
   GrowableArray<BlockInfo*> block_info_;
   GrowableArray<CompilerDeoptInfo*> deopt_infos_;
   GrowableArray<SlowPathCode*> slow_path_code_;
   // Stores static call targets as well as stub targets.
   // TODO(srdjan): Evaluate if we should store allocation stub targets into a
   // separate table?
   GrowableArray<StaticCallsStruct*> static_calls_target_table_;
   const bool is_optimizing_;
   // Set to true if optimized code has IC calls.
   bool may_reoptimize_;
@@ skipping 13 matching lines @@
   // Currently instructions generate deopt stubs internally by
   // calling AddDeoptStub.  To communicate deoptimization environment
   // that should be used when deoptimizing we store it in this variable.
   // In future AddDeoptStub should be moved out of the instruction template.
   Environment* pending_deoptimization_env_;
 
   ZoneGrowableArray<const ICData*>* deopt_id_to_ic_data_;
 
   Array& edge_counters_array_;
 
-  Array& inlined_code_intervals_;
-  const GrowableArray<const Function*>& inline_id_to_function_;
-  const GrowableArray<TokenPosition>& inline_id_to_token_pos_;
-  const GrowableArray<intptr_t>& caller_inline_id_;
-
   DISALLOW_COPY_AND_ASSIGN(FlowGraphCompiler);
 };
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_FLOW_GRAPH_COMPILER_H_