Fix determining of JS lower stack bottom used in profiler's JS stack tracer to work with Chromium.

test/cctest/test-log-ia32.cc

 // Copyright 2006-2009 the V8 project authors. All rights reserved.
 //
 // Tests of profiler-related functions from log.h
 
 #ifdef ENABLE_LOGGING_AND_PROFILING
 
 #include <stdlib.h>
 
 #include "v8.h"
 
@@ skipping 19 matching lines @@
 using v8::internal::TickSample;
 using v8::internal::Top;
 
 namespace i = v8::internal;
 
 
 static v8::Persistent<v8::Context> env;
 
 
 static struct {
-  StackTracer* tracer;
   TickSample* sample;
-} trace_env = { NULL, NULL };
+} trace_env = { NULL };
 
 
-static void InitTraceEnv(StackTracer* tracer, TickSample* sample) {
-  trace_env.tracer = tracer;
+static void InitTraceEnv(TickSample* sample) {
   trace_env.sample = sample;
 }
 
 
 static void DoTrace(Address fp) {
   trace_env.sample->fp = reinterpret_cast<uintptr_t>(fp);
   // sp is only used to define stack high bound
   trace_env.sample->sp =
       reinterpret_cast<unsigned int>(trace_env.sample) - 10240;
-  trace_env.tracer->Trace(trace_env.sample);
+  StackTracer::Trace(trace_env.sample);
 }
 
 
 // Hide c_entry_fp to emulate situation when sampling is done while
 // pure JS code is being executed
 static void DoTraceHideCEntryFPAddress(Address fp) {
   v8::internal::Address saved_c_frame_fp = *(Top::c_entry_fp_address());
   CHECK(saved_c_frame_fp);
   *(Top::c_entry_fp_address()) = 0;
   DoTrace(fp);
@@ skipping 25 matching lines @@
 
 // --- T r a c e   E x t e n s i o n ---
 
 class TraceExtension : public v8::Extension {
  public:
   TraceExtension() : v8::Extension("v8/trace", kSource) { }
   virtual v8::Handle<v8::FunctionTemplate> GetNativeFunction(
       v8::Handle<String> name);
   static v8::Handle<v8::Value> Trace(const v8::Arguments& args);
   static v8::Handle<v8::Value> JSTrace(const v8::Arguments& args);
+  static v8::Handle<v8::Value> JSEntrySP(const v8::Arguments& args);
+  static v8::Handle<v8::Value> JSEntrySPLevel2(const v8::Arguments& args);
  private:
   static Address GetFP(const v8::Arguments& args);
   static const char* kSource;
 };
 
 
 const char* TraceExtension::kSource =
     "native function trace();"
-    "native function js_trace();";
-
+    "native function js_trace();"
+    "native function js_entry_sp();"
+    "native function js_entry_sp_level2();";
 
 v8::Handle<v8::FunctionTemplate> TraceExtension::GetNativeFunction(
     v8::Handle<String> name) {
   if (name->Equals(String::New("trace"))) {
     return v8::FunctionTemplate::New(TraceExtension::Trace);
   } else if (name->Equals(String::New("js_trace"))) {
     return v8::FunctionTemplate::New(TraceExtension::JSTrace);
+  } else if (name->Equals(String::New("js_entry_sp"))) {
+    return v8::FunctionTemplate::New(TraceExtension::JSEntrySP);
+  } else if (name->Equals(String::New("js_entry_sp_level2"))) {
+    return v8::FunctionTemplate::New(TraceExtension::JSEntrySPLevel2);
   } else {
     CHECK(false);
     return v8::Handle<v8::FunctionTemplate>();
   }
 }
 
 
 Address TraceExtension::GetFP(const v8::Arguments& args) {
   CHECK_EQ(1, args.Length());
   Address fp = reinterpret_cast<Address>(args[0]->Int32Value() << 2);
   printf("Trace: %p\n", fp);
   return fp;
 }
 
 
 v8::Handle<v8::Value> TraceExtension::Trace(const v8::Arguments& args) {
   DoTrace(GetFP(args));
   return v8::Undefined();
 }
 
 
 v8::Handle<v8::Value> TraceExtension::JSTrace(const v8::Arguments& args) {
   DoTraceHideCEntryFPAddress(GetFP(args));
   return v8::Undefined();
 }
 
 
+static Address GetJsEntrySp() {
+  CHECK_NE(NULL, Top::GetCurrentThread());
+  return Top::js_entry_sp(Top::GetCurrentThread());
+}
+
+
+v8::Handle<v8::Value> TraceExtension::JSEntrySP(const v8::Arguments& args) {
+  CHECK_NE(0, GetJsEntrySp());
+  return v8::Undefined();
+}
+
+
+static void CompileRun(const char* source) {
+  Script::Compile(String::New(source))->Run();
+}
+
+
+v8::Handle<v8::Value> TraceExtension::JSEntrySPLevel2(
+    const v8::Arguments& args) {
+  v8::HandleScope scope;
+  const Address js_entry_sp = GetJsEntrySp();
+  CHECK_NE(0, js_entry_sp);
+  CompileRun("js_entry_sp();");
+  CHECK_EQ(js_entry_sp, GetJsEntrySp());
+  return v8::Undefined();
+}
+
+
 static TraceExtension kTraceExtension;
 v8::DeclareExtension kTraceExtensionDeclaration(&kTraceExtension);
 
 
 static void InitializeVM() {
   if (env.IsEmpty()) {
     v8::HandleScope scope;
     const char* extensions[] = { "v8/trace" };
     v8::ExtensionConfiguration config(1, extensions);
     env = v8::Context::New(&config);
   }
   v8::HandleScope scope;
   env->Enter();
 }
 
 
 static Handle<JSFunction> CompileFunction(const char* source) {
   return v8::Utils::OpenHandle(*Script::Compile(String::New(source)));
 }
 
 
-static void CompileRun(const char* source) {
-  Script::Compile(String::New(source))->Run();
-}
-
-
 static Local<Value> GetGlobalProperty(const char* name) {
   return env->Global()->Get(String::New(name));
 }
 
 
 static Handle<JSFunction> GetGlobalJSFunction(const char* name) {
   Handle<JSFunction> js_func(JSFunction::cast(
                                  *(v8::Utils::OpenHandle(
                                        *GetGlobalProperty(name)))));
   return js_func;
@@ skipping 66 matching lines @@
   CHECK(func_code->IsCode());
   func_code->Print();
 #endif
 
   SetGlobalProperty(func_name, v8::ToApi<Value>(func));
 }
 
 
 TEST(CFromJSStackTrace) {
   TickSample sample;
-  StackTracer tracer(reinterpret_cast<uintptr_t>(&sample));
-  InitTraceEnv(&tracer, &sample);
+  InitTraceEnv(&sample);
 
   InitializeVM();
   v8::HandleScope scope;
   CreateTraceCallerFunction("JSFuncDoTrace", "trace");
   CompileRun(
       "function JSTrace() {"
       "         JSFuncDoTrace();"
       "};\n"
       "JSTrace();");
   CHECK_GT(sample.frames_count, 1);
   // Stack sampling will start from the first JS function, i.e. "JSFuncDoTrace"
   CheckRetAddrIsInJSFunction("JSFuncDoTrace",
                              sample.stack[0]);
   CheckRetAddrIsInJSFunction("JSTrace",
                              sample.stack[1]);
 }
 
 
 TEST(PureJSStackTrace) {
   TickSample sample;
-  StackTracer tracer(reinterpret_cast<uintptr_t>(&sample));
-  InitTraceEnv(&tracer, &sample);
+  InitTraceEnv(&sample);
 
   InitializeVM();
   v8::HandleScope scope;
   CreateTraceCallerFunction("JSFuncDoTrace", "js_trace");
   CompileRun(
       "function JSTrace() {"
       "         JSFuncDoTrace();"
       "};\n"
       "function OuterJSTrace() {"
       "         JSTrace();"
@@ skipping 24 matching lines @@
     CFuncDoTrace();
     return 0;
   } else {
     return CFunc(depth - 1) + 1;
   }
 }
 
 
 TEST(PureCStackTrace) {
   TickSample sample;
-  StackTracer tracer(reinterpret_cast<uintptr_t>(&sample));
-  InitTraceEnv(&tracer, &sample);
+  InitTraceEnv(&sample);
   // Check that sampler doesn't crash
   CHECK_EQ(10, CFunc(10));
 }
 
 
+TEST(JsEntrySp) {
+  InitializeVM();
+  v8::HandleScope scope;
+  CHECK_EQ(0, GetJsEntrySp());
+  CompileRun("a = 1; b = a + 1;");
+  CHECK_EQ(0, GetJsEntrySp());
+  CompileRun("js_entry_sp();");
+  CHECK_EQ(0, GetJsEntrySp());
+  CompileRun("js_entry_sp_level2();");
+  CHECK_EQ(0, GetJsEntrySp());
+}
+
 #endif  // ENABLE_LOGGING_AND_PROFILING