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

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/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.
 #define F(name, number_of_args, result_size)                    \
   Object* Runtime_##name(int args_length, Object** args_object, \
                          Isolate* isolate);
 FOR_EACH_INTRINSIC_RETURN_OBJECT(F)
 #undef F
 
 #define P(name, number_of_args, result_size)                       \
   ObjectPair Runtime_##name(int args_length, Object** args_object, \
                             Isolate* isolate);
 FOR_EACH_INTRINSIC_RETURN_PAIR(P)
 #undef P
 
 
-#define F(name, number_of_args, result_size)                                  \
-  {                                                                           \
-    Runtime::k##name, Runtime::RUNTIME, #name, FUNCTION_ADDR(Runtime_##name), \
-        number_of_args, result_size                                           \
-  }                                                                           \
+#define F(name, number_of_args, result_size)                         \
+  {                                                                  \
+    Runtime::k##name, Runtime::RUNTIME, #name,                       \
+        {FUNCTION_ADDR(Runtime_##name)}, number_of_args, result_size \
+  }                                                                  \
   ,
 
 
-#define I(name, number_of_args, result_size)                       \
-  {                                                                \
-    Runtime::kInline##name, Runtime::INLINE, "_" #name,            \
-        FUNCTION_ADDR(Runtime_##name), number_of_args, result_size \
-  }                                                                \
+#define I(name, number_of_args, result_size)                         \
+  {                                                                  \
+    Runtime::kInline##name, Runtime::INLINE, "_" #name,              \
+        {FUNCTION_ADDR(Runtime_##name)}, number_of_args, result_size \
+  }                                                                  \
   ,
 
+#define C(index, type, name)                               \
+  {                                                        \
+    Runtime::kContext_##name, Runtime::CONTEXT, #name,     \
+        {reinterpret_cast<Address>(Context::index)}, -1, 0 \
+  }                                                        \
+  ,
 
 static const Runtime::Function kIntrinsicFunctions[] = {
-    FOR_EACH_INTRINSIC(F) FOR_EACH_INTRINSIC(I)};
+  FOR_EACH_INTRINSIC(F)
+  FOR_EACH_INTRINSIC(I)
+  NATIVE_CONTEXT_IMPORTED_FIELDS(C)
+};
 
+#undef C
 #undef I
 #undef F
 
 
 void Runtime::InitializeIntrinsicFunctionNames(Isolate* isolate,
                                                Handle<NameDictionary> dict) {
   DCHECK(dict->NumberOfElements() == 0);
   HandleScope scope(isolate);
   for (int i = 0; i < kNumFunctions; ++i) {
     const char* name = kIntrinsicFunctions[i].name;
@@ skipping 14 matching lines @@
     Object* smi_index = heap->intrinsic_function_names()->ValueAt(entry);
     int function_index = Smi::cast(smi_index)->value();
     return &(kIntrinsicFunctions[function_index]);
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForEntry(Address entry) {
   for (size_t i = 0; i < arraysize(kIntrinsicFunctions); ++i) {
-    if (entry == kIntrinsicFunctions[i].entry) {
+    if (kIntrinsicFunctions[i].intrinsic_type == RUNTIME &&
+        entry == kIntrinsicFunctions[i].entry) {
       return &(kIntrinsicFunctions[i]);
     }
   }
   return NULL;
 }
 
 
 const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
   return &(kIntrinsicFunctions[static_cast<int>(id)]);
 }
 
 
 std::ostream& operator<<(std::ostream& os, Runtime::FunctionId id) {
   return os << Runtime::FunctionForId(id)->name;
 }
 
 }  // namespace internal
 }  // namespace v8