Visit the Optimized Code Map on first call rather than closure creation.

test/cctest/heap/test-heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1499 matching lines @@
     CompileRun("%OptimizeFunctionOnNextCall(foo); foo();");
   }
 
   // Simulate one final GC to make sure the candidate queue is sane.
   heap->CollectAllGarbage();
   CHECK(function->shared()->is_compiled() || !function->IsOptimized());
   CHECK(function->is_compiled() || !function->IsOptimized());
 }
 
 TEST(TestUseOfIncrementalBarrierOnCompileLazy) {
+  // This test requires us to run the CompileLazy builtin, which won't be run
+  // when the interpreter is used.
+  if (i::FLAG_ignition) return;

[Michael Starzinger, 2016/04/08 12:44:02]

This should actually only happen because of eager compilation with Ignition. Can
we change this to "i::FLAG_ignition_eager = false" here? If that doesn't work,
then I would vote for marking the test as FAIL for Ignition in the status file,
because I think this is something we would need to investigate then.

[Michael Starzinger, 2016/04/08 12:53:05]

Actually, as discussed offline: This should even work with eager compilation,
because the closure should still be initialized to the CompileLazy builtin, even
if the shared function info is already compiled. So better check if this is
still needed at all. If it is, then we should mark it as FAIL for Ignitition
instead.

[mvstanton, 2016/04/11 13:36:14]

Yes, it still fails with --turbo and --ignition. I created a bug, initially
assigned to me (but I'll give it to you or Ross most likely) and added a TODO in
the status file.

[mvstanton, 2016/04/11 13:36:14]

Acknowledged.

   // Turn off always_opt because it interferes with running the built-in for
   // the last call to g().
   i::FLAG_always_opt = false;
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Heap* heap = isolate->heap();
   v8::HandleScope scope(CcTest::isolate());
 
   CompileRun(
       "function make_closure(x) {"
       "  return function() { return x + 3 };"
       "}"
       "var f = make_closure(5); f();"
       "var g = make_closure(5);");
 
   // Check f is compiled.
   Handle<String> f_name = factory->InternalizeUtf8String("f");
   Handle<Object> f_value =
       Object::GetProperty(isolate->global_object(), f_name).ToHandleChecked();
   Handle<JSFunction> f_function = Handle<JSFunction>::cast(f_value);
   CHECK(f_function->is_compiled());
 
   // Check g is not compiled.
   Handle<String> g_name = factory->InternalizeUtf8String("g");
   Handle<Object> g_value =
       Object::GetProperty(isolate->global_object(), g_name).ToHandleChecked();
   Handle<JSFunction> g_function = Handle<JSFunction>::cast(g_value);
-  // TODO(mvstanton): change to check that g is *not* compiled when optimized
-  // cache
-  // map lookup moves to the compile lazy builtin.
-  CHECK(g_function->is_compiled());
+  CHECK(!g_function->is_compiled());
 
   SimulateIncrementalMarking(heap);
   CompileRun("%OptimizeFunctionOnNextCall(f); f();");
 
   // g should now have available an optimized function, unmarked by gc. The
   // CompileLazy built-in will discover it and install it in the closure, and
   // the incremental write barrier should be used.
   CompileRun("g();");
   CHECK(g_function->is_compiled());
 }
@@ skipping 5038 matching lines @@
       heap->RightTrimFixedArray<Heap::CONCURRENT_TO_SWEEPER>(arrays[j], N - 1);
     }
   }
   // Force allocation from the free list.
   heap->set_force_oom(true);
   heap->CollectGarbage(OLD_SPACE);
 }
 
 }  // namespace internal
 }  // namespace v8