src/v8/src/sampler.cc

   1 // Copyright 2013 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/sampler.h"
   6
   7 #if V8_OS_POSIX && !V8_OS_CYGWIN
   8
   9 #define USE_SIGNALS
  10
  11 #include <errno.h>
  12 #include <pthread.h>
  13 #include <signal.h>
  14 #include <sys/time.h>
  15
  16 #if !V8_OS_QNX && !V8_OS_NACL
  17 #include <sys/syscall.h>  // NOLINT
  18 #endif
  19
  20 #if V8_OS_MACOSX
  21 #include <mach/mach.h>
  22 // OpenBSD doesn't have <ucontext.h>. ucontext_t lives in <signal.h>
  23 // and is a typedef for struct sigcontext. There is no uc_mcontext.
  24 #elif(!V8_OS_ANDROID || defined(__BIONIC_HAVE_UCONTEXT_T)) && \
  25     !V8_OS_OPENBSD && !V8_OS_NACL
  26 #include <ucontext.h>
  27 #endif
  28
  29 #include <unistd.h>
  30
  31 // GLibc on ARM defines mcontext_t has a typedef for 'struct sigcontext'.
  32 // Old versions of the C library <signal.h> didn't define the type.
  33 #if V8_OS_ANDROID && !defined(__BIONIC_HAVE_UCONTEXT_T) && \
  34     (defined(__arm__) || defined(__aarch64__)) && \
  35     !defined(__BIONIC_HAVE_STRUCT_SIGCONTEXT)
  36 #include <asm/sigcontext.h>  // NOLINT
  37 #endif
  38
  39 #elif V8_OS_WIN || V8_OS_CYGWIN
  40
  41 #include "src/base/win32-headers.h"
  42
  43 #endif
  44
  45 #include "src/v8.h"
  46
  47 #include "src/base/platform/platform.h"
  48 #include "src/cpu-profiler-inl.h"
  49 #include "src/flags.h"
  50 #include "src/frames-inl.h"
  51 #include "src/log.h"
  52 #include "src/simulator.h"
  53 #include "src/v8threads.h"
  54 #include "src/vm-state-inl.h"
  55
  56
  57 #if V8_OS_ANDROID && !defined(__BIONIC_HAVE_UCONTEXT_T)
  58
  59 // Not all versions of Android's C library provide ucontext_t.
  60 // Detect this and provide custom but compatible definitions. Note that these
  61 // follow the GLibc naming convention to access register values from
  62 // mcontext_t.
  63 //
  64 // See http://code.google.com/p/android/issues/detail?id=34784
  65
  66 #if defined(__arm__)
  67
  68 typedef struct sigcontext mcontext_t;
  69
  70 typedef struct ucontext {
  71   uint32_t uc_flags;
  72   struct ucontext* uc_link;
  73   stack_t uc_stack;
  74   mcontext_t uc_mcontext;
  75   // Other fields are not used by V8, don't define them here.
  76 } ucontext_t;
  77
  78 #elif defined(__aarch64__)
  79
  80 typedef struct sigcontext mcontext_t;
  81
  82 typedef struct ucontext {
  83   uint64_t uc_flags;
  84   struct ucontext *uc_link;
  85   stack_t uc_stack;
  86   mcontext_t uc_mcontext;
  87   // Other fields are not used by V8, don't define them here.
  88 } ucontext_t;
  89
  90 #elif defined(__mips__)
  91 // MIPS version of sigcontext, for Android bionic.
  92 typedef struct {
  93   uint32_t regmask;
  94   uint32_t status;
  95   uint64_t pc;
  96   uint64_t gregs[32];
  97   uint64_t fpregs[32];
  98   uint32_t acx;
  99   uint32_t fpc_csr;
 100   uint32_t fpc_eir;
 101   uint32_t used_math;
 102   uint32_t dsp;
 103   uint64_t mdhi;
 104   uint64_t mdlo;
 105   uint32_t hi1;
 106   uint32_t lo1;
 107   uint32_t hi2;
 108   uint32_t lo2;
 109   uint32_t hi3;
 110   uint32_t lo3;
 111 } mcontext_t;
 112
 113 typedef struct ucontext {
 114   uint32_t uc_flags;
 115   struct ucontext* uc_link;
 116   stack_t uc_stack;
 117   mcontext_t uc_mcontext;
 118   // Other fields are not used by V8, don't define them here.
 119 } ucontext_t;
 120
 121 #elif defined(__i386__)
 122 // x86 version for Android.
 123 typedef struct {
 124   uint32_t gregs[19];
 125   void* fpregs;
 126   uint32_t oldmask;
 127   uint32_t cr2;
 128 } mcontext_t;
 129
 130 typedef uint32_t kernel_sigset_t[2];  // x86 kernel uses 64-bit signal masks
 131 typedef struct ucontext {
 132   uint32_t uc_flags;
 133   struct ucontext* uc_link;
 134   stack_t uc_stack;
 135   mcontext_t uc_mcontext;
 136   // Other fields are not used by V8, don't define them here.
 137 } ucontext_t;
 138 enum { REG_EBP = 6, REG_ESP = 7, REG_EIP = 14 };
 139
 140 #elif defined(__x86_64__)
 141 // x64 version for Android.
 142 typedef struct {
 143   uint64_t gregs[23];
 144   void* fpregs;
 145   uint64_t __reserved1[8];
 146 } mcontext_t;
 147
 148 typedef struct ucontext {
 149   uint64_t uc_flags;
 150   struct ucontext *uc_link;
 151   stack_t uc_stack;
 152   mcontext_t uc_mcontext;
 153   // Other fields are not used by V8, don't define them here.
 154 } ucontext_t;
 155 enum { REG_RBP = 10, REG_RSP = 15, REG_RIP = 16 };
 156 #endif
 157
 158 #endif  // V8_OS_ANDROID && !defined(__BIONIC_HAVE_UCONTEXT_T)
 159
 160
 161 namespace v8 {
 162 namespace internal {
 163
 164 namespace {
 165
 166 class PlatformDataCommon : public Malloced {
 167  public:
 168   PlatformDataCommon() : profiled_thread_id_(ThreadId::Current()) {}
 169   ThreadId profiled_thread_id() { return profiled_thread_id_; }
 170
 171  protected:
 172   ~PlatformDataCommon() {}
 173
 174  private:
 175   ThreadId profiled_thread_id_;
 176 };
 177
 178 }  // namespace
 179
 180 #if defined(USE_SIGNALS)
 181
 182 class Sampler::PlatformData : public PlatformDataCommon {
 183  public:
 184   PlatformData() : vm_tid_(pthread_self()) {}
 185   pthread_t vm_tid() const { return vm_tid_; }
 186
 187  private:
 188   pthread_t vm_tid_;
 189 };
 190
 191 #elif V8_OS_WIN || V8_OS_CYGWIN
 192
 193 // ----------------------------------------------------------------------------
 194 // Win32 profiler support. On Cygwin we use the same sampler implementation as
 195 // on Win32.
 196
 197 class Sampler::PlatformData : public PlatformDataCommon {
 198  public:
 199   // Get a handle to the calling thread. This is the thread that we are
 200   // going to profile. We need to make a copy of the handle because we are
 201   // going to use it in the sampler thread. Using GetThreadHandle() will
 202   // not work in this case. We're using OpenThread because DuplicateHandle
 203   // for some reason doesn't work in Chrome's sandbox.
 204   PlatformData()
 205       : profiled_thread_(OpenThread(THREAD_GET_CONTEXT |
 206                                     THREAD_SUSPEND_RESUME |
 207                                     THREAD_QUERY_INFORMATION,
 208                                     false,
 209                                     GetCurrentThreadId())) {}
 210
 211   ~PlatformData() {
 212     if (profiled_thread_ != NULL) {
 213       CloseHandle(profiled_thread_);
 214       profiled_thread_ = NULL;
 215     }
 216   }
 217
 218   HANDLE profiled_thread() { return profiled_thread_; }
 219
 220  private:
 221   HANDLE profiled_thread_;
 222 };
 223 #endif
 224
 225
 226 #if defined(USE_SIMULATOR)
 227 class SimulatorHelper {
 228  public:
 229   inline bool Init(Sampler* sampler, Isolate* isolate) {
 230     simulator_ = isolate->thread_local_top()->simulator_;
 231     // Check if there is active simulator.
 232     return simulator_ != NULL;
 233   }
 234
 235   inline void FillRegisters(RegisterState* state) {
 236 #if V8_TARGET_ARCH_ARM
 237     state->pc = reinterpret_cast<Address>(simulator_->get_pc());
 238     state->sp = reinterpret_cast<Address>(simulator_->get_register(
 239         Simulator::sp));
 240     state->fp = reinterpret_cast<Address>(simulator_->get_register(
 241         Simulator::r11));
 242 #elif V8_TARGET_ARCH_ARM64
 243     if (simulator_->sp() == 0 || simulator_->fp() == 0) {
 244       // It possible that the simulator is interrupted while it is updating
 245       // the sp or fp register. ARM64 simulator does this in two steps:
 246       // first setting it to zero and then setting it to the new value.
 247       // Bailout if sp/fp doesn't contain the new value.
 248       return;
 249     }
 250     state->pc = reinterpret_cast<Address>(simulator_->pc());
 251     state->sp = reinterpret_cast<Address>(simulator_->sp());
 252     state->fp = reinterpret_cast<Address>(simulator_->fp());
 253 #elif V8_TARGET_ARCH_MIPS
 254     state->pc = reinterpret_cast<Address>(simulator_->get_pc());
 255     state->sp = reinterpret_cast<Address>(simulator_->get_register(
 256         Simulator::sp));
 257     state->fp = reinterpret_cast<Address>(simulator_->get_register(
 258         Simulator::fp));
 259 #elif V8_TARGET_ARCH_MIPS64
 260     state->pc = reinterpret_cast<Address>(simulator_->get_pc());
 261     state->sp = reinterpret_cast<Address>(simulator_->get_register(
 262         Simulator::sp));
 263     state->fp = reinterpret_cast<Address>(simulator_->get_register(
 264         Simulator::fp));
 265 #endif
 266   }
 267
 268  private:
 269   Simulator* simulator_;
 270 };
 271 #endif  // USE_SIMULATOR
 272
 273
 274 #if defined(USE_SIGNALS)
 275
 276 class SignalHandler : public AllStatic {
 277  public:
 278   static void SetUp() { if (!mutex_) mutex_ = new base::Mutex(); }
 279   static void TearDown() { delete mutex_; mutex_ = NULL; }
 280
 281   static void IncreaseSamplerCount() {
 282     base::LockGuard<base::Mutex> lock_guard(mutex_);
 283     if (++client_count_ == 1) Install();
 284   }
 285
 286   static void DecreaseSamplerCount() {
 287     base::LockGuard<base::Mutex> lock_guard(mutex_);
 288     if (--client_count_ == 0) Restore();
 289   }
 290
 291   static bool Installed() {
 292     return signal_handler_installed_;
 293   }
 294
 295  private:
 296   static void Install() {
 297 #if !V8_OS_NACL
 298     struct sigaction sa;
 299     sa.sa_sigaction = &HandleProfilerSignal;
 300     sigemptyset(&sa.sa_mask);
 301 #if V8_OS_QNX
 302     sa.sa_flags = SA_SIGINFO;
 303 #else
 304     sa.sa_flags = SA_RESTART | SA_SIGINFO;
 305 #endif
 306     signal_handler_installed_ =
 307         (sigaction(SIGPROF, &sa, &old_signal_handler_) == 0);
 308 #endif
 309   }
 310
 311   static void Restore() {
 312 #if !V8_OS_NACL
 313     if (signal_handler_installed_) {
 314       sigaction(SIGPROF, &old_signal_handler_, 0);
 315       signal_handler_installed_ = false;
 316     }
 317 #endif
 318   }
 319
 320 #if !V8_OS_NACL
 321   static void HandleProfilerSignal(int signal, siginfo_t* info, void* context);
 322 #endif
 323   // Protects the process wide state below.
 324   static base::Mutex* mutex_;
 325   static int client_count_;
 326   static bool signal_handler_installed_;
 327   static struct sigaction old_signal_handler_;
 328 };
 329
 330
 331 base::Mutex* SignalHandler::mutex_ = NULL;
 332 int SignalHandler::client_count_ = 0;
 333 struct sigaction SignalHandler::old_signal_handler_;
 334 bool SignalHandler::signal_handler_installed_ = false;
 335
 336
 337 // As Native Client does not support signal handling, profiling is disabled.
 338 #if !V8_OS_NACL
 339 void SignalHandler::HandleProfilerSignal(int signal, siginfo_t* info,
 340                                          void* context) {
 341   USE(info);
 342   if (signal != SIGPROF) return;
 343   Isolate* isolate = Isolate::UnsafeCurrent();
 344   if (isolate == NULL || !isolate->IsInitialized() || !isolate->IsInUse()) {
 345     // We require a fully initialized and entered isolate.
 346     return;
 347   }
 348   if (v8::Locker::IsActive() &&
 349       !isolate->thread_manager()->IsLockedByCurrentThread()) {
 350     return;
 351   }
 352
 353   Sampler* sampler = isolate->logger()->sampler();
 354   if (sampler == NULL) return;
 355
 356   RegisterState state;
 357
 358 #if defined(USE_SIMULATOR)
 359   SimulatorHelper helper;
 360   if (!helper.Init(sampler, isolate)) return;
 361   helper.FillRegisters(&state);
 362   // It possible that the simulator is interrupted while it is updating
 363   // the sp or fp register. ARM64 simulator does this in two steps:
 364   // first setting it to zero and then setting it to the new value.
 365   // Bailout if sp/fp doesn't contain the new value.
 366   if (state.sp == 0 || state.fp == 0) return;
 367 #else
 368   // Extracting the sample from the context is extremely machine dependent.
 369   ucontext_t* ucontext = reinterpret_cast<ucontext_t*>(context);
 370 #if !V8_OS_OPENBSD
 371   mcontext_t& mcontext = ucontext->uc_mcontext;
 372 #endif
 373 #if V8_OS_LINUX
 374 #if V8_HOST_ARCH_IA32
 375   state.pc = reinterpret_cast<Address>(mcontext.gregs[REG_EIP]);
 376   state.sp = reinterpret_cast<Address>(mcontext.gregs[REG_ESP]);
 377   state.fp = reinterpret_cast<Address>(mcontext.gregs[REG_EBP]);
 378 #elif V8_HOST_ARCH_X64
 379   state.pc = reinterpret_cast<Address>(mcontext.gregs[REG_RIP]);
 380   state.sp = reinterpret_cast<Address>(mcontext.gregs[REG_RSP]);
 381   state.fp = reinterpret_cast<Address>(mcontext.gregs[REG_RBP]);
 382 #elif V8_HOST_ARCH_ARM
 383 #if defined(__GLIBC__) && !defined(__UCLIBC__) && \
 384     (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ <= 3))
 385   // Old GLibc ARM versions used a gregs[] array to access the register
 386   // values from mcontext_t.
 387   state.pc = reinterpret_cast<Address>(mcontext.gregs[R15]);
 388   state.sp = reinterpret_cast<Address>(mcontext.gregs[R13]);
 389   state.fp = reinterpret_cast<Address>(mcontext.gregs[R11]);
 390 #else
 391   state.pc = reinterpret_cast<Address>(mcontext.arm_pc);
 392   state.sp = reinterpret_cast<Address>(mcontext.arm_sp);
 393   state.fp = reinterpret_cast<Address>(mcontext.arm_fp);
 394 #endif  // defined(__GLIBC__) && !defined(__UCLIBC__) &&
 395         // (__GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ <= 3))
 396 #elif V8_HOST_ARCH_ARM64
 397   state.pc = reinterpret_cast<Address>(mcontext.pc);
 398   state.sp = reinterpret_cast<Address>(mcontext.sp);
 399   // FP is an alias for x29.
 400   state.fp = reinterpret_cast<Address>(mcontext.regs[29]);
 401 #elif V8_HOST_ARCH_MIPS
 402   state.pc = reinterpret_cast<Address>(mcontext.pc);
 403   state.sp = reinterpret_cast<Address>(mcontext.gregs[29]);
 404   state.fp = reinterpret_cast<Address>(mcontext.gregs[30]);
 405 #elif V8_HOST_ARCH_MIPS64
 406   state.pc = reinterpret_cast<Address>(mcontext.pc);
 407   state.sp = reinterpret_cast<Address>(mcontext.gregs[29]);
 408   state.fp = reinterpret_cast<Address>(mcontext.gregs[30]);
 409 #endif  // V8_HOST_ARCH_*
 410 #elif V8_OS_MACOSX
 411 #if V8_HOST_ARCH_X64
 412 #if __DARWIN_UNIX03
 413   state.pc = reinterpret_cast<Address>(mcontext->__ss.__rip);
 414   state.sp = reinterpret_cast<Address>(mcontext->__ss.__rsp);
 415   state.fp = reinterpret_cast<Address>(mcontext->__ss.__rbp);
 416 #else  // !__DARWIN_UNIX03
 417   state.pc = reinterpret_cast<Address>(mcontext->ss.rip);
 418   state.sp = reinterpret_cast<Address>(mcontext->ss.rsp);
 419   state.fp = reinterpret_cast<Address>(mcontext->ss.rbp);
 420 #endif  // __DARWIN_UNIX03
 421 #elif V8_HOST_ARCH_IA32
 422 #if __DARWIN_UNIX03
 423   state.pc = reinterpret_cast<Address>(mcontext->__ss.__eip);
 424   state.sp = reinterpret_cast<Address>(mcontext->__ss.__esp);
 425   state.fp = reinterpret_cast<Address>(mcontext->__ss.__ebp);
 426 #else  // !__DARWIN_UNIX03
 427   state.pc = reinterpret_cast<Address>(mcontext->ss.eip);
 428   state.sp = reinterpret_cast<Address>(mcontext->ss.esp);
 429   state.fp = reinterpret_cast<Address>(mcontext->ss.ebp);
 430 #endif  // __DARWIN_UNIX03
 431 #endif  // V8_HOST_ARCH_IA32
 432 #elif V8_OS_FREEBSD
 433 #if V8_HOST_ARCH_IA32
 434   state.pc = reinterpret_cast<Address>(mcontext.mc_eip);
 435   state.sp = reinterpret_cast<Address>(mcontext.mc_esp);
 436   state.fp = reinterpret_cast<Address>(mcontext.mc_ebp);
 437 #elif V8_HOST_ARCH_X64
 438   state.pc = reinterpret_cast<Address>(mcontext.mc_rip);
 439   state.sp = reinterpret_cast<Address>(mcontext.mc_rsp);
 440   state.fp = reinterpret_cast<Address>(mcontext.mc_rbp);
 441 #elif V8_HOST_ARCH_ARM
 442   state.pc = reinterpret_cast<Address>(mcontext.mc_r15);
 443   state.sp = reinterpret_cast<Address>(mcontext.mc_r13);
 444   state.fp = reinterpret_cast<Address>(mcontext.mc_r11);
 445 #endif  // V8_HOST_ARCH_*
 446 #elif V8_OS_NETBSD
 447 #if V8_HOST_ARCH_IA32
 448   state.pc = reinterpret_cast<Address>(mcontext.__gregs[_REG_EIP]);
 449   state.sp = reinterpret_cast<Address>(mcontext.__gregs[_REG_ESP]);
 450   state.fp = reinterpret_cast<Address>(mcontext.__gregs[_REG_EBP]);
 451 #elif V8_HOST_ARCH_X64
 452   state.pc = reinterpret_cast<Address>(mcontext.__gregs[_REG_RIP]);
 453   state.sp = reinterpret_cast<Address>(mcontext.__gregs[_REG_RSP]);
 454   state.fp = reinterpret_cast<Address>(mcontext.__gregs[_REG_RBP]);
 455 #endif  // V8_HOST_ARCH_*
 456 #elif V8_OS_OPENBSD
 457 #if V8_HOST_ARCH_IA32
 458   state.pc = reinterpret_cast<Address>(ucontext->sc_eip);
 459   state.sp = reinterpret_cast<Address>(ucontext->sc_esp);
 460   state.fp = reinterpret_cast<Address>(ucontext->sc_ebp);
 461 #elif V8_HOST_ARCH_X64
 462   state.pc = reinterpret_cast<Address>(ucontext->sc_rip);
 463   state.sp = reinterpret_cast<Address>(ucontext->sc_rsp);
 464   state.fp = reinterpret_cast<Address>(ucontext->sc_rbp);
 465 #endif  // V8_HOST_ARCH_*
 466 #elif V8_OS_SOLARIS
 467   state.pc = reinterpret_cast<Address>(mcontext.gregs[REG_PC]);
 468   state.sp = reinterpret_cast<Address>(mcontext.gregs[REG_SP]);
 469   state.fp = reinterpret_cast<Address>(mcontext.gregs[REG_FP]);
 470 #elif V8_OS_QNX
 471 #if V8_HOST_ARCH_IA32
 472   state.pc = reinterpret_cast<Address>(mcontext.cpu.eip);
 473   state.sp = reinterpret_cast<Address>(mcontext.cpu.esp);
 474   state.fp = reinterpret_cast<Address>(mcontext.cpu.ebp);
 475 #elif V8_HOST_ARCH_ARM
 476   state.pc = reinterpret_cast<Address>(mcontext.cpu.gpr[ARM_REG_PC]);
 477   state.sp = reinterpret_cast<Address>(mcontext.cpu.gpr[ARM_REG_SP]);
 478   state.fp = reinterpret_cast<Address>(mcontext.cpu.gpr[ARM_REG_FP]);
 479 #endif  // V8_HOST_ARCH_*
 480 #endif  // V8_OS_QNX
 481 #endif  // USE_SIMULATOR
 482   sampler->SampleStack(state);
 483 }
 484 #endif  // V8_OS_NACL
 485
 486 #endif
 487
 488
 489 class SamplerThread : public base::Thread {
 490  public:
 491   static const int kSamplerThreadStackSize = 64 * KB;
 492
 493   explicit SamplerThread(int interval)
 494       : Thread(base::Thread::Options("SamplerThread", kSamplerThreadStackSize)),
 495         interval_(interval) {}
 496
 497   static void SetUp() { if (!mutex_) mutex_ = new base::Mutex(); }
 498   static void TearDown() { delete mutex_; mutex_ = NULL; }
 499
 500   static void AddActiveSampler(Sampler* sampler) {
 501     bool need_to_start = false;
 502     base::LockGuard<base::Mutex> lock_guard(mutex_);
 503     if (instance_ == NULL) {
 504       // Start a thread that will send SIGPROF signal to VM threads,
 505       // when CPU profiling will be enabled.
 506       instance_ = new SamplerThread(sampler->interval());
 507       need_to_start = true;
 508     }
 509
 510     DCHECK(sampler->IsActive());
 511     DCHECK(!instance_->active_samplers_.Contains(sampler));
 512     DCHECK(instance_->interval_ == sampler->interval());
 513     instance_->active_samplers_.Add(sampler);
 514
 515     if (need_to_start) instance_->StartSynchronously();
 516   }
 517
 518   static void RemoveActiveSampler(Sampler* sampler) {
 519     SamplerThread* instance_to_remove = NULL;
 520     {
 521       base::LockGuard<base::Mutex> lock_guard(mutex_);
 522
 523       DCHECK(sampler->IsActive());
 524       bool removed = instance_->active_samplers_.RemoveElement(sampler);
 525       DCHECK(removed);
 526       USE(removed);
 527
 528       // We cannot delete the instance immediately as we need to Join() the
 529       // thread but we are holding mutex_ and the thread may try to acquire it.
 530       if (instance_->active_samplers_.is_empty()) {
 531         instance_to_remove = instance_;
 532         instance_ = NULL;
 533       }
 534     }
 535
 536     if (!instance_to_remove) return;
 537     instance_to_remove->Join();
 538     delete instance_to_remove;
 539   }
 540
 541   // Implement Thread::Run().
 542   virtual void Run() {
 543     while (true) {
 544       {
 545         base::LockGuard<base::Mutex> lock_guard(mutex_);
 546         if (active_samplers_.is_empty()) break;
 547         // When CPU profiling is enabled both JavaScript and C++ code is
 548         // profiled. We must not suspend.
 549         for (int i = 0; i < active_samplers_.length(); ++i) {
 550           Sampler* sampler = active_samplers_.at(i);
 551           if (!sampler->isolate()->IsInitialized()) continue;
 552           if (!sampler->IsProfiling()) continue;
 553           sampler->DoSample();
 554         }
 555       }
 556       base::OS::Sleep(interval_);
 557     }
 558   }
 559
 560  private:
 561   // Protects the process wide state below.
 562   static base::Mutex* mutex_;
 563   static SamplerThread* instance_;
 564
 565   const int interval_;
 566   List<Sampler*> active_samplers_;
 567
 568   DISALLOW_COPY_AND_ASSIGN(SamplerThread);
 569 };
 570
 571
 572 base::Mutex* SamplerThread::mutex_ = NULL;
 573 SamplerThread* SamplerThread::instance_ = NULL;
 574
 575
 576 //
 577 // StackTracer implementation
 578 //
 579 DISABLE_ASAN void TickSample::Init(Isolate* isolate,
 580                                    const RegisterState& regs) {
 581   DCHECK(isolate->IsInitialized());
 582   timestamp = base::TimeTicks::HighResolutionNow();
 583   pc = regs.pc;
 584   state = isolate->current_vm_state();
 585
 586   // Avoid collecting traces while doing GC.
 587   if (state == GC) return;
 588
 589   Address js_entry_sp = isolate->js_entry_sp();
 590   if (js_entry_sp == 0) {
 591     // Not executing JS now.
 592     return;
 593   }
 594
 595   ExternalCallbackScope* scope = isolate->external_callback_scope();
 596   Address handler = Isolate::handler(isolate->thread_local_top());
 597   // If there is a handler on top of the external callback scope then
 598   // we have already entrered JavaScript again and the external callback
 599   // is not the top function.
 600   if (scope && scope->scope_address() < handler) {
 601     external_callback = scope->callback();
 602     has_external_callback = true;
 603   } else {
 604     // Sample potential return address value for frameless invocation of
 605     // stubs (we'll figure out later, if this value makes sense).
 606     tos = Memory::Address_at(regs.sp);
 607     has_external_callback = false;
 608   }
 609
 610   SafeStackFrameIterator it(isolate, regs.fp, regs.sp, js_entry_sp);
 611   top_frame_type = it.top_frame_type();
 612   unsigned i = 0;
 613   while (!it.done() && i < TickSample::kMaxFramesCount) {
 614     stack[i++] = it.frame()->pc();
 615     it.Advance();
 616   }
 617   frames_count = i;
 618 }
 619
 620
 621 void Sampler::SetUp() {
 622 #if defined(USE_SIGNALS)
 623   SignalHandler::SetUp();
 624 #endif
 625   SamplerThread::SetUp();
 626 }
 627
 628
 629 void Sampler::TearDown() {
 630   SamplerThread::TearDown();
 631 #if defined(USE_SIGNALS)
 632   SignalHandler::TearDown();
 633 #endif
 634 }
 635
 636
 637 Sampler::Sampler(Isolate* isolate, int interval)
 638     : isolate_(isolate),
 639       interval_(interval),
 640       profiling_(false),
 641       has_processing_thread_(false),
 642       active_(false),
 643       is_counting_samples_(false),
 644       js_and_external_sample_count_(0) {
 645   data_ = new PlatformData;
 646 }
 647
 648
 649 Sampler::~Sampler() {
 650   DCHECK(!IsActive());
 651   delete data_;
 652 }
 653
 654
 655 void Sampler::Start() {
 656   DCHECK(!IsActive());
 657   SetActive(true);
 658   SamplerThread::AddActiveSampler(this);
 659 }
 660
 661
 662 void Sampler::Stop() {
 663   DCHECK(IsActive());
 664   SamplerThread::RemoveActiveSampler(this);
 665   SetActive(false);
 666 }
 667
 668
 669 void Sampler::IncreaseProfilingDepth() {
 670   base::NoBarrier_AtomicIncrement(&profiling_, 1);
 671 #if defined(USE_SIGNALS)
 672   SignalHandler::IncreaseSamplerCount();
 673 #endif
 674 }
 675
 676
 677 void Sampler::DecreaseProfilingDepth() {
 678 #if defined(USE_SIGNALS)
 679   SignalHandler::DecreaseSamplerCount();
 680 #endif
 681   base::NoBarrier_AtomicIncrement(&profiling_, -1);
 682 }
 683
 684
 685 void Sampler::SampleStack(const RegisterState& state) {
 686   TickSample* sample = isolate_->cpu_profiler()->StartTickSample();
 687   TickSample sample_obj;
 688   if (sample == NULL) sample = &sample_obj;
 689   sample->Init(isolate_, state);
 690   if (is_counting_samples_) {
 691     if (sample->state == JS || sample->state == EXTERNAL) {
 692       ++js_and_external_sample_count_;
 693     }
 694   }
 695   Tick(sample);
 696   if (sample != &sample_obj) {
 697     isolate_->cpu_profiler()->FinishTickSample();
 698   }
 699 }
 700
 701
 702 #if defined(USE_SIGNALS)
 703
 704 void Sampler::DoSample() {
 705   if (!SignalHandler::Installed()) return;
 706   pthread_kill(platform_data()->vm_tid(), SIGPROF);
 707 }
 708
 709 #elif V8_OS_WIN || V8_OS_CYGWIN
 710
 711 void Sampler::DoSample() {
 712   HANDLE profiled_thread = platform_data()->profiled_thread();
 713   if (profiled_thread == NULL) return;
 714
 715 #if defined(USE_SIMULATOR)
 716   SimulatorHelper helper;
 717   if (!helper.Init(this, isolate())) return;
 718 #endif
 719
 720   const DWORD kSuspendFailed = static_cast<DWORD>(-1);
 721   if (SuspendThread(profiled_thread) == kSuspendFailed) return;
 722
 723   // Context used for sampling the register state of the profiled thread.
 724   CONTEXT context;
 725   memset(&context, 0, sizeof(context));
 726   context.ContextFlags = CONTEXT_FULL;
 727   if (GetThreadContext(profiled_thread, &context) != 0) {
 728     RegisterState state;
 729 #if defined(USE_SIMULATOR)
 730     helper.FillRegisters(&state);
 731 #else
 732 #if V8_HOST_ARCH_X64
 733     state.pc = reinterpret_cast<Address>(context.Rip);
 734     state.sp = reinterpret_cast<Address>(context.Rsp);
 735     state.fp = reinterpret_cast<Address>(context.Rbp);
 736 #else
 737     state.pc = reinterpret_cast<Address>(context.Eip);
 738     state.sp = reinterpret_cast<Address>(context.Esp);
 739     state.fp = reinterpret_cast<Address>(context.Ebp);
 740 #endif
 741 #endif  // USE_SIMULATOR
 742     SampleStack(state);
 743   }
 744   ResumeThread(profiled_thread);
 745 }
 746
 747 #endif  // USE_SIGNALS
 748
 749
 750 } }  // namespace v8::internal