Reset trunk to 3.24.35.4

src/runtime.cc

 // Copyright 2012 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 615 matching lines @@
   Handle<Object> name(args[0], isolate);
   RUNTIME_ASSERT(name->IsString() || name->IsUndefined());
   Symbol* symbol;
   MaybeObject* maybe = isolate->heap()->AllocatePrivateSymbol();
   if (!maybe->To(&symbol)) return maybe;
   if (name->IsString()) symbol->set_name(*name);
   return symbol;
 }
 
 
-RUNTIME_FUNCTION(MaybeObject*, Runtime_NewSymbolWrapper) {
-  ASSERT(args.length() == 1);
-  CONVERT_ARG_CHECKED(Symbol, symbol, 0);
-  return symbol->ToObject(isolate);
-}
-
-
-RUNTIME_FUNCTION(MaybeObject*, Runtime_SymbolDescription) {
+RUNTIME_FUNCTION(MaybeObject*, Runtime_SymbolName) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 1);
   CONVERT_ARG_CHECKED(Symbol, symbol, 0);
   return symbol->name();
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_SymbolIsPrivate) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 1);
@@ skipping 5887 matching lines @@
       args, isolate, isolate->runtime_state()->to_lower_mapping());
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_StringToUpperCase) {
   return ConvertCase(
       args, isolate, isolate->runtime_state()->to_upper_mapping());
 }
 
 
+static inline bool IsTrimWhiteSpace(unibrow::uchar c) {
+  return unibrow::WhiteSpace::Is(c) || c == 0x200b || c == 0xfeff;
+}
+
+
 RUNTIME_FUNCTION(MaybeObject*, Runtime_StringTrim) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 3);
 
   CONVERT_ARG_HANDLE_CHECKED(String, string, 0);
   CONVERT_BOOLEAN_ARG_CHECKED(trimLeft, 1);
   CONVERT_BOOLEAN_ARG_CHECKED(trimRight, 2);
 
   string = FlattenGetString(string);
   int length = string->length();
 
   int left = 0;
-  UnicodeCache* unicode_cache = isolate->unicode_cache();
   if (trimLeft) {
-    while (left < length &&
-           unicode_cache->IsWhiteSpaceOrLineTerminator(string->Get(left))) {
+    while (left < length && IsTrimWhiteSpace(string->Get(left))) {
       left++;
     }
   }
 
   int right = length;
   if (trimRight) {
-    while (right > left &&
-           unicode_cache->IsWhiteSpaceOrLineTerminator(
-               string->Get(right - 1))) {
+    while (right > left && IsTrimWhiteSpace(string->Get(right - 1))) {
       right--;
     }
   }
 
   return *isolate->factory()->NewSubString(string, left, right);
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_StringSplit) {
   HandleScope handle_scope(isolate);
@@ skipping 1061 matching lines @@
   }
   { MaybeObject* maybe_obj = isolate->heap()->PrepareForCompare(y);
     if (!maybe_obj->ToObject(&obj)) return maybe_obj;
   }
 
   return (x->IsFlat() && y->IsFlat()) ? FlatStringCompare(x, y)
       : StringCharacterStreamCompare(isolate->runtime_state(), x, y);
 }
 
 
-#define RUNTIME_UNARY_MATH(NAME)                                               \
-RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_##NAME) {                          \
-  SealHandleScope shs(isolate);                                                \
-  ASSERT(args.length() == 1);                                                  \
-  isolate->counters()->math_##NAME()->Increment();                             \
-  CONVERT_DOUBLE_ARG_CHECKED(x, 0);                                            \
-  return isolate->heap()->AllocateHeapNumber(std::NAME(x));                    \
-}
+RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_acos) {
+  SealHandleScope shs(isolate);
+  ASSERT(args.length() == 1);
+  isolate->counters()->math_acos()->Increment();
 
-RUNTIME_UNARY_MATH(acos)
-RUNTIME_UNARY_MATH(asin)
-RUNTIME_UNARY_MATH(atan)
-RUNTIME_UNARY_MATH(log)
-#undef RUNTIME_UNARY_MATH
-
-
-// Cube root approximation, refer to: http://metamerist.com/cbrt/cbrt.htm
-// Using initial approximation adapted from Kahan's cbrt and 4 iterations
-// of Newton's method.
-inline double CubeRootNewtonIteration(double approx, double x) {
-  return (1.0 / 3.0) * (x / (approx * approx) + 2 * approx);
+  CONVERT_DOUBLE_ARG_CHECKED(x, 0);
+  return isolate->heap()->AllocateHeapNumber(std::acos(x));
 }
 
 
-inline double CubeRoot(double x) {
-  static const uint64_t magic = V8_2PART_UINT64_C(0x2A9F7893, 00000000);
-  uint64_t xhigh = double_to_uint64(x);
-  double approx = uint64_to_double(xhigh / 3 + magic);
+RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_asin) {
+  SealHandleScope shs(isolate);
+  ASSERT(args.length() == 1);
+  isolate->counters()->math_asin()->Increment();
 
-  approx = CubeRootNewtonIteration(approx, x);
-  approx = CubeRootNewtonIteration(approx, x);
-  approx = CubeRootNewtonIteration(approx, x);
-  return CubeRootNewtonIteration(approx, x);
+  CONVERT_DOUBLE_ARG_CHECKED(x, 0);
+  return isolate->heap()->AllocateHeapNumber(std::asin(x));
 }
 
 
-RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_cbrt) {
+RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_atan) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 1);
+  isolate->counters()->math_atan()->Increment();
+
   CONVERT_DOUBLE_ARG_CHECKED(x, 0);
