Make profiler work without Instructions -> Code pointer

runtime/vm/profiler_service.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/profiler_service.h"
 
 #include "vm/growable_array.h"
 #include "vm/native_symbol.h"
 #include "vm/object.h"
 #include "vm/os.h"
@@ skipping 1057 matching lines @@
 
   void SanitizeMinMaxTimes() {
     if ((profile_->min_time_ == kMaxInt64) && (profile_->max_time_ == 0)) {
       profile_->min_time_ = 0;
       profile_->max_time_ = 0;
     }
   }
 
   void BuildCodeTable() {
     ScopeTimer sw("ProfileBuilder::BuildCodeTable", FLAG_trace_profiler);
+
+    Isolate* isolate = thread_->isolate();
+    ASSERT(isolate != NULL);
+
+    // Build the live code table eagerly by populating it with code objects
+    // from the processed sample buffer.
+    const CodeLookupTable& code_lookup_table = samples_->code_lookup_table();
+    for (intptr_t i = 0; i < code_lookup_table.length(); i++) {
+      const CodeDescriptor* descriptor = code_lookup_table.At(i);
+      ASSERT(descriptor != NULL);
+      const Code& code = Code::Handle(descriptor->code());
+      ASSERT(!code.IsNull());
+      RegisterLiveProfileCode(
+          new ProfileCode(ProfileCode::kDartCode,
+                          code.EntryPoint(),
+                          code.EntryPoint() + code.Size(),
+                          code.compile_timestamp(),
+                          code));
+    }
+
+    // Iterate over samples.
     for (intptr_t sample_index = 0;
          sample_index < samples_->length();
          sample_index++) {
       ProcessedSample* sample = samples_->At(sample_index);
       const int64_t timestamp = sample->timestamp();
 
       // This is our first pass over the sample buffer, use this as an
       // opportunity to determine the min and max time ranges of this profile.
       UpdateMinMaxTimes(timestamp);
 
       // Make sure VM tag exists.
       if (VMTag::IsNativeEntryTag(sample->vm_tag())) {
         RegisterProfileCodeTag(VMTag::kNativeTagId);
       } else if (VMTag::IsRuntimeEntryTag(sample->vm_tag())) {
         RegisterProfileCodeTag(VMTag::kRuntimeTagId);
       }
       RegisterProfileCodeTag(sample->vm_tag());
       // Make sure user tag exists.
       RegisterProfileCodeTag(sample->user_tag());
 
       // Make sure that a ProfileCode objects exist for all pcs in the sample
       // and tick each one.
       for (intptr_t frame_index = 0;
            frame_index < sample->length();
            frame_index++) {
         const uword pc = sample->At(frame_index);
         ASSERT(pc != 0);
-        ProfileCode* code = RegisterProfileCode(pc, timestamp);
+        ProfileCode* code = FindOrRegisterProfileCode(pc, timestamp);
         ASSERT(code != NULL);
         code->Tick(pc, IsExecutingFrame(sample, frame_index), sample_index);
       }
     }
     SanitizeMinMaxTimes();
   }
 
   void FinalizeCodeIndexes() {
     ScopeTimer sw("ProfileBuilder::FinalizeCodeIndexes", FLAG_trace_profiler);
     ProfileCodeTable* live_table = profile_->live_code_;
@@ skipping 714 matching lines @@
 
   ProfileCode* CreateProfileCodeReused(uword pc) {
     ProfileCode* code = new ProfileCode(ProfileCode::kReusedCode,
                                         pc,
                                         pc + 1,
                                         0,
                                         null_code_);
     return code;
   }
 
-  ProfileCode* CreateProfileCode(uword pc) {
-    const intptr_t kDartCodeAlignment = OS::PreferredCodeAlignment();
-    const intptr_t kDartCodeAlignmentMask = ~(kDartCodeAlignment - 1);
-    Code& code = Code::Handle(thread_->zone());
+  bool IsPCInDartHeap(uword pc) {
+    return vm_isolate_->heap()->CodeContains(pc) ||
+           thread_->isolate()->heap()->CodeContains(pc);
+  }
 
-    // Check current isolate for pc.
-    if (thread_->isolate()->heap()->CodeContains(pc)) {
-      code ^= Code::LookupCode(pc);
-      if (!code.IsNull()) {
-        deoptimized_code_->Add(code);
-        return new ProfileCode(ProfileCode::kDartCode,
-                              code.EntryPoint(),
-                              code.EntryPoint() + code.Size(),
-                              code.compile_timestamp(),
-                              code);
-      }
-      return new ProfileCode(ProfileCode::kCollectedCode,
-                            pc,
-                            (pc & kDartCodeAlignmentMask) + kDartCodeAlignment,
-                            0,
-                            code);
+
+  ProfileCode* FindOrRegisterNativeProfileCode(uword pc) {
+    // Check if |pc| is already known in the live code table.
+    ProfileCodeTable* live_table = profile_->live_code_;
+    ProfileCode* profile_code = live_table->FindCodeForPC(pc);
+    if (profile_code != NULL) {
+      return profile_code;
     }
 
-    // Check VM isolate for pc.
-    if (vm_isolate_->heap()->CodeContains(pc)) {
-      code ^= Code::LookupCodeInVmIsolate(pc);
-      if (!code.IsNull()) {
-        return new ProfileCode(ProfileCode::kDartCode,
-                              code.EntryPoint(),
-                              code.EntryPoint() + code.Size(),
-                              code.compile_timestamp(),
-                              code);
-      }
-      // Precompiled instructions are in the VM isolate, but the code (except
-      // stubs) is in the current isolate.
-      code ^= Code::LookupCode(pc);
-      if (!code.IsNull()) {
-        return new ProfileCode(ProfileCode::kDartCode,
-                              code.EntryPoint(),
-                              code.EntryPoint() + code.Size(),
-                              code.compile_timestamp(),
-                              code);
-      }
-      return new ProfileCode(ProfileCode::kCollectedCode,
-                            pc,
-                            (pc & kDartCodeAlignmentMask) + kDartCodeAlignment,
-                            0,
-                            code);
-    }
+    // We haven't seen this pc yet.
+    Code& code = Code::Handle(thread_->zone());
 
     // Check NativeSymbolResolver for pc.
     uintptr_t native_start = 0;
     char* native_name = NativeSymbolResolver::LookupSymbolName(pc,
                                                                &native_start);
     if (native_name == NULL) {
-      // No native name found.
-      return new ProfileCode(ProfileCode::kNativeCode,
-                            pc,
-                            pc + 1,
-                            0,
-                            code);
+      // Failed to find a native symbol for pc.
+      native_start = pc;
     }
 
 #if defined(HOST_ARCH_ARM)
     // The symbol for a Thumb function will be xxx1, but we may have samples
     // at function entry which will have pc xxx0.
     native_start &= ~1;
 #endif
 
     ASSERT(pc >= native_start);
-    ProfileCode* profile_code =
-        new ProfileCode(ProfileCode::kNativeCode,
-                       native_start,
-                       pc + 1,
-                       0,
-                       code);
-    profile_code->SetName(native_name);
-    NativeSymbolResolver::FreeSymbolName(native_name);
+    profile_code = new ProfileCode(ProfileCode::kNativeCode,
+                                   native_start,
+                                   pc + 1,
+                                   0,
+                                   code);
+    if (native_name != NULL) {
+      profile_code->SetName(native_name);
+      NativeSymbolResolver::FreeSymbolName(native_name);
+    }
+
+    RegisterLiveProfileCode(profile_code);
     return profile_code;
   }
 
-  ProfileCode* RegisterProfileCode(uword pc, int64_t timestamp) {
+  void RegisterLiveProfileCode(ProfileCode* code) {
     ProfileCodeTable* live_table = profile_->live_code_;
+    intptr_t index = live_table->InsertCode(code);
+    ASSERT(index >= 0);
+  }
+
+  ProfileCode* FindOrRegisterDeadProfileCode(uword pc) {
     ProfileCodeTable* dead_table = profile_->dead_code_;
 
-    ProfileCode* code = live_table->FindCodeForPC(pc);
-    if (code == NULL) {
-      // Code not found.
-      intptr_t index = live_table->InsertCode(CreateProfileCode(pc));
-      ASSERT(index >= 0);
-      code = live_table->At(index);
-      if (code->compile_timestamp() <= timestamp) {
-        // Code was compiled before sample was taken.
-        return code;
-      }
-      // Code was compiled after the sample was taken. Insert code object into
-      // the dead code table.
-      index = dead_table->InsertCode(CreateProfileCodeReused(pc));
-      ASSERT(index >= 0);
-      return dead_table->At(index);
-    }
-    // Existing code found.
-    if (code->compile_timestamp() <= timestamp) {
-      // Code was compiled before sample was taken.
-      return code;
-    }
-    // Code was compiled after the sample was taken. Check if we have an entry
-    // in the dead code table.
-    code = dead_table->FindCodeForPC(pc);
+    ProfileCode* code = dead_table->FindCodeForPC(pc);
     if (code != NULL) {
       return code;
     }
+
     // Create a new dead code entry.
     intptr_t index = dead_table->InsertCode(CreateProfileCodeReused(pc));
     ASSERT(index >= 0);
     return dead_table->At(index);
   }
 
+  ProfileCode* FindOrRegisterProfileCode(uword pc, int64_t timestamp) {
+    ProfileCodeTable* live_table = profile_->live_code_;
+    ProfileCode* code = live_table->FindCodeForPC(pc);
+    if ((code != NULL) && (code->compile_timestamp() <= timestamp)) {
+      // Code was compiled before sample was taken.
+      return code;
+    }
+    if ((code == NULL) && !IsPCInDartHeap(pc)) {
+      // Not a PC from Dart code. Check with native code.
+      return FindOrRegisterNativeProfileCode(pc);
+    }
+    // We either didn't find the code or it was compiled after the sample.
+    return FindOrRegisterDeadProfileCode(pc);
+  }
+
   Profile::TagOrder tag_order() const {
     return tag_order_;
   }
 
   bool vm_tags_emitted() const {
     return (tag_order_ == Profile::kUserVM) ||
            (tag_order_ == Profile::kVMUser) ||
            (tag_order_ == Profile::kVM);
   }
 
@@ skipping 324 matching lines @@
   Isolate* isolate = thread->isolate();
 
   // Disable thread interrupts while processing the buffer.
   DisableThreadInterruptsScope dtis(thread);
 
   ClearProfileVisitor clear_profile(isolate);
   sample_buffer->VisitSamples(&clear_profile);
 }
 
 }  // namespace dart