Add storage of class id and state bit to the profiler's Sample

runtime/vm/profiler.cc

 // Copyright (c) 2013, 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 "platform/address_sanitizer.h"
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
@@ skipping 780 matching lines @@
 
   Sample* sample_;
   const uword stack_upper_;
   const uword original_pc_;
   const uword original_fp_;
   const uword original_sp_;
   uword lower_bound_;
 };
 
 
-static void CopyPCMarkerIfSafe(Sample* sample) {
+static void CopyPCMarkerIfSafe(Sample* sample, uword fp_addr, uword sp_addr) {
   ASSERT(sample != NULL);
 
   if (sample->vm_tag() != VMTag::kDartTagId) {
     // We can only trust the stack pointer if we are executing Dart code.
     // See http://dartbug.com/20421 for details.
     return;
   }
-  uword* fp = reinterpret_cast<uword*>(sample->fp());
-  uword* sp = reinterpret_cast<uword*>(sample->sp());
+  uword* fp = reinterpret_cast<uword*>(fp_addr);
+  uword* sp = reinterpret_cast<uword*>(sp_addr);
 
   // If FP == SP, the pc marker hasn't been pushed.
   if (fp > sp) {
     uword* pc_marker_ptr = fp + kPcMarkerSlotFromFp;
     // MSan/ASan are unaware of frames initialized by generated code.
     MSAN_UNPOISON(pc_marker_ptr, kWordSize);
     ASAN_UNPOISON(pc_marker_ptr, kWordSize);
     sample->set_pc_marker(*pc_marker_ptr);
   }
 }
 
 
-static void CopyStackBuffer(Sample* sample) {
+static void CopyStackBuffer(Sample* sample, uword sp_addr) {
   ASSERT(sample != NULL);
   if (sample->vm_tag() != VMTag::kDartTagId) {
     // We can only trust the stack pointer if we are executing Dart code.
     // See http://dartbug.com/20421 for details.
     return;
   }
-  uword* sp = reinterpret_cast<uword*>(sample->sp());
+  uword* sp = reinterpret_cast<uword*>(sp_addr);
   uword* buffer = sample->GetStackBuffer();
   if (sp != NULL) {
     for (intptr_t i = 0; i < Sample::kStackBufferSizeInWords; i++) {
       MSAN_UNPOISON(sp, kWordSize);
       ASAN_UNPOISON(sp, kWordSize);
       buffer[i] = *sp;
       sp++;
     }
   }
 }
@@ skipping 17 matching lines @@
 #endif
 
 // All memory access done to collect the sample is performed in CollectSample.
 static void CollectSample(Isolate* isolate,
                           bool exited_dart_code,
                           bool in_dart_code,
                           Sample* sample,
                           ProfilerNativeStackWalker* native_stack_walker,
                           ProfilerDartExitStackWalker* dart_exit_stack_walker,
                           ProfilerDartStackWalker* dart_stack_walker,
-                          uword pc) {
+                          uword pc,
+                          uword fp,
+                          uword sp) {
 #if defined(TARGET_OS_WINDOWS)
   // Use structured exception handling to trap guard page access on Windows.
   __try {
 #endif
 
-  CopyStackBuffer(sample);
-  CopyPCMarkerIfSafe(sample);
+  CopyStackBuffer(sample, sp);
+  CopyPCMarkerIfSafe(sample, fp, sp);
 
   if (FLAG_profile_vm) {
     // Always walk the native stack collecting both native and Dart frames.
     native_stack_walker->walk();
   } else if (exited_dart_code) {
     // We have a valid exit frame info, use the Dart stack walker.
     dart_exit_stack_walker->walk();
   } else if (in_dart_code) {
     // We are executing Dart code. We have frame pointers.
     dart_stack_walker->walk();
@@ skipping 153 matching lines @@
   if (redirect_vm_tag != 0) {
     vm_tag = redirect_vm_tag;
   }
 #endif
   // Increment counter for vm tag.
   VMTagCounters* counters = isolate->vm_tag_counters();
   ASSERT(counters != NULL);
   counters->Increment(vm_tag);
   sample->set_vm_tag(vm_tag);
   sample->set_user_tag(isolate->user_tag());
-  sample->set_sp(sp);
-  sample->set_fp(fp);
   sample->set_lr(lr);
 
   ProfilerNativeStackWalker native_stack_walker(sample,
                                                 stack_lower,
                                                 stack_upper,
                                                 pc,
                                                 fp,
                                                 sp);
 
   ProfilerDartExitStackWalker dart_exit_stack_walker(isolate, sample);
 
   ProfilerDartStackWalker dart_stack_walker(isolate,
                                             sample,
                                             stack_lower,
                                             stack_upper,
                                             pc,
                                             fp,
                                             sp);
 
   // All memory access is done inside CollectSample.
   CollectSample(isolate,
                 exited_dart_code,
                 in_dart_code,
                 sample,
                 &native_stack_walker,
                 &dart_exit_stack_walker,
                 &dart_stack_walker,
-                pc);
+                pc,
+                fp,
+                sp);
 }
 
 }  // namespace dart