-  if (x == 0 || std::isinf(x)) return args[0];
-  double result = (x > 0) ? CubeRoot(x) : -CubeRoot(-x);
-  return isolate->heap()->AllocateHeapNumber(result);
+  return isolate->heap()->AllocateHeapNumber(std::atan(x));
 }
 
 
-RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_log1p) {
-  SealHandleScope shs(isolate);
-  ASSERT(args.length() == 1);
-  CONVERT_DOUBLE_ARG_CHECKED(x, 0);
-
-  double x_abs = std::fabs(x);
-  // Use Taylor series to approximate. With y = x + 1;
-  // log(y) at 1 == log(1) + log'(1)(y-1)/1! + log''(1)(y-1)^2/2! + ...
-  //             == 0 + x - x^2/2 + x^3/3 ...
-  // The closer x is to 0, the fewer terms are required.
-  static const double threshold_2 = 1.0 / 0x00800000;
-  static const double threshold_3 = 1.0 / 0x00008000;
-  static const double threshold_7 = 1.0 / 0x00000080;
-
-  double result;
-  if (x_abs < threshold_2) {
-    result = x * (1.0/1.0 - x * 1.0/2.0);
-  } else if (x_abs < threshold_3) {
-    result = x * (1.0/1.0 - x * (1.0/2.0 - x * (1.0/3.0)));
-  } else if (x_abs < threshold_7) {
-    result = x * (1.0/1.0 - x * (1.0/2.0 - x * (
-                  1.0/3.0 - x * (1.0/4.0 - x * (
-                  1.0/5.0 - x * (1.0/6.0 - x * (
-                  1.0/7.0)))))));
-  } else {  // Use regular log if not close enough to 0.
-    result = std::log(1.0 + x);
-  }
-  return isolate->heap()->AllocateHeapNumber(result);
-}
-
-
-RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_expm1) {
-  SealHandleScope shs(isolate);
-  ASSERT(args.length() == 1);
-  CONVERT_DOUBLE_ARG_CHECKED(x, 0);
-
-  double x_abs = std::fabs(x);
-  // Use Taylor series to approximate.
-  // exp(x) - 1 at 0 == -1 + exp(0) + exp'(0)*x/1! + exp''(0)*x^2/2! + ...
-  //                 == x/1! + x^2/2! + x^3/3! + ...
-  // The closer x is to 0, the fewer terms are required.
-  static const double threshold_2 = 1.0 / 0x00400000;
-  static const double threshold_3 = 1.0 / 0x00004000;
-  static const double threshold_6 = 1.0 / 0x00000040;
-
-  double result;
-  if (x_abs < threshold_2) {
-    result = x * (1.0/1.0 + x * (1.0/2.0));
-  } else if (x_abs < threshold_3) {
-    result = x * (1.0/1.0 + x * (1.0/2.0 + x * (1.0/6.0)));
-  } else if (x_abs < threshold_6) {
-    result = x * (1.0/1.0 + x * (1.0/2.0 + x * (
-                  1.0/6.0 + x * (1.0/24.0 + x * (
-                  1.0/120.0 + x * (1.0/720.0))))));
-  } else {  // Use regular exp if not close enough to 0.
-    result = std::exp(x) - 1.0;
-  }
-  return isolate->heap()->AllocateHeapNumber(result);
-}
-
-
 static const double kPiDividedBy4 = 0.78539816339744830962;
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_atan2) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 2);
   isolate->counters()->math_atan2()->Increment();
 
   CONVERT_DOUBLE_ARG_CHECKED(x, 0);
   CONVERT_DOUBLE_ARG_CHECKED(y, 1);
