[vm, bytecode] Plumb bytecode mode flags to VM unit tests.

 - Make tests using eval fail instead of timing out.
 - Collect allocation stats in the interpreter.
 - And various EnsureDeclarationLoaded.

Change-Id: I17377216cd6dde2615b205f1b28071e12e50e252
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/107442
Reviewed-by: Alexander Markov <[email protected]>
Reviewed-by: Régis Crelier <[email protected]>
Commit-Queue: Ryan Macnak <[email protected]>

Author: rmacnak-google

pkg/test_runner/lib/src/test_suite.dart

@@ -370,6 +370,7 @@ class VMTestSuite extends TestSuite {
       var dfePath = Path(filename).absolute.toNativePath();
       // '--dfe' has to be the first argument for run_vm_test to pick it up.
       args.insert(0, '--dfe=$dfePath');
+      args.addAll(configuration.vmOptions);
     }
     if (expectations.contains(Expectation.crash)) {
       args.insert(0, '--suppress-core-dump');

pkg/vm/bin/kernel_service.dart

@@ -534,7 +534,12 @@ Future _processLoadRequest(request) async {
     assert(incremental,
         "Incremental compiler required for use of 'kUpdateSourcesTag'");
     compiler = lookupIncrementalCompiler(isolateId);
-    assert(compiler != null);
+    if (compiler == null) {
+      port.send(new CompilationResult.errors(
+              ["No incremental compiler available for this isolate."], null)
+          .toResponse());
+      return;
+    }
     updateSources(compiler, sourceFiles);
     port.send(new CompilationResult.ok(null).toResponse());
     return;

runtime/tests/vm/vm.status

@@ -35,7 +35,7 @@ dart/snapshot_version_test: RuntimeError
 dart/entrypoints/aot/*: SkipByDesign
 
 [ $compiler == dartkb ]
-cc/*: Skip # Bytecode modes are not properly hooked up in run_vm_tests.
+cc/*: Skip # Too many timeouts and crashes for infrastructure to handle.
 
 [ $compiler == dartkp ]
 dart/v8_snapshot_profile_writer_test: Pass, Slow # Can be slow due to re-invoking the precompiler.

runtime/vm/compiler/backend/il_test_helper.cc

@@ -45,6 +45,10 @@ RawFunction* GetFunction(const Library& lib, const char* name) {
 }
 
 void Invoke(const Library& lib, const char* name) {
+  // These tests rely on running unoptimized code to collect type feedback. The
+  // interpreter does not collect type feedback for interface calls.
+  SetFlagScope<bool> sfs(&FLAG_enable_interpreter, false);
+
   Thread* thread = Thread::Current();
   Dart_Handle api_lib = Api::NewHandle(thread, lib.raw());
   TransitionVMToNative transition(thread);

runtime/vm/compiler/backend/loops_test.cc

@@ -307,7 +307,7 @@ ISOLATE_UNIT_TEST_CASE(WrapAroundAndDerived) {
       "  WRAP(-99, LIN(0 + -1 * i))\n"  // d
       "  LIN(1 + 1 * i)\n"              // add
       "  ]\n";
-  EXPECT_STREQ(ComputeInduction(thread, script_chars), expected);
+  EXPECT_STREQ(expected, ComputeInduction(thread, script_chars));
 }
 
 ISOLATE_UNIT_TEST_CASE(PeriodicAndDerived) {
@@ -342,7 +342,7 @@ ISOLATE_UNIT_TEST_CASE(PeriodicAndDerived) {
       "  PERIOD(95, 5)\n"       // p2
       "  LIN(1 + 1 * i)\n"      // add
       "  ]\n";
-  EXPECT_STREQ(ComputeInduction(thread, script_chars), expected);
+  EXPECT_STREQ(expected, ComputeInduction(thread, script_chars));
 }
 
 //

runtime/vm/dart_api_impl.cc

@@ -5106,6 +5106,7 @@ DART_EXPORT Dart_Handle Dart_GetClass(Dart_Handle library,
     return Api::NewError("Class '%s' not found in library '%s'.",
                          cls_name.ToCString(), lib_name.ToCString());
   }
+  cls.EnsureDeclarationLoaded();
   CHECK_ERROR_HANDLE(cls.VerifyEntryPoint());
   return Api::NewHandle(T, cls.RareType());
 }

runtime/vm/interpreter.cc

@@ -1355,6 +1355,8 @@ DART_NOINLINE bool Interpreter::AllocateMint(Thread* thread,
   const uword start = thread->top();
   if (LIKELY((start + instance_size) < thread->end())) {
     thread->set_top(start + instance_size);
+    NOT_IN_PRODUCT(thread->isolate()->class_table()->UpdateAllocatedNew(
+        kMintCid, instance_size));
     RawMint* result =
         Mint::RawCast(InitializeHeader(start, kMintCid, instance_size));
     result->ptr()->value_ = value;
@@ -1385,6 +1387,8 @@ DART_NOINLINE bool Interpreter::AllocateDouble(Thread* thread,
   const uword start = thread->top();
   if (LIKELY((start + instance_size) < thread->end())) {
     thread->set_top(start + instance_size);
+    NOT_IN_PRODUCT(thread->isolate()->class_table()->UpdateAllocatedNew(
+        kDoubleCid, instance_size));
     RawDouble* result =
         Double::RawCast(InitializeHeader(start, kDoubleCid, instance_size));
     result->ptr()->value_ = value;
@@ -1415,6 +1419,8 @@ DART_NOINLINE bool Interpreter::AllocateFloat32x4(Thread* thread,
   const uword start = thread->top();
   if (LIKELY((start + instance_size) < thread->end())) {
     thread->set_top(start + instance_size);
+    NOT_IN_PRODUCT(thread->isolate()->class_table()->UpdateAllocatedNew(
+        kFloat32x4Cid, instance_size));
     RawFloat32x4* result = Float32x4::RawCast(
         InitializeHeader(start, kFloat32x4Cid, instance_size));
     value.writeTo(result->ptr()->value_);
@@ -1445,6 +1451,8 @@ DART_NOINLINE bool Interpreter::AllocateFloat64x2(Thread* thread,
   const uword start = thread->top();
   if (LIKELY((start + instance_size) < thread->end())) {
     thread->set_top(start + instance_size);
+    NOT_IN_PRODUCT(thread->isolate()->class_table()->UpdateAllocatedNew(
+        kFloat64x2Cid, instance_size));
     RawFloat64x2* result = Float64x2::RawCast(
         InitializeHeader(start, kFloat64x2Cid, instance_size));
     value.writeTo(result->ptr()->value_);
@@ -1479,6 +1487,8 @@ bool Interpreter::AllocateArray(Thread* thread,
       const uword start = thread->top();
       if (LIKELY((start + instance_size) < thread->end())) {
         thread->set_top(start + instance_size);
+        NOT_IN_PRODUCT(thread->isolate()->class_table()->UpdateAllocatedNew(
+            kArrayCid, instance_size));
         RawArray* result =
             Array::RawCast(InitializeHeader(start, kArrayCid, instance_size));
         result->ptr()->type_arguments_ = type_args;
@@ -1512,6 +1522,8 @@ bool Interpreter::AllocateContext(Thread* thread,
   const uword start = thread->top();
   if (LIKELY((start + instance_size) < thread->end())) {
     thread->set_top(start + instance_size);
+    NOT_IN_PRODUCT(thread->isolate()->class_table()->UpdateAllocatedNew(
+        kContextCid, instance_size));
     RawContext* result =
         Context::RawCast(InitializeHeader(start, kContextCid, instance_size));
     result->ptr()->num_variables_ = num_context_variables;
@@ -1542,6 +1554,8 @@ bool Interpreter::AllocateClosure(Thread* thread,
   const uword start = thread->top();
   if (LIKELY((start + instance_size) < thread->end())) {
     thread->set_top(start + instance_size);
+    NOT_IN_PRODUCT(thread->isolate()->class_table()->UpdateAllocatedNew(
+        kClosureCid, instance_size));
     RawClosure* result =
         Closure::RawCast(InitializeHeader(start, kClosureCid, instance_size));
     RawObject* null_value = Object::null();
@@ -2481,6 +2495,8 @@ RawObject* Interpreter::Call(RawFunction* function,
       const uword start = thread->top();
       if (LIKELY((start + instance_size) < thread->end())) {
         thread->set_top(start + instance_size);
+        NOT_IN_PRODUCT(thread->isolate()->class_table()->UpdateAllocatedNew(
+            class_id, instance_size));
         RawObject* result = InitializeHeader(start, class_id, instance_size);
         for (intptr_t offset = sizeof(RawInstance); offset < instance_size;
              offset += kWordSize) {
@@ -2512,6 +2528,8 @@ RawObject* Interpreter::Call(RawFunction* function,
       const uword start = thread->top();
       if (LIKELY((start + instance_size) < thread->end())) {
         thread->set_top(start + instance_size);
+        NOT_IN_PRODUCT(thread->isolate()->class_table()->UpdateAllocatedNew(
+            class_id, instance_size));
         RawObject* result = InitializeHeader(start, class_id, instance_size);
         for (intptr_t offset = sizeof(RawInstance); offset < instance_size;
              offset += kWordSize) {

runtime/vm/object.cc

@@ -2276,6 +2276,7 @@ bool Class::IsInFullSnapshot() const {
 }
 
 RawAbstractType* Class::RareType() const {
+  ASSERT(is_declaration_loaded());
   const Type& type = Type::Handle(Type::New(
       *this, Object::null_type_arguments(), TokenPosition::kNoSource));
   return ClassFinalizer::FinalizeType(*this, type);
@@ -4152,6 +4153,7 @@ void Class::set_declaration_type(const Type& value) const {
 }
 
 RawType* Class::DeclarationType() const {
+  ASSERT(is_declaration_loaded());
   if (declaration_type() != Type::null()) {
     return declaration_type();
   }

runtime/vm/source_report.cc

@@ -569,6 +569,7 @@ void SourceReport::VisitLibrary(JSONArray* jsarr, const Library& lib) {
         }
         ASSERT(cls.is_finalized());
       } else {
+        cls.EnsureDeclarationLoaded();
         // Emit one range for the whole uncompiled class.
         JSONObject range(jsarr);
         script = cls.script();

runtime/vm/stack_frame_test.cc

@@ -48,7 +48,7 @@ void FUNCTION_NAME(StackFrame_equals)(Dart_NativeArguments args) {
   if (!expected.OperatorEquals(actual)) {
     OS::PrintErr("expected: '%s' actual: '%s'\n", expected.ToCString(),
                  actual.ToCString());
-    FATAL("Expect_equals fails.\n");
+    EXPECT(false);
   }
 }