Precompilation/x64: Load float vector constants via Thread.

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 342 matching lines @@
     ASSERT(assembler != NULL);
   }
   ~AssemblerTest() { }
 
   Assembler* assembler() const { return assembler_; }
 
   const Code& code() const { return code_; }
 
   uword entry() const { return code_.EntryPoint(); }
 
-  // Invoke/InvokeWithCode is used to call assembler test functions using the
-  // ABI calling convention.
+  // Invoke/InvokeWithCodeAndThread is used to call assembler test functions
+  // using the ABI calling convention.
   // ResultType is the return type of the assembler test function.
   // ArgNType is the type of the Nth argument.
 #if defined(USING_SIMULATOR)
 
 #if defined(ARCH_IS_64_BIT)
-  // TODO(fschneider): Make InvokeWithCode<> more general and work on 32-bit.
+  // TODO(fschneider): Make InvokeWithCodeAndThread<> more general and work on
+  // 32-bit.
   // Since Simulator::Call always return a int64_t, bit_cast does not work
   // on 32-bit platforms when returning an int32_t. Since template functions
   // don't support partial specialization, we'd need to introduce a helper
   // class to support 32-bit return types.
-  template<typename ResultType> ResultType InvokeWithCode() {
+  template<typename ResultType> ResultType InvokeWithCodeAndThread() {
     const bool fp_return = is_double<ResultType>::value;
     const bool fp_args = false;
+    Thread* thread = Thread::Current();
+    ASSERT(thread != NULL);
     return bit_cast<ResultType, int64_t>(Simulator::Current()->Call(
         bit_cast<intptr_t, uword>(entry()),
-        reinterpret_cast<intptr_t>(&code_), 0, 0, 0, fp_return, fp_args));
+        reinterpret_cast<intptr_t>(&code_),
+        reinterpret_cast<intptr_t>(thread),
+        0, 0, fp_return, fp_args));
   }
   template<typename ResultType, typename Arg1Type>
-  ResultType InvokeWithCode(Arg1Type arg1) {
+  ResultType InvokeWithCodeAndThread(Arg1Type arg1) {
     const bool fp_return = is_double<ResultType>::value;
     const bool fp_args = is_double<Arg1Type>::value;
     // TODO(fschneider): Support double arguments for simulator calls.
     COMPILE_ASSERT(!fp_args);
+    Thread* thread = Thread::Current();
+    ASSERT(thread != NULL);
     return bit_cast<ResultType, int64_t>(Simulator::Current()->Call(
         bit_cast<intptr_t, uword>(entry()),
         reinterpret_cast<intptr_t>(&code_),
+        reinterpret_cast<intptr_t>(thread),
         reinterpret_cast<intptr_t>(arg1),
-        0, 0, fp_return, fp_args));
+        0, fp_return, fp_args));
   }
 #endif  // ARCH_IS_64_BIT
 
   template<typename ResultType,
            typename Arg1Type,
            typename Arg2Type,
            typename Arg3Type>
   ResultType Invoke(Arg1Type arg1, Arg2Type arg2, Arg3Type arg3) {
     // TODO(fschneider): Support double arguments for simulator calls.
     COMPILE_ASSERT(is_void<ResultType>::value);
     COMPILE_ASSERT(!is_double<Arg1Type>::value);
     COMPILE_ASSERT(!is_double<Arg2Type>::value);
     COMPILE_ASSERT(!is_double<Arg3Type>::value);
     const bool fp_args = false;
     const bool fp_return = false;
     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 InvokeWithCode() {
-    typedef ResultType (*FunctionType) (const Code&);
-    return reinterpret_cast<FunctionType>(entry())(code_);
+  template<typename ResultType> ResultType InvokeWithCodeAndThread() {
+    Thread* thread = Thread::Current();
+    ASSERT(thread != NULL);
+    typedef ResultType (*FunctionType) (const Code&, Thread*);
+    return reinterpret_cast<FunctionType>(entry())(code_, thread);
   }
 
   template<typename ResultType, typename Arg1Type>
-  ResultType InvokeWithCode(Arg1Type arg1) {
-    typedef ResultType (*FunctionType) (const Code&, Arg1Type);
-    return reinterpret_cast<FunctionType>(entry())(code_, arg1);
+  ResultType InvokeWithCodeAndThread(Arg1Type arg1) {
+    Thread* thread = Thread::Current();
+    ASSERT(thread != NULL);
+    typedef ResultType (*FunctionType) (const Code&, Thread*, Arg1Type);
+    return reinterpret_cast<FunctionType>(entry())(code_, thread, 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);
   }
@@ skipping 102 matching lines @@
 // Yields:
 //
 //    out = "\"id\":\"\""
 //
 void ElideJSONSubstring(const char* prefix, const char* in, char* out);
 
 
 }  // namespace dart
 
 #endif  // VM_UNIT_TEST_H_