Encode inlining information in CodeSourceMap and remove inlining interval arrays.

runtime/vm/object.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_OBJECT_H_
 #define RUNTIME_VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 4383 matching lines @@
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawCodeSourceMap) ==
            OFFSET_OF_RETURNED_VALUE(RawCodeSourceMap, data));
     return 0;
   }
   static intptr_t InstanceSize(intptr_t len) {
     ASSERT(0 <= len && len <= kMaxElements);
     return RoundedAllocationSize(sizeof(RawCodeSourceMap) + len);
   }
 
-  static RawCodeSourceMap* New(GrowableArray<uint8_t>* delta_encoded_data);
+  static RawCodeSourceMap* New(intptr_t length);
+
+  intptr_t Length() const { return raw_ptr()->length_; }
+  uint8_t* Data() const {
+    return UnsafeMutableNonPointer(&raw_ptr()->data()[0]);
+  }
 
   void PrintToJSONObject(JSONObject* jsobj, bool ref) const;
 
-  // Encode integer in SLEB128 format.
-  static void EncodeInteger(GrowableArray<uint8_t>* data, intptr_t value);
-
-  // Decode SLEB128 encoded integer. Update byte_index to the next integer.
-  intptr_t DecodeInteger(intptr_t* byte_index) const;
-
-  TokenPosition TokenPositionForPCOffset(uword pc_offset) const;
-  RawFunction* FunctionForPCOffset(const Code& code,
-                                   const Function& function,
-                                   uword pc_offset) const;
-  RawScript* ScriptForPCOffset(const Code& code,
-                               const Function& function,
-                               uword pc_offset) const;
-
-  static void Dump(const CodeSourceMap& code_source_map,
-                   const Code& code,
-                   const Function& function);
-
-  class Iterator : ValueObject {
-   public:
-    explicit Iterator(const CodeSourceMap& code_source_map)
-        : code_source_map_(code_source_map),
-          byte_index_(0),
-          cur_pc_offset_(0),
-          cur_token_pos_(0) {}
-
-    bool MoveNext() {
-      // Moves to the next record.
-      while (byte_index_ < code_source_map_.Length()) {
-        cur_pc_offset_ += code_source_map_.DecodeInteger(&byte_index_);
-        cur_token_pos_ += code_source_map_.DecodeInteger(&byte_index_);
-
-        return true;
-      }
-      return false;
-    }
-
-    uword PcOffset() const { return cur_pc_offset_; }
-    TokenPosition TokenPos() const { return TokenPosition(cur_token_pos_); }
-
-   private:
-    friend class CodeSourceMap;
-
-    const CodeSourceMap& code_source_map_;
-    intptr_t byte_index_;
-
-    intptr_t cur_pc_offset_;
-    intptr_t cur_token_pos_;
-  };
-
  private:
-  static RawCodeSourceMap* New(intptr_t length);
-
-  intptr_t Length() const;
   void SetLength(intptr_t value) const;
-  void CopyData(GrowableArray<uint8_t>* data);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(CodeSourceMap, Object);
   friend class Class;
   friend class Object;
 };
 
 
 class StackMap : public Object {
  public:
   static const intptr_t kNoMaximum = -1;
@@ skipping 249 matching lines @@
 #else
     ASSERT(code_source_map.IsOld());
     StorePointer(&raw_ptr()->code_source_map_, code_source_map.raw());
 #endif
   }
 
   // Used during reloading (see object_reload.cc). Calls Reset on all ICDatas
   // that are embedded inside the Code object.
   void ResetICDatas(Zone* zone) const;
 
-  TokenPosition GetTokenPositionAt(intptr_t offset) const;
-
   // Array of DeoptInfo objects.
   RawArray* deopt_info_array() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
     UNREACHABLE();
     return NULL;
 #else
     return raw_ptr()->deopt_info_array_;
 #endif
   }
   void set_deopt_info_array(const Array& array) const;
