Add initial support for inlining.

test/cctest/compiler/function-tester.h

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_CCTEST_COMPILER_FUNCTION_TESTER_H_
 #define V8_CCTEST_COMPILER_FUNCTION_TESTER_H_
 
 #include "src/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/compiler.h"
 #include "src/compiler/pipeline.h"
 #include "src/execution.h"
 #include "src/full-codegen.h"
 #include "src/handles.h"
 #include "src/objects-inl.h"
 #include "src/parser.h"
 #include "src/rewriter.h"
 #include "src/scopes.h"
 
 #define USE_CRANKSHAFT 0
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+static void AssertStackDepth(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::HandleScope scope(args.GetIsolate());
+  v8::Handle<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
+      args.GetIsolate(), 10, v8::StackTrace::kDetailed);
+  CHECK_EQ(args[0]->ToInt32()->Value(), stackTrace->GetFrameCount());
+}
+
 class FunctionTester : public InitializedHandleScope {
  public:
   explicit FunctionTester(const char* source)
-      : isolate(main_isolate()),
-        function((FLAG_allow_natives_syntax = true, NewFunction(source))) {
+      : isolate(main_isolate()), context(0, GetObjectTemplate()) {
+    FLAG_allow_natives_syntax = true;
+    function = NewFunction(source);
     Compile(function);
   }
 
   Isolate* isolate;
   Handle<JSFunction> function;
+  LocalContext context;
 
   Handle<JSFunction> Compile(Handle<JSFunction> function) {
 #if V8_TURBOFAN_TARGET
     CompilationInfoWithZone info(function);
 
     CHECK(Parser::Parse(&info));
     StrictMode strict_mode = info.function()->strict_mode();
     info.SetStrictMode(strict_mode);
     info.SetOptimizing(BailoutId::None(), Handle<Code>(function->code()));
     CHECK(Rewriter::Rewrite(&info));
@@ skipping 16 matching lines @@
     if (FLAG_print_opt_code) {
       CodeTracer::Scope tracing_scope(isolate->GetCodeTracer());
       code->Disassemble("test code", tracing_scope.file());
     }
 #endif
     function->ReplaceCode(*code);
 #endif
     return function;
   }
 
+  Local<ObjectTemplate> GetObjectTemplate() {
+    Local<ObjectTemplate> templ = ObjectTemplate::New(CcTest::isolate());
+    templ->Set(v8_str("AssertStackDepth"),
+               v8::FunctionTemplate::New(CcTest::isolate(), AssertStackDepth));
+    return templ;
+  }
+
   static void EnsureDeoptimizationSupport(CompilationInfo* info) {
     bool should_recompile = !info->shared_info()->has_deoptimization_support();
     if (should_recompile) {
       CompilationInfoWithZone unoptimized(info->shared_info());
       // Note that we use the same AST that we will use for generating the
       // optimized code.
       unoptimized.SetFunction(info->function());
       unoptimized.PrepareForCompilation(info->scope());
       unoptimized.SetContext(info->context());
       if (should_recompile) unoptimized.EnableDeoptimizationSupport();
@@ skipping 102 matching lines @@
 
   Handle<Object> true_value() { return isolate->factory()->true_value(); }
 
   Handle<Object> false_value() { return isolate->factory()->false_value(); }
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_CCTEST_COMPILER_FUNCTION_TESTER_H_