DBC: Collect type feedback for fastpath smi ops

runtime/vm/assembler_dbc_test.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_DBC)
 
 #include "vm/assembler.h"
 #include "vm/stack_frame.h"
 #include "vm/unit_test.h"
@@ skipping 14 matching lines @@
 #define EXECUTE_TEST_CODE_INTPTR(code)                                         \
     Smi::Value(Smi::RawCast(ExecuteTest(code)))
 #define EXECUTE_TEST_CODE_BOOL(code)                                           \
     (Bool::RawCast(ExecuteTest(code)) == Bool::True().raw())
 #define EXECUTE_TEST_CODE_OBJECT(code)                                         \
     Object::Handle(ExecuteTest(code))
 
 #define __ assembler->
 
 
+static RawClass* CreateDummyClass(const String& class_name,
+                                  const Script& script) {
+  const Class& cls = Class::Handle(Class::New(
+      Library::Handle(), class_name, script, TokenPosition::kNoSource));
+  cls.set_is_synthesized_class();  // Dummy class for testing.
+  return cls.raw();
+}
+
+
+static RawLibrary* CreateDummyLibrary(const String& library_name) {
+  return Library::New(library_name);
+}
+
+
+static RawFunction* CreateFunction(const char* name) {
+  Thread* thread = Thread::Current();
+  const String& class_name = String::Handle(Symbols::New(thread, "ownerClass"));
+  const String& lib_name = String::Handle(Symbols::New(thread, "ownerLibrary"));
+  const Script& script = Script::Handle();
+  const Class& owner_class =
+      Class::Handle(CreateDummyClass(class_name, script));
+  const Library& owner_library =
+      Library::Handle(CreateDummyLibrary(lib_name));
+  owner_class.set_library(owner_library);
+  const String& function_name = String::ZoneHandle(Symbols::New(thread, name));
+  return Function::New(function_name, RawFunction::kRegularFunction,
+                       true, false, false, false, false, owner_class,
+                       TokenPosition::kMinSource);
+}
+
+
+static void GenerateDummyCode(Assembler* assembler, const Object& result) {
+  __ PushConstant(result);
+  __ ReturnTOS();
+}
+
+
+static void MakeDummyInstanceCall(Assembler* assembler, const Object& result) {
+  // Make a dummy function.
+  Assembler _assembler_;
+  GenerateDummyCode(&_assembler_, result);
+  const char* dummy_function_name = "dummy_instance_function";
+  const Function& dummy_instance_function =
+      Function::Handle(CreateFunction(dummy_function_name));
+  Code& code =
+      Code::Handle(Code::FinalizeCode(dummy_instance_function, &_assembler_));
+  dummy_instance_function.AttachCode(code);
+
+  // Make a dummy ICData.
+  const Array& dummy_arguments_descriptor =
+      Array::Handle(ArgumentsDescriptor::New(2));
+  const ICData& ic_data = ICData::Handle(ICData::New(
+      dummy_instance_function,
+      String::Handle(dummy_instance_function.name()),
+      dummy_arguments_descriptor,
+      Thread::kNoDeoptId,
+      2));
+
+  // Wire up the Function in the ICData.
+  GrowableArray<intptr_t> cids(2);
+  cids.Add(kSmiCid);
+  cids.Add(kSmiCid);
+  ic_data.AddCheck(cids, dummy_instance_function);
+
+  // For the non-Smi tests.
+  cids[0] = kBigintCid;
+  ic_data.AddCheck(cids, dummy_instance_function);
+  ICData* call_ic_data = &ICData::ZoneHandle(ic_data.Original());
+
+  // Generate the instance call.
+  const intptr_t call_ic_data_kidx = __ AddConstant(*call_ic_data);
+  __ InstanceCall2(2, call_ic_data_kidx);
+}
+
+
 ASSEMBLER_TEST_GENERATE(Simple, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(Simple, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
@@ skipping 14 matching lines @@
 //    GreaterThanTOS;
 //
 //    Smi fast-path for a corresponding method. Checks if SP[0] and SP[-1] are
 //    both smis and result of SP[0] <op> SP[-1] is a smi - if this is true
 //    then pops operands and pushes result on the stack and skips the next
 //    instruction (which implements a slow path fallback).
 ASSEMBLER_TEST_GENERATE(AddTOS, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(-42)));
   __ PushConstant(Smi::Handle(Smi::New(84)));
   __ AddTOS();
-  __ PushConstant(Smi::Handle(Smi::New(0)));  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(0)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(AddTOS, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(AddTOSOverflow, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(Smi::kMaxValue)));
   __ PushConstant(Smi::Handle(Smi::New(1)));
   __ AddTOS();
-  __ PushConstant(Smi::Handle(Smi::New(42)));  // Shouldn't be skipped.
+  // Shouldn't be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(42)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(AddTOSOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(AddTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
   __ PushConstant(Integer::Handle(Integer::New(numstr, Heap::kOld)));
   __ PushConstant(Smi::Handle(Smi::New(1)));
   __ AddTOS();
-  __ PushConstant(Smi::Handle(Smi::New(42)));  // Shouldn't be skipped.
+  // Shouldn't be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(42)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(AddTOSNonSmi, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(SubTOS, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(30)));
   __ PushConstant(Smi::Handle(Smi::New(-12)));
   __ SubTOS();
-  __ PushConstant(Smi::Handle(Smi::New(0)));  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(0)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(SubTOS, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(SubTOSOverflow, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(Smi::kMinValue)));
   __ PushConstant(Smi::Handle(Smi::New(1)));
   __ SubTOS();
-  __ PushConstant(Smi::Handle(Smi::New(42)));  // Shouldn't be skipped.
+  // Shouldn't be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(42)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(SubTOSOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(SubTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
   __ PushConstant(Integer::Handle(Integer::New(numstr, Heap::kOld)));
   __ PushConstant(Smi::Handle(Smi::New(1)));
   __ SubTOS();
-  __ PushConstant(Smi::Handle(Smi::New(42)));  // Shouldn't be skipped.
+  // Shouldn't be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(42)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(SubTOSNonSmi, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(MulTOS, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(-6)));
   __ PushConstant(Smi::Handle(Smi::New(-7)));
   __ MulTOS();
-  __ PushConstant(Smi::Handle(Smi::New(0)));  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(0)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(MulTOS, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(MulTOSOverflow, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(Smi::kMaxValue)));
   __ PushConstant(Smi::Handle(Smi::New(-8)));
   __ MulTOS();
-  __ PushConstant(Smi::Handle(Smi::New(42)));  // Shouldn't be skipped.
+  // Shouldn't be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(42)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(MulTOSOverflow, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(MulTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
   __ PushConstant(Integer::Handle(Integer::New(numstr, Heap::kOld)));
   __ PushConstant(Smi::Handle(Smi::New(1)));
   __ MulTOS();
-  __ PushConstant(Smi::Handle(Smi::New(42)));  // Shouldn't be skipped.
+  // Shouldn't be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(42)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(MulTOSNonSmi, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(BitOrTOS, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(0x22)));
   __ PushConstant(Smi::Handle(Smi::New(0x08)));
   __ BitOrTOS();
-  __ PushConstant(Smi::Handle(Smi::New(0)));  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(0)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(BitOrTOS, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(BitOrTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
   __ PushConstant(Integer::Handle(Integer::New(numstr, Heap::kOld)));
   __ PushConstant(Smi::Handle(Smi::New(0x08)));
   __ BitOrTOS();
-  __ PushConstant(Smi::Handle(Smi::New(42)));  // Shouldn't be skipped.
+  // Shouldn't be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(42)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(BitOrTOSNonSmi, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(BitAndTOS, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(0x2a)));
   __ PushConstant(Smi::Handle(Smi::New(0xaa)));
   __ BitAndTOS();
-  __ PushConstant(Smi::Handle(Smi::New(0)));  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(0)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(BitAndTOS, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(BitAndTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
   __ PushConstant(Integer::Handle(Integer::New(numstr, Heap::kOld)));
   __ PushConstant(Smi::Handle(Smi::New(0x08)));
   __ BitAndTOS();
-  __ PushConstant(Smi::Handle(Smi::New(42)));  // Shouldn't be skipped.
+  // Shouldn't be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(42)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(BitAndTOSNonSmi, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(EqualTOSTrue, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ EqualTOS();
-  __ PushConstant(Bool::False());  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Bool::False());
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(EqualTOSTrue, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(EqualTOSFalse, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ PushConstant(Smi::Handle(Smi::New(-42)));
   __ EqualTOS();
-  __ PushConstant(Bool::True());  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Bool::True());
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(EqualTOSFalse, test) {
   EXPECT(!EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(EqualTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
   __ PushConstant(Integer::Handle(Integer::New(numstr, Heap::kOld)));
   __ PushConstant(Smi::Handle(Smi::New(-42)));
   __ EqualTOS();
-  __ PushConstant(Bool::True());  // Shouldn't be skipped.
+  // Shouldn't be skipped.
+  MakeDummyInstanceCall(assembler, Bool::True());
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(EqualTOSNonSmi, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LessThanTOSTrue, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(-42)));
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ LessThanTOS();
-  __ PushConstant(Bool::False());  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Bool::False());
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(LessThanTOSTrue, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LessThanTOSFalse, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ PushConstant(Smi::Handle(Smi::New(-42)));
   __ LessThanTOS();
-  __ PushConstant(Bool::False());  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Bool::False());
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(LessThanTOSFalse, test) {
   EXPECT(!EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LessThanTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
   __ PushConstant(Integer::Handle(Integer::New(numstr, Heap::kOld)));
   __ PushConstant(Smi::Handle(Smi::New(-42)));
   __ LessThanTOS();
-  __ PushConstant(Bool::True());  // Shouldn't be skipped.
+  // Shouldn't be skipped.
+  MakeDummyInstanceCall(assembler, Bool::True());
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(LessThanTOSNonSmi, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(GreaterThanTOSTrue, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ PushConstant(Smi::Handle(Smi::New(-42)));
   __ GreaterThanTOS();
-  __ PushConstant(Bool::False());  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Bool::False());
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(GreaterThanTOSTrue, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(GreaterThanTOSFalse, assembler) {
   __ PushConstant(Smi::Handle(Smi::New(-42)));
   __ PushConstant(Smi::Handle(Smi::New(42)));
   __ GreaterThanTOS();
-  __ PushConstant(Bool::False());  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Bool::False());
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(GreaterThanTOSFalse, test) {
   EXPECT(!EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(GreaterThanTOSNonSmi, assembler) {
   const String& numstr =
       String::Handle(String::New("98765432198765432100", Heap::kOld));
   __ PushConstant(Integer::Handle(Integer::New(numstr, Heap::kOld)));
   __ PushConstant(Smi::Handle(Smi::New(-42)));
   __ GreaterThanTOS();
-  __ PushConstant(Bool::True());  // Shouldn't be skipped.
+  // Shouldn't be skipped.
+  MakeDummyInstanceCall(assembler, Bool::True());
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(GreaterThanTOSNonSmi, test) {
   EXPECT(EXECUTE_TEST_CODE_BOOL(test->code()));
 }
 
 
 //  - IfNeStrictTOS; IfEqStrictTOS; IfNeStrictNumTOS; IfEqStrictNumTOS
@@ skipping 380 matching lines @@
   __ PushConstant(Smi::Handle(Smi::New(37)));
   __ PushConstant(Smi::Handle(Smi::New(37)));
   __ PushConstant(Smi::Handle(Smi::New(37)));
   __ PushConstant(Smi::Handle(Smi::New(37)));
   __ PushConstant(Smi::Handle(Smi::New(37)));
   __ PushConstant(Smi::Handle(Smi::New(37)));
   __ PushConstant(Smi::Handle(Smi::New(37)));
   __ PushConstant(Smi::Handle(Smi::New(41)));
   __ DropR(11);
   __ AddTOS();
-  __ PushConstant(Smi::Handle(Smi::New(0)));  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(0)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(DropR, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 //  - Frame D
@@ skipping 42 matching lines @@
 
 //  - StoreLocal rX; PopLocal rX
 //
 //    Store top of the stack into FP[rX] and pop it if needed.
 //
 //  - Push rX
 //
 //    Push FP[rX] to the stack.
 ASSEMBLER_TEST_GENERATE(StoreLocalPush, assembler) {
   __ Frame(1);
+  __ PushConstant(Smi::Handle(Smi::New(37)));
   __ PushConstant(Smi::Handle(Smi::New(21)));
   __ StoreLocal(0);
   __ Push(0);
   __ AddTOS();
-  __ PushConstant(Smi::Handle(Smi::New(0)));  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(0)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(StoreLocalPush, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(PopLocalPush, assembler) {
   __ Frame(1);
   __ PushConstant(Smi::Handle(Smi::New(21)));
   __ PopLocal(0);
   __ Push(0);
   __ Push(0);
   __ AddTOS();
-  __ PushConstant(Smi::Handle(Smi::New(0)));  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(0)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(PopLocalPush, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 ASSEMBLER_TEST_GENERATE(LoadConstantPush, assembler) {
   __ Frame(1);
   __ LoadConstant(0, Smi::Handle(Smi::New(21)));
   __ Push(0);
   __ Push(0);
   __ AddTOS();
-  __ PushConstant(Smi::Handle(Smi::New(0)));  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(0)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(LoadConstantPush, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 //  - Move rA, rX
 //
 //    FP[rA] <- FP[rX]
 //    Note: rX is signed so it can be used to address parameters which are
 //    at negative indices with respect to FP.
 ASSEMBLER_TEST_GENERATE(MoveLocalLocal, assembler) {
   __ Frame(2);
   __ PushConstant(Smi::Handle(Smi::New(21)));
   __ PopLocal(0);
   __ Move(1, 0);
   __ Push(0);
   __ Push(1);
   __ AddTOS();
-  __ PushConstant(Smi::Handle(Smi::New(0)));  // Should be skipped.
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(0)));
   __ ReturnTOS();
 }
 
 
 ASSEMBLER_TEST_RUN(MoveLocalLocal, test) {
   EXPECT_EQ(42, EXECUTE_TEST_CODE_INTPTR(test->code()));
 }
 
 
 //  - Return R; ReturnTOS
@@ skipping 30 matching lines @@
   __ Frame(2);
   __ LoadConstant(0, Smi::Handle(Smi::New(42)));
   __ LoadConstant(1, Smi::Handle(Smi::New(0)));
 
   Label loop_entry, error;
   __ Bind(&loop_entry);
   // Add 1 to FP[1].
   __ PushConstant(Smi::Handle(Smi::New(1)));
   __ Push(1);
   __ AddTOS();
-  __ Jump(&error);
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(-1)));
   __ PopLocal(1);
 
   // Subtract 1 from FP[0].
   __ Push(0);
   __ PushConstant(Smi::Handle(Smi::New(1)));
   __ SubTOS();
-  __ Jump(&error);
+  // Should be skipped.
+  MakeDummyInstanceCall(assembler, Smi::Handle(Smi::New(-1)));
 
   // Jump to loop_entry if FP[0] != 0.
   __ StoreLocal(0);
   __ PushConstant(Smi::Handle(Smi::New(0)));
   __ IfNeStrictNumTOS();
   __ Jump(&loop_entry);
 
   __ Return(1);
 
   __ Bind(&error);
@@ skipping 52 matching lines @@
   const Object& obj = EXECUTE_TEST_CODE_OBJECT(test->code());
   EXPECT(obj.IsArray());
   Array& array = Array::Handle();
   array ^= obj.raw();
   EXPECT_EQ(10, array.Length());
 }
 
 }  // namespace dart
 
 #endif  // defined(TARGET_ARCH_DBC)