VM: Refactor assembler test that rely on the constant pool.

runtime/vm/unit_test.h

 // Copyright (c) 2011, 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.
 
 #ifndef VM_UNIT_TEST_H_
 #define VM_UNIT_TEST_H_
 
 #include "include/dart_native_api.h"
 
 #include "platform/globals.h"
@@ skipping 303 matching lines @@
   }
   Isolate* isolate() const { return isolate_; }
 
  private:
   Isolate* isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(TestIsolateScope);
 };
 
 
+template<typename T> struct is_void {
+  static const bool value = false;
+};
+
+
+template<> struct is_void<void> {
+  static const bool value = true;
+};
+
+
+template<typename T> struct is_double {
+  static const bool value = false;
+};
+
+
+template<> struct is_double<double> {
+  static const bool value = true;
+};
+
+
 class AssemblerTest {
  public:
   AssemblerTest(const char* name, Assembler* assembler)
       : name_(name),
         assembler_(assembler),
         code_(Code::ZoneHandle()) {
     ASSERT(name != NULL);
     ASSERT(assembler != NULL);
   }
   ~AssemblerTest() { }
 
   Assembler* assembler() const { return assembler_; }
 
   const Code& code() const { return code_; }
 
   uword entry() const { return entry_; }
+#if defined(USING_SIMULATOR)

[zra, 2015/08/11 19:48:17]

Please add comments here about how to use Invoke() and the restrictions on the
argument/return types.

[Florian Schneider, 2015/08/12 07:30:53]

If you happen to write a test that requires a new return-type which needs
special handling, the compiler will complain.

The point of using templates is that you get a compile-time error when something
is not right. Therefore, I don't see the need for additional comments.

[zra, 2015/08/17 16:35:43]

Template errors from the compiler are hard to read. I'm not sure this is a good
trade-off.

+  template<typename ResultType> ResultType Invoke() {
+    const bool fp_return = is_double<ResultType>::value;
+    COMPILE_ASSERT(!fp_return);
+    const bool fp_args = false;
+    return static_cast<ResultType>(Simulator::Current()->Call(
+        bit_cast<intptr_t, uword>(entry()), 0, 0, 0, 0, fp_return, fp_args));
+  }
+  template<typename ResultType, typename Arg1Type>
+  ResultType Invoke(Arg1Type arg1) {
+    const bool fp_return = is_double<ResultType>::value;
+    COMPILE_ASSERT(!fp_return);
+    const bool fp_args = false;
+    COMPILE_ASSERT(!is_double<Arg1Type>::value);
+    return static_cast<ResultType>(Simulator::Current()->Call(
+        bit_cast<intptr_t, uword>(entry()),
+        reinterpret_cast<intptr_t>(arg1),
+        0, 0, 0, fp_return, fp_args));
+  }
+  template<typename ResultType,
+           typename Arg1Type,
+           typename Arg2Type,
+           typename Arg3Type>
+  ResultType Invoke(Arg1Type arg1, Arg2Type arg2, Arg3Type arg3) {
+    COMPILE_ASSERT(is_void<ResultType>::value);
+    const bool fp_return = false;
+    COMPILE_ASSERT(!is_double<Arg1Type>::value);
+    COMPILE_ASSERT(!is_double<Arg2Type>::value);
+    COMPILE_ASSERT(!is_double<Arg3Type>::value);
+    const bool fp_args = false;
+    return static_cast<ResultType>(Simulator::Current()->Call(
+        bit_cast<intptr_t, uword>(entry()),
+        reinterpret_cast<intptr_t>(arg1),
+        reinterpret_cast<intptr_t>(arg2),
+        reinterpret_cast<intptr_t>(arg3),
+        0, fp_return, fp_args));
+  }
+#else
+  template<typename ResultType> ResultType Invoke() {
+    typedef ResultType (*FunctionType) ();
+    return reinterpret_cast<FunctionType>(entry())();
+  }
+
+  template<typename ResultType, typename Arg1Type>
+  ResultType Invoke(Arg1Type arg1) {
+    typedef ResultType (*FunctionType) (Arg1Type);
+    return reinterpret_cast<FunctionType>(entry())(arg1);
+  }
+
+  template<typename ResultType,
+           typename Arg1Type,
+           typename Arg2Type,
+           typename Arg3Type>
+  ResultType Invoke(Arg1Type arg1, Arg2Type arg2, Arg3Type arg3) {
+    typedef ResultType (*FunctionType) (Arg1Type, Arg2Type, Arg3Type);
+    return reinterpret_cast<FunctionType>(entry())(arg1, arg2, arg3);
+  }
+#endif
 
   // Assemble test and set code_ and entry_.
   void Assemble();
 
  private:
   const char* name_;
   Assembler* assembler_;
   Code& code_;
   uword entry_;
 
@@ skipping 74 matching lines @@
       }                                                                        \
     } else {                                                                   \
       dart::Expect(__FILE__, __LINE__).Fail("expected True, but was '%s'\n",   \
           #handle);                                                            \
     }                                                                          \
   } while (0)
 
 }  // namespace dart
 
 #endif  // VM_UNIT_TEST_H_