[Interpreter] Add CallRuntime support to the interpreter.

src/runtime/runtime.cc

 // Copyright 2012 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 "src/runtime/runtime.h"
 
+#include "src/assembler.h"
 #include "src/contexts.h"
 #include "src/handles-inl.h"
 #include "src/heap/heap.h"
 #include "src/isolate.h"
 #include "src/runtime/runtime-utils.h"
 
 namespace v8 {
 namespace internal {
 
 // Header of runtime functions.
@@ skipping 70 matching lines @@
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
   return &(kIntrinsicFunctions[static_cast<int>(id)]);
 }
 
 
+static Runtime::Function* kRedirectedIntrinsicFunctions = nullptr;
+
+
+const Runtime::Function* Runtime::RuntimeFunctionTable(Isolate* isolate) {
+  if (isolate->external_reference_redirector()) {
+    // When running with the simulator we need to provide a table which has
+    // redirected runtime entry addresses.
+    if (!kRedirectedIntrinsicFunctions) {

[Michael Starzinger, 2015/09/29 08:28:34]

This is not thread-safe when multiple isolates are spinning up at the same time.
It's probably OK and nothing actionable at this time, but TSAN might come back
to you about this one.

[rmcilroy, 2015/10/01 17:02:45]

Put this on the isolate in RuntimeState as disscussed offline. This should
address the threading issues.

[Michael Starzinger, 2015/10/01 17:43:47]

Acknowledged. Looks good.

+      kRedirectedIntrinsicFunctions = reinterpret_cast<Runtime::Function*>(
+          malloc(sizeof(kIntrinsicFunctions)));

[Michael Starzinger, 2015/09/29 08:28:34]

Hmm, allocated but never freed AFAICT. How about we leave a TODO here that this
should eventually be moved into the Isolate instead?

[rmcilroy, 2015/10/01 17:02:45]

Put this on the isolate in RuntimeState as disscussed offline. This should
address the freeing issues.

[Michael Starzinger, 2015/10/01 17:43:47]

Acknowledged. Looks good.

+      memcpy(kRedirectedIntrinsicFunctions, kIntrinsicFunctions,
+             sizeof(kIntrinsicFunctions));
+      for (int i = 0; i < sizeof(kIntrinsicFunctions) / sizeof(Function); i++) {

[oth, 2015/09/29 09:33:36]

nit: arraysize()

[rmcilroy, 2015/10/01 17:02:45]

Done.

+        ExternalReference redirected_entry(static_cast<Runtime::FunctionId>(i),
+                                           isolate);
+        kRedirectedIntrinsicFunctions[i].entry = redirected_entry.address();
+      }

[rmcilroy, 2015/09/28 16:20:47]

Note: To get this working on the simulator I've needed to make a duplicate
intrinsics table with redirected entry addresses (i.e., they point to the arm
software-interrupt handler which then transitions from the simulator to native
C++ implementation). The only other options I could think of would have been
really invasive to non-simulator code, so I think this is best since it only
does this duplicate when the interpreter is being used, and is running on a
simulator. Happy to discuss other options though.

[Michael Starzinger, 2015/09/29 08:28:34]

Acknowledged. I'm fine with this, just the mechanics mentioned in the comments
above might need addressing, TODOs and follow-up CL is fine as well.

[rmcilroy, 2015/10/01 17:02:45]

Acknowledged.

+    }
+    return kRedirectedIntrinsicFunctions;
+  } else {
+    return kIntrinsicFunctions;
+  }
+}
+
+
 std::ostream& operator<<(std::ostream& os, Runtime::FunctionId id) {
   return os << Runtime::FunctionForId(id)->name;
 }
 
 }  // namespace internal
 }  // namespace v8