Fix issue 658: update test-log-stack-tracer after r4211.

test/cctest/test-log-stack-tracer.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"
 
 #include "codegen.h"
 #include "log.h"
 #include "top.h"
 #include "cctest.h"
 #include "disassembler.h"
 #include "register-allocator-inl.h"
 
 using v8::Function;
 using v8::Local;
 using v8::Object;
 using v8::Script;
 using v8::String;
 using v8::Value;
 
 using v8::internal::byte;
 using v8::internal::Address;
 using v8::internal::Handle;
 using v8::internal::JSFunction;
-using v8::internal::SharedFunctionInfo;
 using v8::internal::StackTracer;
 using v8::internal::TickSample;
 using v8::internal::Top;
 
 namespace i = v8::internal;
 
 
 static v8::Persistent<v8::Context> env;
 
 
@@ skipping 31 matching lines @@
                                      Address ret_addr,
                                      Address func_start_addr,
                                      unsigned int func_len) {
   printf("CheckRetAddrIsInFunction \"%s\": %p %p %p\n",
          func_name, func_start_addr, ret_addr, func_start_addr + func_len);
   CHECK_GE(ret_addr, func_start_addr);
   CHECK_GE(func_start_addr + func_len, ret_addr);
 }
 
 
-static void CheckRetAddrIsInSharedFunctionInfo(
-    const char* func_name,
-    Address ret_addr,
-    Handle<SharedFunctionInfo> func) {
+static void CheckRetAddrIsInJSFunction(const char* func_name,
+                                       Address ret_addr,
+                                       Handle<JSFunction> func) {
   v8::internal::Code* func_code = func->code();
   CheckRetAddrIsInFunction(
       func_name, ret_addr,
       func_code->instruction_start(),
       func_code->ExecutableSize());
 }
 
 
 // --- T r a c e   E x t e n s i o n ---
 
@@ skipping 90 matching lines @@
     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<SharedFunctionInfo> CompileFunction(const char* source) {
-  Handle<v8::internal::Object> obj =
-      v8::Utils::OpenHandle(*Script::Compile(String::New(source)));
-  Handle<SharedFunctionInfo> shared;
-  if (obj->IsSharedFunctionInfo()) {
-    shared = Handle<SharedFunctionInfo>(SharedFunctionInfo::cast(*obj));
-  } else {
-    shared = Handle<SharedFunctionInfo>(JSFunction::cast(*obj)->shared());
-  }
-  return shared;
+static Handle<JSFunction> CompileFunction(const char* source) {
+  Handle<JSFunction> result(JSFunction::cast(
+      *v8::Utils::OpenHandle(*Script::Compile(String::New(source)))));
+  return result;
 }
 
 
 static Local<Value> GetGlobalProperty(const char* name) {
   return env->Global()->Get(String::New(name));
 }
 
 
-static Handle<SharedFunctionInfo> GetGlobalJSFunction(const char* name) {
-  Handle<SharedFunctionInfo> js_func(
-      SharedFunctionInfo::cast(
-          *(v8::Utils::OpenHandle(*GetGlobalProperty(name)))));
-  return js_func;
+static Handle<JSFunction> GetGlobalJSFunction(const char* name) {
+  Handle<JSFunction> result(JSFunction::cast(
+      *v8::Utils::OpenHandle(*GetGlobalProperty(name))));
+  return result;
 }
 
 
-static void CheckRetAddrIsInSharedFunctionInfo(const char* func_name,
+static void CheckRetAddrIsInJSFunction(const char* func_name,
                                                Address ret_addr) {
-  CheckRetAddrIsInSharedFunctionInfo(func_name,
+  CheckRetAddrIsInJSFunction(func_name,
                                      ret_addr,

[Kasper Lund, 2010/03/23 11:53:28]

Indentation.

[mnaganov (inactive), 2010/03/23 12:39:18]

Done.

                                      GetGlobalJSFunction(func_name));
 }
 
 
 static void SetGlobalProperty(const char* name, Local<Value> value) {
   env->Global()->Set(String::New(name), value);
 }
 
 
 static Handle<v8::internal::String> NewString(const char* s) {
@@ skipping 36 matching lines @@
 // shifted right to be presented as Smi.
 static void CreateTraceCallerFunction(const char* func_name,
                                       const char* trace_func_name) {
   i::EmbeddedVector<char, 256> trace_call_buf;
   i::OS::SNPrintF(trace_call_buf, "%s(%%_GetFramePointer());", trace_func_name);
 
   // Compile the script.
   i::CodeGeneratorPatcher patcher;
   bool allow_natives_syntax = i::FLAG_allow_natives_syntax;
   i::FLAG_allow_natives_syntax = true;
-  Handle<SharedFunctionInfo> func = CompileFunction(trace_call_buf.start());
+  Handle<JSFunction> func = CompileFunction(trace_call_buf.start());
   CHECK(!func.is_null());
   i::FLAG_allow_natives_syntax = allow_natives_syntax;
 
 #ifdef DEBUG
   v8::internal::Code* func_code = func->code();
   CHECK(func_code->IsCode());
   func_code->Print();
 #endif
 
   SetGlobalProperty(func_name, v8::ToApi<Value>(func));
+  CHECK_EQ(*func, *GetGlobalJSFunction(func_name));
 }
 
 
 TEST(CFromJSStackTrace) {
-  // TODO(657): Fixup test after FunctionBoilerplate removal.
-  return;
-
   TickSample sample;
   InitTraceEnv(&sample);
 
   InitializeVM();
   v8::HandleScope scope;
   CreateTraceCallerFunction("JSFuncDoTrace", "trace");
-  CompileRun(
+  CHECK(!CompileRun(

[Kasper Lund, 2010/03/23 11:53:28]

I would create a local handle for the result and do CHECK(!result.IsEmpty())
separately. 

[mnaganov (inactive), 2010/03/23 12:39:18]

Good point. Done.

       "function JSTrace() {"
       "         JSFuncDoTrace();"
       "};\n"
-      "JSTrace();");
+      "JSTrace();\n"
+      "true;").IsEmpty());
   CHECK_GT(sample.frames_count, 1);
   // Stack sampling will start from the first JS function, i.e. "JSFuncDoTrace"
-  CheckRetAddrIsInSharedFunctionInfo("JSFuncDoTrace",
+  CheckRetAddrIsInJSFunction("JSFuncDoTrace",
                                      sample.stack[0]);

[Kasper Lund, 2010/03/23 11:53:28]

Indentation.

[mnaganov (inactive), 2010/03/23 12:39:18]

Done.

-  CheckRetAddrIsInSharedFunctionInfo("JSTrace",
+  CheckRetAddrIsInJSFunction("JSTrace",
                                      sample.stack[1]);

[Kasper Lund, 2010/03/23 11:53:28]

Indentation.

[mnaganov (inactive), 2010/03/23 12:39:18]

Done.

 }
 
 
 TEST(PureJSStackTrace) {
-  // TODO(657): Fixup test after FunctionBoilerplate removal.
-  return;
-
   TickSample sample;
   InitTraceEnv(&sample);
 
   InitializeVM();
   v8::HandleScope scope;
   CreateTraceCallerFunction("JSFuncDoTrace", "js_trace");
-  CompileRun(
+  CHECK(!CompileRun(

[Kasper Lund, 2010/03/23 11:53:28]

I would create a local handle for the result and do CHECK(!result.IsEmpty())
separately. 

[mnaganov (inactive), 2010/03/23 12:39:18]

Done.

       "function JSTrace() {"
       "         JSFuncDoTrace();"
       "};\n"
       "function OuterJSTrace() {"
       "         JSTrace();"
       "};\n"
-      "OuterJSTrace();");
+      "OuterJSTrace();\n"
+      "true;").IsEmpty());
   // The last JS function called.
   CHECK_EQ(GetGlobalJSFunction("JSFuncDoTrace")->address(),
            sample.function);
   CHECK_GT(sample.frames_count, 1);
   // Stack sampling will start from the caller of JSFuncDoTrace, i.e. "JSTrace"
-  CheckRetAddrIsInSharedFunctionInfo("JSTrace",
+  CheckRetAddrIsInJSFunction("JSTrace",
                                      sample.stack[0]);

[Kasper Lund, 2010/03/23 11:53:28]

Indentation.

[mnaganov (inactive), 2010/03/23 12:39:18]

Done.

-  CheckRetAddrIsInSharedFunctionInfo("OuterJSTrace",
+  CheckRetAddrIsInJSFunction("OuterJSTrace",
                                      sample.stack[1]);

[Kasper Lund, 2010/03/23 11:53:28]

Indentation.

[mnaganov (inactive), 2010/03/23 12:39:18]

Done.

 }
 
 
 static void CFuncDoTrace(byte dummy_parameter) {
   Address fp;
 #ifdef __GNUC__
   fp = reinterpret_cast<Address>(__builtin_frame_address(0));
 #elif defined _MSC_VER
   // Approximate a frame pointer address. We compile without base pointers,
   // so we can't trust ebp/rbp.
@@ skipping 29 matching lines @@
   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