[crankshaft] Replace stub cache harvesting with a bit of type propagation

test/cctest/test-api-fast-accessor-builder.cc

 // Copyright 2015 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.
 
 #include <stdlib.h>
 
 #include "include/v8.h"
 #include "include/v8-experimental.h"
 
 #include "src/api.h"
@@ skipping 94 matching lines @@
   builder->ReturnValue(
       builder->LoadInternalField(builder->GetReceiver(), field_no));
   templ->SetAccessorProperty(v8_str(name),
                              v8::FunctionTemplate::NewWithFastHandler(
                                  isolate, NativePropertyAccessor, builder));
 }
 
 
 // "Fast" accessor that accesses an internal field.
 TEST(FastAccessorWithInternalField) {
+  // Crankshaft support for fast accessors is not implemented; crankshafted
+  // code uses the slow accessor which breaks this test's expectations.
+  v8::internal::FLAG_always_opt = false;
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<v8::ObjectTemplate> foo = v8::ObjectTemplate::New(isolate);
   foo->SetInternalFieldCount(3);
   AddInternalFieldAccessor(isolate, foo, "field0", 0);
   AddInternalFieldAccessor(isolate, foo, "field1", 1);
   AddInternalFieldAccessor(isolate, foo, "field2", 2);
 
@@ skipping 10 matching lines @@
 
   // Access fields.
   ExpectString("field0()", "Hi there!");
   ExpectInt32("field1()", 4321);
   ExpectUndefined("field2()");
 }
 
 
 // "Fast" accessor with control flow via ...OrReturnNull methods.
 TEST(FastAccessorOrReturnNull) {
+  // Crankshaft support for fast accessors is not implemented; crankshafted
+  // code uses the slow accessor which breaks this test's expectations.
+  v8::internal::FLAG_always_opt = false;
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<v8::ObjectTemplate> foo = v8::ObjectTemplate::New(isolate);
   foo->SetInternalFieldCount(2);
   {
     // accessor "nullcheck": Return null if field 0 is non-null object; else 5.
     auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
     auto val = builder->LoadInternalField(builder->GetReceiver(), 0);
@@ skipping 29 matching lines @@
   CompileRun(FN_WARMUP("maskcheck", "return obj.maskcheck"));
   obj->SetAlignedPointerInInternalField(1, reinterpret_cast<void*>(0xf0));
   ExpectInt32("maskcheck()", 42);
   obj->SetAlignedPointerInInternalField(1, reinterpret_cast<void*>(0xfe));
   ExpectNull("maskcheck()");
 }
 
 
 // "Fast" accessor with simple control flow via explicit labels.
 TEST(FastAccessorControlFlowWithLabels) {
+  // Crankshaft support for fast accessors is not implemented; crankshafted
+  // code uses the slow accessor which breaks this test's expectations.
+  v8::internal::FLAG_always_opt = false;
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<v8::ObjectTemplate> foo = v8::ObjectTemplate::New(isolate);
   foo->SetInternalFieldCount(1);
   {
     // accessor isnull: 0 for nullptr, else 1.
     auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
     auto label = builder->MakeLabel();
@@ skipping 15 matching lines @@
   CompileRun(FN_WARMUP("isnull", "return obj.isnull"));
   obj->SetAlignedPointerInInternalField(0, /* anything != nullptr */ isolate);
   ExpectInt32("isnull()", 1);
   obj->SetAlignedPointerInInternalField(0, nullptr);
   ExpectInt32("isnull()", 0);
 }
 
 
 // "Fast" accessor, loading things.
 TEST(FastAccessorLoad) {
+  // Crankshaft support for fast accessors is not implemented; crankshafted
+  // code uses the slow accessor which breaks this test's expectations.
+  v8::internal::FLAG_always_opt = false;
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<v8::ObjectTemplate> foo = v8::ObjectTemplate::New(isolate);
   foo->SetInternalFieldCount(1);
 
   // Internal field 0 is a pointer to a C++ data structure that we wish to load
   // field values from.
   struct {
@@ skipping 59 matching lines @@
 }
 
 void ApiCallbackParam(const v8::FunctionCallbackInfo<v8::Value>& info) {
   CHECK_EQ(1, info.Length());
   CHECK(info[0]->IsNumber());
   info.GetReturnValue().Set(info[0]);
 }
 
 // "Fast" accessor, callback to embedder
 TEST(FastAccessorCallback) {
+  // Crankshaft support for fast accessors is not implemented; crankshafted
+  // code uses the slow accessor which breaks this test's expectations.
+  v8::internal::FLAG_always_opt = false;
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<v8::ObjectTemplate> foo = v8::ObjectTemplate::New(isolate);
   {
     auto builder = v8::experimental::FastAccessorBuilder::New(isolate);
     builder->ReturnValue(
         builder->Call(&ApiCallbackInt, builder->IntegerConstant(999)));
     foo->SetAccessorProperty(v8_str("int"),
@@ skipping 22 matching lines @@
   // Callbacks:
   CompileRun(FN_WARMUP("callbackint", "return obj.int"));
   ExpectInt32("callbackint()", 12345);
 
   CompileRun(FN_WARMUP("callbackstr", "return obj.str"));
   ExpectString("callbackstr()", kApiCallbackStringValue);
 
   CompileRun(FN_WARMUP("callbackparam", "return obj.param"));
   ExpectInt32("callbackparam()", 1000);
 }