Direct call C++ functions

src/runtime.cc

 // Copyright 2006-2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 31 matching lines @@
 #include "platform.h"
 #include "runtime.h"
 #include "scopeinfo.h"
 #include "smart-pointer.h"
 #include "stub-cache.h"
 #include "v8threads.h"
 
 namespace v8 {
 namespace internal {
 
+#if defined(V8_TARGET_ARCH_X64) || defined(V8_TARGET_ARCH_IA32)
+#define DIRECT_CALL_SUPPORTED
+#endif
 
 #define RUNTIME_ASSERT(value) \
   if (!(value)) return Top::ThrowIllegalOperation();
 
 // Cast the given object to a value of the specified type and store
 // it in a variable with the given name.  If the object is not of the
 // expected type call IllegalOperation and return.
 #define CONVERT_CHECKED(Type, name, obj)                             \
   RUNTIME_ASSERT(obj->Is##Type());                                   \
   Type* name = Type::cast(obj);
@@ skipping 418 matching lines @@
       Top::context()->global_context()->context_extension_function();
   Object* object = Heap::AllocateJSObject(constructor);
   if (object->IsFailure()) return object;
   // Assign the exception value to the catch variable and make sure
   // that the catch variable is DontDelete.
   value = JSObject::cast(object)->SetProperty(key, value, DONT_DELETE);
   if (value->IsFailure()) return value;
   return object;
 }
 
-
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_ClassOf(Object* obj) {
+  AssertNoAllocation na;
+#else
 static Object* Runtime_ClassOf(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
   Object* obj = args[0];
+#endif
   if (!obj->IsJSObject()) return Heap::null_value();
   return JSObject::cast(obj)->class_name();
 }
 
 
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_IsInPrototypeChain(Object* O, Object* V) {
+  AssertNoAllocation na;
+#else
 static Object* Runtime_IsInPrototypeChain(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
-  // See ECMA-262, section 15.3.5.3, page 88 (steps 5 - 8).
   Object* O = args[0];
   Object* V = args[1];
+#endif
+  // See ECMA-262, section 15.3.5.3, page 88 (steps 5 - 8).
   while (true) {
     Object* prototype = V->GetPrototype();
     if (prototype->IsNull()) return Heap::false_value();
     if (O == prototype) return Heap::true_value();
     V = prototype;
   }
 }
 
 
 // Inserts an object as the hidden prototype of another object.
@@ skipping 101 matching lines @@
     elms->set(1, result.GetLazyValue());
     elms->set(2, Heap::ToBoolean(!result.IsReadOnly()));
   }
 
   elms->set(3, Heap::ToBoolean(!result.IsDontEnum()));
   elms->set(4, Heap::ToBoolean(!result.IsDontDelete()));
   return *desc;
 }
 
 
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_IsExtensible(Object* arg) {
+  AssertNoAllocation na;
+  ASSERT(arg->IsJSObject());
+  JSObject* obj = JSObject::cast(arg);
+#else
 static Object* Runtime_IsExtensible(Arguments args) {
   ASSERT(args.length() == 1);
   CONVERT_CHECKED(JSObject, obj, args[0]);
+#endif
   return obj->map()->is_extensible() ?  Heap::true_value()
                                      : Heap::false_value();
 }
 
 
 static Object* Runtime_RegExpCompile(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 3);
   CONVERT_ARG_CHECKED(JSRegExp, re, 0);
   CONVERT_ARG_CHECKED(String, pattern, 1);
@@ skipping 613 matching lines @@
                                       &has_pending_exception);
   if (has_pending_exception) {
     ASSERT(Top::has_pending_exception());
     return Failure::Exception();
   }
   literals->set(index, *regexp);
   return *regexp;
 }
 
 
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_FunctionGetName(Object* arg) {
+  AssertNoAllocation na;
+
+  ASSERT(arg->IsJSFunction());
+  JSFunction* f = JSFunction::cast(arg);
+#else
 static Object* Runtime_FunctionGetName(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
 
   CONVERT_CHECKED(JSFunction, f, args[0]);
+#endif
   return f->shared()->name();
 }
 
 
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_FunctionSetName(Object* arg0, Object* arg1) {
+  AssertNoAllocation na;
+
+  ASSERT(arg0->IsJSFunction());
+  JSFunction* f = JSFunction::cast(arg0);
+  ASSERT(arg1->IsString());
+  String* name = String::cast(arg1);
+#else
 static Object* Runtime_FunctionSetName(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
   CONVERT_CHECKED(JSFunction, f, args[0]);
   CONVERT_CHECKED(String, name, args[1]);
+#endif
   f->shared()->set_name(name);
   return Heap::undefined_value();
 }
 
 
 static Object* Runtime_FunctionGetScript(Arguments args) {
   HandleScope scope;
   ASSERT(args.length() == 1);
 
   CONVERT_CHECKED(JSFunction, fun, args[0]);
@@ skipping 1196 matching lines @@
         break;
       }
     }
     if (found) return Smi::FromInt(i);
   }
 
   return Smi::FromInt(-1);
 }
 
 
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_StringLocaleCompare(Object* arg0, Object* arg1) {
+  AssertNoAllocation na;
+  String* str1 = String::cast(arg0);
+  String* str2 = String::cast(arg1);
+#else
 static Object* Runtime_StringLocaleCompare(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
   CONVERT_CHECKED(String, str1, args[0]);
   CONVERT_CHECKED(String, str2, args[1]);
+#endif
 
   if (str1 == str2) return Smi::FromInt(0);  // Equal.
   int str1_length = str1->length();
   int str2_length = str2->length();
 
   // Decide trivial cases without flattening.
   if (str1_length == 0) {
     if (str2_length == 0) return Smi::FromInt(0);  // Equal.
     return Smi::FromInt(-str2_length);
   } else {
@@ skipping 1021 matching lines @@
   ASSERT(args.length() == 1);
   Handle<Object> object = args.at<Object>(0);
   if (object->IsJSObject()) {
     Handle<JSObject> js_object = Handle<JSObject>::cast(object);
     js_object->NormalizeProperties(CLEAR_INOBJECT_PROPERTIES, 0);
   }
   return *object;
 }
 
 
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_ToBool(Object* arg) {
+  AssertNoAllocation na;
+
+  return arg->ToBoolean();
+}
+#else
 static Object* Runtime_ToBool(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
 
   return args[0]->ToBoolean();
 }
+#endif
 
 
 // Returns the type string of a value; see ECMA-262, 11.4.3 (p 47).
 // Possible optimizations: put the type string into the oddballs.
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_Typeof(Object* obj) {
+  AssertNoAllocation na;
+#else
 static Object* Runtime_Typeof(Arguments args) {
   NoHandleAllocation ha;
-
   Object* obj = args[0];
+#endif
   if (obj->IsNumber()) return Heap::number_symbol();
   HeapObject* heap_obj = HeapObject::cast(obj);
 
   // typeof an undetectable object is 'undefined'
   if (heap_obj->map()->is_undetectable()) return Heap::undefined_symbol();
 
   InstanceType instance_type = heap_obj->map()->instance_type();
   if (instance_type < FIRST_NONSTRING_TYPE) {
     return Heap::string_symbol();
   }
@@ skipping 529 matching lines @@
 
   Object* obj = args[0];
   if (obj->IsSmi()) return obj;
   CONVERT_DOUBLE_CHECKED(number, obj);
   return Heap::NumberFromInt32(DoubleToInt32(number));
 }
 
 
 // Converts a Number to a Smi, if possible. Returns NaN if the number is not
 // a small integer.
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_NumberToSmi(Object* obj) {
+  AssertNoAllocation na;
+#else
 static Object* Runtime_NumberToSmi(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
 
   Object* obj = args[0];
+#endif
   if (obj->IsSmi()) {
     return obj;
   }
   if (obj->IsHeapNumber()) {
     double value = HeapNumber::cast(obj)->value();
     int int_value = FastD2I(value);
     if (value == FastI2D(int_value) && Smi::IsValid(int_value)) {
       return Smi::FromInt(int_value);
     }
   }
@@ skipping 275 matching lines @@
 static Object* Runtime_NumberSar(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
   CONVERT_NUMBER_CHECKED(int32_t, x, Int32, args[0]);
   CONVERT_NUMBER_CHECKED(int32_t, y, Int32, args[1]);
   return Heap::NumberFromInt32(ArithmeticShiftRight(x, y & 0x1f));
 }
 
 
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_NumberEquals(Object* arg0, Object* arg1) {
+  AssertNoAllocation na;
+
+  ASSERT(arg0->IsNumber());
+  double x = arg0->Number();
+  ASSERT(arg1->IsNumber());
+  double y = arg1->Number();
+#else
 static Object* Runtime_NumberEquals(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
   CONVERT_DOUBLE_CHECKED(x, args[0]);
   CONVERT_DOUBLE_CHECKED(y, args[1]);
+#endif
   if (isnan(x)) return Smi::FromInt(NOT_EQUAL);
   if (isnan(y)) return Smi::FromInt(NOT_EQUAL);
   if (x == y) return Smi::FromInt(EQUAL);
   Object* result;
   if ((fpclassify(x) == FP_ZERO) && (fpclassify(y) == FP_ZERO)) {
     result = Smi::FromInt(EQUAL);
   } else {
     result = Smi::FromInt(NOT_EQUAL);
   }
   return result;
 }
 
 
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_StringEquals(Object* arg0, Object* arg1) {
+  AssertNoAllocation na;
+
+  ASSERT(arg0->IsString());
+  String* x = String::cast(arg0);
+  ASSERT(arg1->IsString());
+  String* y = String::cast(arg1);
+#else
 static Object* Runtime_StringEquals(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
   CONVERT_CHECKED(String, x, args[0]);
   CONVERT_CHECKED(String, y, args[1]);
+#endif
 
   bool not_equal = !x->Equals(y);
   // This is slightly convoluted because the value that signifies
   // equality is 0 and inequality is 1 so we have to negate the result
   // from String::Equals.
   ASSERT(not_equal == 0 || not_equal == 1);
   STATIC_CHECK(EQUAL == 0);
   STATIC_CHECK(NOT_EQUAL == 1);
   return Smi::FromInt(not_equal);
 }
 
 
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_NumberCompare(Object* arg0, Object* arg1, Object* arg2) {
+  NoHandleAllocation ha;
+
+  ASSERT(arg0->IsNumber());
+  double x = arg0->Number();
+  ASSERT(arg1->IsNumber());
+  double y = arg1->Number();
+  if (isnan(x) || isnan(y)) return arg2;
+#else
 static Object* Runtime_NumberCompare(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 3);
 
   CONVERT_DOUBLE_CHECKED(x, args[0]);
   CONVERT_DOUBLE_CHECKED(y, args[1]);
   if (isnan(x) || isnan(y)) return args[2];
+#endif
   if (x == y) return Smi::FromInt(EQUAL);
   if (isless(x, y)) return Smi::FromInt(LESS);
   return Smi::FromInt(GREATER);
 }
 
 
 // Compare two Smis as if they were converted to strings and then
 // compared lexicographically.
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_SmiLexicographicCompare(Object* arg0, Object* arg1) {
+  AssertNoAllocation na;
+
+  // Extract the integer values from the Smis.
+  ASSERT(arg0->IsSmi());
+  Smi* x = Smi::cast(arg0);
+  ASSERT(arg1->IsSmi());
+  Smi* y = Smi::cast(arg1);
+#else
 static Object* Runtime_SmiLexicographicCompare(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
+  // Extract the integer values from the Smis.
+  CONVERT_CHECKED(Smi, x, args[0]);
+  CONVERT_CHECKED(Smi, y, args[1]);
+#endif
+
   // Arrays for the individual characters of the two Smis.  Smis are
   // 31 bit integers and 10 decimal digits are therefore enough.
   static int x_elms[10];
   static int y_elms[10];
 
-  // Extract the integer values from the Smis.
-  CONVERT_CHECKED(Smi, x, args[0]);
-  CONVERT_CHECKED(Smi, y, args[1]);
   int x_value = x->value();
   int y_value = y->value();
 
   // If the integers are equal so are the string representations.
   if (x_value == y_value) return Smi::FromInt(EQUAL);
 
   // If one of the integers are zero the normal integer order is the
   // same as the lexicographic order of the string representations.
   if (x_value == 0 || y_value == 0) return Smi::FromInt(x_value - y_value);
 
@@ skipping 26 matching lines @@
     if (diff != 0) return Smi::FromInt(diff);
   }
 
   // If one array is a suffix of the other array, the longest array is
   // the representation of the largest of the Smis in the
   // lexicographic ordering.
   return Smi::FromInt(x_index - y_index);
 }
 
 
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_StringCompare(Object* arg0, Object* arg1) {
+  AssertNoAllocation na;
+
+  ASSERT(arg0->IsString());
+  String* x = String::cast(arg0);
+  ASSERT(arg1->IsString());
+  String* y = String::cast(arg1);
+#else
 static Object* Runtime_StringCompare(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
   CONVERT_CHECKED(String, x, args[0]);
   CONVERT_CHECKED(String, y, args[1]);
+#endif
 
   Counters::string_compare_runtime.Increment();
 
   // A few fast case tests before we flatten.
   if (x == y) return Smi::FromInt(EQUAL);
   if (y->length() == 0) {
     if (x->length() == 0) return Smi::FromInt(EQUAL);
     return Smi::FromInt(GREATER);
   } else if (x->length() == 0) {
     return Smi::FromInt(LESS);
@@ skipping 920 matching lines @@
 
 static Object* Runtime_DateDaylightSavingsOffset(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
 
   CONVERT_DOUBLE_CHECKED(x, args[0]);
   return Heap::NumberFromDouble(OS::DaylightSavingsOffset(x));
 }
 
 
+#ifdef DIRECT_CALL_SUPPORTED
+static Object* Runtime_NumberIsFinite(Object* arg0) {
+  AssertNoAllocation na;
+  ASSERT(arg0->IsNumber());
+  double value = arg0->Number();
+#else
 static Object* Runtime_NumberIsFinite(Arguments args) {
   NoHandleAllocation ha;
   ASSERT(args.length() == 1);
 
   CONVERT_DOUBLE_CHECKED(value, args[0]);
+#endif
   Object* result;
   if (isnan(value) || (fpclassify(value) == FP_INFINITE)) {
     result = Heap::false_value();
   } else {
     result = Heap::true_value();
   }
   return result;
 }
 
 
@@ skipping 2627 matching lines @@
 
 #ifdef DEBUG
 // ListNatives is ONLY used by the fuzz-natives.js in debug mode
 // Exclude the code in release mode.
 static Object* Runtime_ListNatives(Arguments args) {
   ASSERT(args.length() == 0);
   HandleScope scope;
   Handle<JSArray> result = Factory::NewJSArray(0);
   int index = 0;
 #define ADD_ENTRY(Name, argc, ressize)                                       \
-  {                                                                          \
+  if (Runtime::FunctionForId(Runtime::k##Name)->calling_convention !=        \
+      Runtime::DIRECT_CALL_NOT_FAILS) {                                      \
     HandleScope inner;                                                       \
     Handle<String> name =                                                    \
       Factory::NewStringFromAscii(                                           \
           Vector<const char>(#Name, StrLength(#Name)));       \
     Handle<JSArray> pair = Factory::NewJSArray(0);                           \
     SetElement(pair, 0, name);                                               \
     SetElement(pair, 1, Handle<Smi>(Smi::FromInt(argc)));                    \
     SetElement(result, index++, pair);                                       \
   }
   RUNTIME_FUNCTION_LIST(ADD_ENTRY)
@@ skipping 11 matching lines @@
   Logger::LogRuntime(chars, elms);
   return Heap::undefined_value();
 }
 
 
 static Object* Runtime_IS_VAR(Arguments args) {
   UNREACHABLE();  // implemented as macro in the parser
   return NULL;
 }
 
+// ----------------------------------------------------------------------------
+// Utilities for building the runtime function list
+namespace {
+
+template <size_t kId>
+class SignatureTag {
+  char a[kId];  // there is a biection between  id and sizeof(SignatureTag<kId>)
+};
+
+
+template <size_t signature_tag_size> struct FunctionTraits;
+
+
+#define SIGNATURE_TRAITS(id, signature) \
+  SignatureTag<id> GetTag(signature); \
+  template <> struct FunctionTraits<sizeof(SignatureTag<id>)>
+
+SIGNATURE_TRAITS(1, Object* (*)(Arguments)) {
+  static const Runtime::CallingConvention conv = Runtime::EXIT_FRAME_CALL;
+};
+
+
+SIGNATURE_TRAITS(2, ObjectPair (*)(Arguments)) {
+  static const Runtime::CallingConvention conv = Runtime::EXIT_FRAME_CALL;
+};
+
+
+SIGNATURE_TRAITS(3, Object* (*)(Object* arg)) {
+  static const Runtime::CallingConvention conv = Runtime::DIRECT_CALL_NOT_FAILS;
+};
+
+
+SIGNATURE_TRAITS(4, Object* (*)(Object* agr0, Object* arg1)) {
+  static const Runtime::CallingConvention conv = Runtime::DIRECT_CALL_NOT_FAILS;
+};
+
+SIGNATURE_TRAITS(5, Object* (*)(Object* arg0, Object* arg1, Object* arg2)) {
+  static const Runtime::CallingConvention conv = Runtime::DIRECT_CALL_NOT_FAILS;
+};
+}
 
 // ----------------------------------------------------------------------------
 // Implementation of Runtime
 
 #define F(name, nargs, ressize)                                           \
   { #name, FUNCTION_ADDR(Runtime_##name), nargs, \
-    static_cast<int>(Runtime::k##name), ressize },
+    static_cast<int>(Runtime::k##name), ressize, \
+    FunctionTraits<sizeof(GetTag(Runtime_##name))>::conv},
 
 static Runtime::Function Runtime_functions[] = {
   RUNTIME_FUNCTION_LIST(F)
-  { NULL, NULL, 0, -1, 0 }
+  { NULL, NULL, 0, -1, 0, Runtime::EXIT_FRAME_CALL }
 };
 
 #undef F
 
 
 Runtime::Function* Runtime::FunctionForId(FunctionId fid) {
   ASSERT(0 <= fid && fid < kNofFunctions);
   return &Runtime_functions[fid];
 }
 
@@ skipping 17 matching lines @@
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     Counters::gc_last_resort_from_js.Increment();
     Heap::CollectAllGarbage(false);
   }
 }
 
 
 } }  // namespace v8::internal