[Isolates] Merge from bleeding_edge, revisions 5934-6100.

src/heap-inl.h

-// Copyright 2006-2008 the V8 project authors. All rights reserved.
+// Copyright 2006-2010 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
 //       with the distribution.
@@ skipping 30 matching lines @@
   // Assert no overflow into live objects.
   ASSERT(reinterpret_cast<Address>(rear_) >= HEAP->new_space()->top());
 }
 
 
 int Heap::MaxObjectSizeInPagedSpace() {
   return Page::kMaxHeapObjectSize;
 }
 
 
+MaybeObject* Heap::AllocateStringFromUtf8(Vector<const char> str,
+                                          PretenureFlag pretenure) {
+  // Check for ASCII first since this is the common case.
+  for (int i = 0; i < str.length(); ++i) {
+    if (static_cast<uint8_t>(str[i]) > String::kMaxAsciiCharCodeU) {
+      // Non-ASCII and we need to decode.
+      return AllocateStringFromUtf8Slow(str, pretenure);
+    }
+  }
+  // If the string is ASCII, we do not need to convert the characters
+  // since UTF8 is backwards compatible with ASCII.
+  return AllocateStringFromAscii(str, pretenure);
+}
+
+
 MaybeObject* Heap::AllocateSymbol(Vector<const char> str,
                                   int chars,
                                   uint32_t hash_field) {
   unibrow::Utf8InputBuffer<> buffer(str.start(),
                                     static_cast<unsigned>(str.length()));
   return AllocateInternalSymbol(&buffer, chars, hash_field);
 }
 
 
 MaybeObject* Heap::CopyFixedArray(FixedArray* src) {
@@ skipping 488 matching lines @@
   }
   return cache->Get(input);
 }
 
 
 Address TranscendentalCache::cache_array_address() {
   return reinterpret_cast<Address>(caches_);
 }
 
 
+double TranscendentalCache::SubCache::Calculate(double input) {
+  switch (type_) {
+    case ACOS:
+      return acos(input);
+    case ASIN:
+      return asin(input);
+    case ATAN:
+      return atan(input);
+    case COS:
+      return cos(input);
+    case EXP:
+      return exp(input);
+    case LOG:
+      return log(input);
+    case SIN:
+      return sin(input);
+    case TAN:
+      return tan(input);
+    default:
+      return 0.0;  // Never happens.
+  }
+}
+
+
 MaybeObject* TranscendentalCache::SubCache::Get(double input) {
   Converter c;
   c.dbl = input;
   int hash = Hash(c);
   Element e = elements_[hash];
   if (e.in[0] == c.integers[0] &&
       e.in[1] == c.integers[1]) {
     ASSERT(e.output != NULL);
     isolate_->counters()->transcendental_cache_hit()->Increment();
     return e.output;
@@ skipping 22 matching lines @@
 #ifdef DEBUG
   UpdateLiveObjectCount(obj);
 #endif
   obj->SetMark();
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_INL_H_