@@ skipping 74 matching lines @@
     return NULL;
 #else
     return raw_ptr()->return_address_metadata_;
 #endif
   }
   // Sets |return_address_metadata|.
   void SetPrologueOffset(intptr_t offset) const;
   // Returns -1 if no prologue offset is available.
   intptr_t GetPrologueOffset() const;
 
-  enum InlinedIntervalEntries {
-    kInlIntStart = 0,
-    kInlIntInliningId = 1,
-    kInlIntNumEntries = 2,
-  };
+  RawArray* inlined_id_to_function() const;
+  void set_inlined_id_to_function(const Array& value) const;
 
-  RawArray* GetInlinedIntervals() const;
-  void SetInlinedIntervals(const Array& value) const;
+  // Provides the call stack at the given pc offset, with the top-of-stack in
+  // the last element and the root function (this) as the first element, along
+  // with the corresponding source positions. Note the token position for each
+  // function except the top-of-stack is the position of the call to the next
+  // function. The stack will be empty if we lack the metadata to produce it,
+  // which happens for stub code.
+  void GetInlinedFunctionsAt(
+      intptr_t pc_offset,
+      GrowableArray<const Function*>* functions,
+      GrowableArray<TokenPosition>* token_positions) const;
 
-  RawArray* GetInlinedIdToFunction() const;
-  void SetInlinedIdToFunction(const Array& value) const;
-
-  RawArray* GetInlinedIdToTokenPos() const;
-  void SetInlinedIdToTokenPos(const Array& value) const;
-
-  RawArray* GetInlinedCallerIdMap() const;
-  void SetInlinedCallerIdMap(const Array& value) const;
-
-  // If |token_positions| is not NULL it will be populated with the token
-  // positions of the inlined calls.
-  void GetInlinedFunctionsAt(
-      intptr_t offset,
-      GrowableArray<Function*>* fs,
-      GrowableArray<TokenPosition>* token_positions = NULL) const;
-
-  void DumpInlinedIntervals() const;
+  NOT_IN_PRODUCT(void PrintJSONInlineIntervals(JSONObject* object) const);
+  void DumpInlineIntervals() const;
+  void DumpSourcePositions() const;
 
   RawLocalVarDescriptors* var_descriptors() const {
 #if defined(DART_PRECOMPILED_RUNTIME)
     UNREACHABLE();
     return NULL;
 #else
     return raw_ptr()->var_descriptors_;
 #endif
   }
   void set_var_descriptors(const LocalVarDescriptors& value) const {
@@ skipping 164 matching lines @@
     ASSERT(index >= 0);
     ASSERT(index < pointer_offsets_length());
     // TODO(iposva): Unit test is missing for this functionality.
     return &UnsafeMutableNonPointer(raw_ptr()->data())[index];
   }
   void SetPointerOffsetAt(int index, int32_t offset_in_instructions) {
     NoSafepointScope no_safepoint;
     *PointerOffsetAddrAt(index) = offset_in_instructions;
   }
 
-  // Currently slow, as it searches linearly through inlined_intervals().
-  intptr_t GetCallerId(intptr_t inlined_id) const;
-
   intptr_t BinarySearchInSCallTable(uword pc) const;
   static RawCode* LookupCodeInIsolate(Isolate* isolate, uword pc);
 
   // New is a private method as RawInstruction and RawCode objects should
   // only be created using the Code::FinalizeCode method. This method creates
   // the RawInstruction and RawCode objects, sets up the pointer offsets
   // and links the two in a GC safe manner.
   static RawCode* New(intptr_t pointer_offsets_length);
 
   FINAL_HEAP_OBJECT_IMPLEMENTATION(Code, Object);
@@ skipping 3904 matching lines @@
 
 inline void TypeArguments::SetHash(intptr_t value) const {
   // This is only safe because we create a new Smi, which does not cause
   // heap allocation.
   StoreSmi(&raw_ptr()->hash_, Smi::New(value));
 }
 
 }  // namespace dart
 
 #endif  // RUNTIME_VM_OBJECT_H_