Call JS functions via native context instead of js builtins object.

src/runtime/runtime.h

 // 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.
 
 #ifndef V8_RUNTIME_RUNTIME_H_
 #define V8_RUNTIME_RUNTIME_H_
 
 #include "src/allocation.h"
+#include "src/contexts.h"
 #include "src/objects.h"
 #include "src/unicode.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 
 // * Each intrinsic is consistently exposed in JavaScript via 2 names:
 //    * %#name, which is always a runtime call.
 //    * %_#name, which can be inlined or just a runtime call, the compiler in
@@ skipping 277 matching lines @@
   F(BreakIteratorCurrent, 1, 1)              \
   F(BreakIteratorBreakType, 1, 1)
 #else
 #define FOR_EACH_INTRINSIC_I18N(F)
 #endif
 
 
 #define FOR_EACH_INTRINSIC_INTERNAL(F)        \
   F(CheckIsBootstrapping, 0, 1)               \
   F(ExportPrivateSymbols, 1, 1)               \
-  F(ImportToRuntime, 1, 1)                    \
-  F(ImportExperimentalToRuntime, 1, 1)        \
+  F(ExportToRuntime, 1, 1)                    \
   F(InstallJSBuiltins, 1, 1)                  \
   F(Throw, 1, 1)                              \
   F(ReThrow, 1, 1)                            \
   F(UnwindAndFindExceptionHandler, 0, 1)      \
   F(PromoteScheduledException, 0, 1)          \
   F(ThrowReferenceError, 1, 1)                \
   F(NewTypeError, 2, 1)                       \
   F(NewSyntaxError, 2, 1)                     \
   F(NewReferenceError, 2, 1)                  \
   F(ThrowIteratorResultNotAnObject, 1, 1)     \
@@ skipping 657 matching lines @@
 
 
 class JavaScriptFrameIterator;  // Forward declaration.
 
 
 class Runtime : public AllStatic {
  public:
   enum FunctionId {
 #define F(name, nargs, ressize) k##name,
 #define I(name, nargs, ressize) kInline##name,
-    FOR_EACH_INTRINSIC(F) FOR_EACH_INTRINSIC(I)
+#define C(index, type, name) kContext_##name,
+  FOR_EACH_INTRINSIC(F)
+  FOR_EACH_INTRINSIC(I)
+  NATIVE_CONTEXT_IMPORTED_FIELDS(C)
+#undef C
 #undef I
 #undef F
-        kNumFunctions,
+            kNumFunctions,
   };
 
-  enum IntrinsicType { RUNTIME, INLINE };
+  enum IntrinsicType { RUNTIME, INLINE, CONTEXT };

[Michael Starzinger, 2015/08/25 18:12:09]

High-level feedback: I am not sure whether overloading the Runtime::Function
table like this is the way to go. Basically what we need is a mapping (name ->
context-index) IIUC. The other fields (e.g. nargs, result_size) make no sense
for "imported context functions". Also them being implemented in JavaScript as
opposed to C++ makes them different. Would it be worth it to have a separate
lookup functionality outside of the Runtime class?

 
   // Intrinsic function descriptor.
   struct Function {
     FunctionId function_id;
     IntrinsicType intrinsic_type;
     // The JS name of the function.
     const char* name;
 
-    // The C++ (native) entry point.  NULL if the function is inlined.
-    byte* entry;
+    // For RUNTIME functions, this is the C++ entry point.
+    // For INLINE functions this is the C++ entry point of the fall back.
+    // For CONTEXT functions this is the native context index.
+    union {
+      Address entry;
+      Context::Index index;
+    };
 
     // The number of arguments expected. nargs is -1 if the function takes
     // a variable number of arguments.
-    int nargs;
+    int8_t nargs;
     // Size of result.  Most functions return a single pointer, size 1.
-    int result_size;
+    int8_t result_size;
   };
 
   static const int kNotFound = -1;
 
   // Add internalized strings for all the intrinsic function names to a
   // StringDictionary.
   static void InitializeIntrinsicFunctionNames(Isolate* isolate,
                                                Handle<NameDictionary> dict);
 
   // Get the intrinsic function with the given name, which must be internalized.
@@ skipping 120 matching lines @@
 inline bool Runtime::AtomicIsLockFree(uint32_t size) {
   return size == 1 || size == 2 || size == 4;
 }
 
 #endif
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_RUNTIME_RUNTIME_H_