@@ skipping 27 matching lines @@
 RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_floor) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 1);
   isolate->counters()->math_floor()->Increment();
 
   CONVERT_DOUBLE_ARG_CHECKED(x, 0);
   return isolate->heap()->NumberFromDouble(std::floor(x));
 }
 
 
+RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_log) {
+  SealHandleScope shs(isolate);
+  ASSERT(args.length() == 1);
+  isolate->counters()->math_log()->Increment();
+
+  CONVERT_DOUBLE_ARG_CHECKED(x, 0);
+  return isolate->heap()->AllocateHeapNumber(std::log(x));
+}
+
+
 // Slow version of Math.pow.  We check for fast paths for special cases.
 // Used if SSE2/VFP3 is not available.
 RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_pow) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 2);
   isolate->counters()->math_pow()->Increment();
 
   CONVERT_DOUBLE_ARG_CHECKED(x, 0);
 
   // If the second argument is a smi, it is much faster to call the
@@ skipping 75 matching lines @@
 RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_sqrt) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 1);
   isolate->counters()->math_sqrt()->Increment();
 
   CONVERT_DOUBLE_ARG_CHECKED(x, 0);
   return isolate->heap()->AllocateHeapNumber(fast_sqrt(x));
 }
 
 
-RUNTIME_FUNCTION(MaybeObject*, Runtime_Math_fround) {
-  SealHandleScope shs(isolate);
-  ASSERT(args.length() == 1);
-
-  CONVERT_DOUBLE_ARG_CHECKED(x, 0);
-  float xf = static_cast<float>(x);
-  return isolate->heap()->AllocateHeapNumber(xf);
-}
-
-
 RUNTIME_FUNCTION(MaybeObject*, Runtime_DateMakeDay) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 2);
 
   CONVERT_SMI_ARG_CHECKED(year, 0);
   CONVERT_SMI_ARG_CHECKED(month, 1);
 
   return Smi::FromInt(isolate->date_cache()->DaysFromYearMonth(year, month));
 }
 
@@ skipping 625 matching lines @@
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_ClearFunctionTypeFeedback) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
   Code* unoptimized = function->shared()->code();
   if (unoptimized->kind() == Code::FUNCTION) {
     unoptimized->ClearInlineCaches();
-    unoptimized->ClearTypeFeedbackInfo(isolate->heap());
+    unoptimized->ClearTypeFeedbackCells(isolate->heap());
   }
   return isolate->heap()->undefined_value();
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_RunningInSimulator) {
   SealHandleScope shs(isolate);
 #if defined(USE_SIMULATOR)
   return isolate->heap()->true_value();
 #else
@@ skipping 5770 matching lines @@
 
   const char* version_string = v8::V8::GetVersion();
 
   return isolate->heap()->AllocateStringFromOneByte(CStrVector(version_string),
                                                   NOT_TENURED);
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_Abort) {
   SealHandleScope shs(isolate);
-  ASSERT(args.length() == 1);
-  CONVERT_SMI_ARG_CHECKED(message_id, 0);
-  const char* message = GetBailoutReason(
-      static_cast<BailoutReason>(message_id));
-  OS::PrintError("abort: %s\n", message);
+  ASSERT(args.length() == 2);
+  OS::PrintError("abort: %s\n",
+                 reinterpret_cast<char*>(args[0]) + args.smi_at(1));
   isolate->PrintStack(stderr);
   OS::Abort();
   UNREACHABLE();
   return NULL;
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_AbortJS) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 1);
@@ skipping 308 matching lines @@
 RUNTIME_FUNCTION(MaybeObject*, Runtime_SetMicrotaskPending) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 1);
   CONVERT_BOOLEAN_ARG_CHECKED(new_state, 0);
   bool old_state = isolate->microtask_pending();
   isolate->set_microtask_pending(new_state);
   return isolate->heap()->ToBoolean(old_state);
 }
 
 
-RUNTIME_FUNCTION(MaybeObject*, Runtime_RunMicrotasks) {
-  HandleScope scope(isolate);
-  ASSERT(args.length() == 0);
-  Execution::RunMicrotasks(isolate);
-  return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(MaybeObject*, Runtime_GetMicrotaskState) {
-  SealHandleScope shs(isolate);
-  ASSERT(args.length() == 0);
-  return isolate->heap()->microtask_state();
-}
-
-
 RUNTIME_FUNCTION(MaybeObject*, Runtime_GetObservationState) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 0);
   return isolate->heap()->observation_state();
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_ObservationWeakMapCreate) {
   HandleScope scope(isolate);
   ASSERT(args.length() == 0);
@@ skipping 255 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal