src/v8/test/cctest/test-log-stack-tracer.cc

   1 // Copyright 2011 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27 //
  28 // Tests of profiler-related functions from log.h
  29
  30 #include <stdlib.h>
  31
  32 #include "src/v8.h"
  33
  34 #include "src/api.h"
  35 #include "src/codegen.h"
  36 #include "src/disassembler.h"
  37 #include "src/isolate.h"
  38 #include "src/log.h"
  39 #include "src/sampler.h"
  40 #include "src/vm-state-inl.h"
  41 #include "test/cctest/cctest.h"
  42 #include "test/cctest/trace-extension.h"
  43
  44 using v8::Function;
  45 using v8::Local;
  46 using v8::Object;
  47 using v8::Script;
  48 using v8::String;
  49 using v8::Value;
  50
  51 using v8::internal::byte;
  52 using v8::internal::Address;
  53 using v8::internal::Handle;
  54 using v8::internal::Isolate;
  55 using v8::internal::JSFunction;
  56 using v8::internal::TickSample;
  57
  58
  59 static bool IsAddressWithinFuncCode(JSFunction* function, Address addr) {
  60   i::Code* code = function->code();
  61   return code->contains(addr);
  62 }
  63
  64
  65 static bool IsAddressWithinFuncCode(v8::Local<v8::Context> context,
  66                                     const char* func_name,
  67                                     Address addr) {
  68   v8::Local<v8::Value> func = context->Global()->Get(v8_str(func_name));
  69   CHECK(func->IsFunction());
  70   JSFunction* js_func = JSFunction::cast(*v8::Utils::OpenHandle(*func));
  71   return IsAddressWithinFuncCode(js_func, addr);
  72 }
  73
  74
  75 // This C++ function is called as a constructor, to grab the frame pointer
  76 // from the calling function.  When this function runs, the stack contains
  77 // a C_Entry frame and a Construct frame above the calling function's frame.
  78 static void construct_call(const v8::FunctionCallbackInfo<v8::Value>& args) {
  79   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(args.GetIsolate());
  80   i::StackFrameIterator frame_iterator(isolate);
  81   CHECK(frame_iterator.frame()->is_exit());
  82   frame_iterator.Advance();
  83   CHECK(frame_iterator.frame()->is_construct());
  84   frame_iterator.Advance();
  85   i::StackFrame* calling_frame = frame_iterator.frame();
  86   CHECK(calling_frame->is_java_script());
  87
  88 #if defined(V8_HOST_ARCH_32_BIT)
  89   int32_t low_bits = reinterpret_cast<int32_t>(calling_frame->fp());
  90   args.This()->Set(v8_str("low_bits"), v8_num(low_bits >> 1));
  91 #elif defined(V8_HOST_ARCH_64_BIT)
  92   uint64_t fp = reinterpret_cast<uint64_t>(calling_frame->fp());
  93   int32_t low_bits = static_cast<int32_t>(fp & 0xffffffff);
  94   int32_t high_bits = static_cast<int32_t>(fp >> 32);
  95   args.This()->Set(v8_str("low_bits"), v8_num(low_bits));
  96   args.This()->Set(v8_str("high_bits"), v8_num(high_bits));
  97 #else
  98 #error Host architecture is neither 32-bit nor 64-bit.
  99 #endif
 100   args.GetReturnValue().Set(args.This());
 101 }
 102
 103
 104 // Use the API to create a JSFunction object that calls the above C++ function.
 105 void CreateFramePointerGrabberConstructor(v8::Local<v8::Context> context,
 106                                           const char* constructor_name) {
 107     Local<v8::FunctionTemplate> constructor_template =
 108         v8::FunctionTemplate::New(context->GetIsolate(), construct_call);
 109     constructor_template->SetClassName(v8_str("FPGrabber"));
 110     Local<Function> fun = constructor_template->GetFunction();
 111     context->Global()->Set(v8_str(constructor_name), fun);
 112 }
 113
 114
 115 // Creates a global function named 'func_name' that calls the tracing
 116 // function 'trace_func_name' with an actual EBP register value,
 117 // encoded as one or two Smis.
 118 static void CreateTraceCallerFunction(v8::Local<v8::Context> context,
 119                                       const char* func_name,
 120                                       const char* trace_func_name) {
 121   i::EmbeddedVector<char, 256> trace_call_buf;
 122   i::SNPrintF(trace_call_buf,
 123               "function %s() {"
 124               "  fp = new FPGrabber();"
 125               "  %s(fp.low_bits, fp.high_bits);"
 126               "}",
 127               func_name, trace_func_name);
 128
 129   // Create the FPGrabber function, which grabs the caller's frame pointer
 130   // when called as a constructor.
 131   CreateFramePointerGrabberConstructor(context, "FPGrabber");
 132
 133   // Compile the script.
 134   CompileRun(trace_call_buf.start());
 135 }
 136
 137
 138 // This test verifies that stack tracing works when called during
 139 // execution of a native function called from JS code. In this case,
 140 // TickSample::Trace uses Isolate::c_entry_fp as a starting point for stack
 141 // walking.
 142 TEST(CFromJSStackTrace) {
 143   // BUG(1303) Inlining of JSFuncDoTrace() in JSTrace below breaks this test.
 144   i::FLAG_use_inlining = false;
 145
 146   TickSample sample;
 147   i::TraceExtension::InitTraceEnv(&sample);
 148
 149   v8::HandleScope scope(CcTest::isolate());
 150   v8::Local<v8::Context> context = CcTest::NewContext(TRACE_EXTENSION);
 151   v8::Context::Scope context_scope(context);
 152
 153   // Create global function JSFuncDoTrace which calls
 154   // extension function trace() with the current frame pointer value.
 155   CreateTraceCallerFunction(context, "JSFuncDoTrace", "trace");
 156   Local<Value> result = CompileRun(
 157       "function JSTrace() {"
 158       "         JSFuncDoTrace();"
 159       "};\n"
 160       "JSTrace();\n"
 161       "true;");
 162   CHECK(!result.IsEmpty());
 163   // When stack tracer is invoked, the stack should look as follows:
 164   // script [JS]
 165   //   JSTrace() [JS]
 166   //     JSFuncDoTrace() [JS] [captures EBP value and encodes it as Smi]
 167   //       trace(EBP) [native (extension)]
 168   //         DoTrace(EBP) [native]
 169   //           TickSample::Trace
 170
 171   CHECK(sample.has_external_callback);
 172   CHECK_EQ(FUNCTION_ADDR(i::TraceExtension::Trace), sample.external_callback);
 173
 174   // Stack tracing will start from the first JS function, i.e. "JSFuncDoTrace"
 175   unsigned base = 0;
 176   CHECK_GT(sample.frames_count, base + 1);
 177
 178   CHECK(IsAddressWithinFuncCode(
 179       context, "JSFuncDoTrace", sample.stack[base + 0]));
 180   CHECK(IsAddressWithinFuncCode(context, "JSTrace", sample.stack[base + 1]));
 181 }
 182
 183
 184 // This test verifies that stack tracing works when called during
 185 // execution of JS code. However, as calling TickSample::Trace requires
 186 // entering native code, we can only emulate pure JS by erasing
 187 // Isolate::c_entry_fp value. In this case, TickSample::Trace uses passed frame
 188 // pointer value as a starting point for stack walking.
 189 TEST(PureJSStackTrace) {
 190   // This test does not pass with inlining enabled since inlined functions
 191   // don't appear in the stack trace.
 192   i::FLAG_use_inlining = false;
 193
 194   TickSample sample;
 195   i::TraceExtension::InitTraceEnv(&sample);
 196
 197   v8::HandleScope scope(CcTest::isolate());
 198   v8::Local<v8::Context> context = CcTest::NewContext(TRACE_EXTENSION);
 199   v8::Context::Scope context_scope(context);
 200
 201   // Create global function JSFuncDoTrace which calls
 202   // extension function js_trace() with the current frame pointer value.
 203   CreateTraceCallerFunction(context, "JSFuncDoTrace", "js_trace");
 204   Local<Value> result = CompileRun(
 205       "function JSTrace() {"
 206       "         JSFuncDoTrace();"
 207       "};\n"
 208       "function OuterJSTrace() {"
 209       "         JSTrace();"
 210       "};\n"
 211       "OuterJSTrace();\n"
 212       "true;");
 213   CHECK(!result.IsEmpty());
 214   // When stack tracer is invoked, the stack should look as follows:
 215   // script [JS]
 216   //   OuterJSTrace() [JS]
 217   //     JSTrace() [JS]
 218   //       JSFuncDoTrace() [JS]
 219   //         js_trace(EBP) [native (extension)]
 220   //           DoTraceHideCEntryFPAddress(EBP) [native]
 221   //             TickSample::Trace
 222   //
 223
 224   CHECK(sample.has_external_callback);
 225   CHECK_EQ(FUNCTION_ADDR(i::TraceExtension::JSTrace), sample.external_callback);
 226
 227   // Stack sampling will start from the caller of JSFuncDoTrace, i.e. "JSTrace"
 228   unsigned base = 0;
 229   CHECK_GT(sample.frames_count, base + 1);
 230   CHECK(IsAddressWithinFuncCode(context, "JSTrace", sample.stack[base + 0]));
 231   CHECK(IsAddressWithinFuncCode(
 232       context, "OuterJSTrace", sample.stack[base + 1]));
 233 }
 234
 235
 236 static void CFuncDoTrace(byte dummy_parameter) {
 237   Address fp;
 238 #ifdef __GNUC__
 239   fp = reinterpret_cast<Address>(__builtin_frame_address(0));
 240 #elif defined _MSC_VER
 241   // Approximate a frame pointer address. We compile without base pointers,
 242   // so we can't trust ebp/rbp.
 243   fp = &dummy_parameter - 2 * sizeof(void*);  // NOLINT
 244 #else
 245 #error Unexpected platform.
 246 #endif
 247   i::TraceExtension::DoTrace(fp);
 248 }
 249
 250
 251 static int CFunc(int depth) {
 252   if (depth <= 0) {
 253     CFuncDoTrace(0);
 254     return 0;
 255   } else {
 256     return CFunc(depth - 1) + 1;
 257   }
 258 }
 259
 260
 261 // This test verifies that stack tracing doesn't crash when called on
 262 // pure native code. TickSample::Trace only unrolls JS code, so we can't
 263 // get any meaningful info here.
 264 TEST(PureCStackTrace) {
 265   TickSample sample;
 266   i::TraceExtension::InitTraceEnv(&sample);
 267   v8::HandleScope scope(CcTest::isolate());
 268   v8::Local<v8::Context> context = CcTest::NewContext(TRACE_EXTENSION);
 269   v8::Context::Scope context_scope(context);
 270   // Check that sampler doesn't crash
 271   CHECK_EQ(10, CFunc(10));
 272 }
 273
 274
 275 TEST(JsEntrySp) {
 276   v8::HandleScope scope(CcTest::isolate());
 277   v8::Local<v8::Context> context = CcTest::NewContext(TRACE_EXTENSION);
 278   v8::Context::Scope context_scope(context);
 279   CHECK_EQ(0, i::TraceExtension::GetJsEntrySp());
 280   CompileRun("a = 1; b = a + 1;");
 281   CHECK_EQ(0, i::TraceExtension::GetJsEntrySp());
 282   CompileRun("js_entry_sp();");
 283   CHECK_EQ(0, i::TraceExtension::GetJsEntrySp());
 284   CompileRun("js_entry_sp_level2();");
 285   CHECK_EQ(0, i::TraceExtension::GetJsEntrySp());
 286 }