1 files changed, 1 insertions, 215 deletions

diff --git a/runtime/mirror/string-inl.h b/runtime/mirror/string-inl.h
index 3752d6dde9..d89ef1ecd9 100644
--- a/runtime/mirror/string-inl.h
+++ b/runtime/mirror/string-inl.h
@@ -20,17 +20,11 @@
 
 #include "android-base/stringprintf.h"
 
-#include "array.h"
-#include "base/bit_utils.h"
 #include "base/globals.h"
 #include "base/utils.h"
-#include "class.h"
-#include "class_root.h"
+#include "class-inl.h"
 #include "common_throws.h"
 #include "dex/utf.h"
-#include "gc/heap-inl.h"
-#include "runtime.h"
-#include "thread.h"
 
 namespace art {
 namespace mirror {
@@ -49,127 +43,6 @@ inline uint32_t String::ClassSize(PointerSize pointer_size) {
   return Class::ComputeClassSize(true, vtable_entries, 0, 0, 0, 1, 2, pointer_size);
 }
 
-// Sets string count in the allocation code path to ensure it is guarded by a CAS.
-class SetStringCountVisitor {
- public:
-  explicit SetStringCountVisitor(int32_t count) : count_(count) {
-  }
-
-  void operator()(ObjPtr<Object> obj, size_t usable_size ATTRIBUTE_UNUSED) const
-      REQUIRES_SHARED(Locks::mutator_lock_) {
-    // Avoid AsString as object is not yet in live bitmap or allocation stack.
-    ObjPtr<String> string = ObjPtr<String>::DownCast(obj);
-    string->SetCount(count_);
-    DCHECK(!string->IsCompressed() || kUseStringCompression);
-  }
-
- private:
-  const int32_t count_;
-};
-
-// Sets string count and value in the allocation code path to ensure it is guarded by a CAS.
-class SetStringCountAndBytesVisitor {
- public:
-  SetStringCountAndBytesVisitor(int32_t count, Handle<ByteArray> src_array, int32_t offset,
-                                int32_t high_byte)
-      : count_(count), src_array_(src_array), offset_(offset), high_byte_(high_byte) {
-  }
-
-  void operator()(ObjPtr<Object> obj, size_t usable_size ATTRIBUTE_UNUSED) const
-      REQUIRES_SHARED(Locks::mutator_lock_) {
-    // Avoid AsString as object is not yet in live bitmap or allocation stack.
-    ObjPtr<String> string = ObjPtr<String>::DownCast(obj);
-    string->SetCount(count_);
-    DCHECK(!string->IsCompressed() || kUseStringCompression);
-    int32_t length = String::GetLengthFromCount(count_);
-    const uint8_t* const src = reinterpret_cast<uint8_t*>(src_array_->GetData()) + offset_;
-    if (string->IsCompressed()) {
-      uint8_t* valueCompressed = string->GetValueCompressed();
-      for (int i = 0; i < length; i++) {
-        valueCompressed[i] = (src[i] & 0xFF);
-      }
-    } else {
-      uint16_t* value = string->GetValue();
-      for (int i = 0; i < length; i++) {
-        value[i] = high_byte_ + (src[i] & 0xFF);
-      }
-    }
-  }
-
- private:
-  const int32_t count_;
-  Handle<ByteArray> src_array_;
-  const int32_t offset_;
-  const int32_t high_byte_;
-};
-
-// Sets string count and value in the allocation code path to ensure it is guarded by a CAS.
-class SetStringCountAndValueVisitorFromCharArray {
- public:
-  SetStringCountAndValueVisitorFromCharArray(int32_t count, Handle<CharArray> src_array,
-                                             int32_t offset) :
-    count_(count), src_array_(src_array), offset_(offset) {
-  }
-
-  void operator()(ObjPtr<Object> obj, size_t usable_size ATTRIBUTE_UNUSED) const
-      REQUIRES_SHARED(Locks::mutator_lock_) {
-    // Avoid AsString as object is not yet in live bitmap or allocation stack.
-    ObjPtr<String> string = ObjPtr<String>::DownCast(obj);
-    string->SetCount(count_);
-    const uint16_t* const src = src_array_->GetData() + offset_;
-    const int32_t length = String::GetLengthFromCount(count_);
-    if (kUseStringCompression && String::IsCompressed(count_)) {
-      for (int i = 0; i < length; ++i) {
-        string->GetValueCompressed()[i] = static_cast<uint8_t>(src[i]);
-      }
-    } else {
-      memcpy(string->GetValue(), src, length * sizeof(uint16_t));
-    }
-  }
-
- private:
-  const int32_t count_;
-  Handle<CharArray> src_array_;
-  const int32_t offset_;
-};
-
-// Sets string count and value in the allocation code path to ensure it is guarded by a CAS.
-class SetStringCountAndValueVisitorFromString {
- public:
-  SetStringCountAndValueVisitorFromString(int32_t count,
-                                          Handle<String> src_string,
-                                          int32_t offset) :
-    count_(count), src_string_(src_string), offset_(offset) {
-  }
-
-  void operator()(ObjPtr<Object> obj, size_t usable_size ATTRIBUTE_UNUSED) const
-      REQUIRES_SHARED(Locks::mutator_lock_) {
-    // Avoid AsString as object is not yet in live bitmap or allocation stack.
-    ObjPtr<String> string = ObjPtr<String>::DownCast(obj);
-    string->SetCount(count_);
-    const int32_t length = String::GetLengthFromCount(count_);
-    bool compressible = kUseStringCompression && String::IsCompressed(count_);
-    if (src_string_->IsCompressed()) {
-      const uint8_t* const src = src_string_->GetValueCompressed() + offset_;
-      memcpy(string->GetValueCompressed(), src, length * sizeof(uint8_t));
-    } else {
-      const uint16_t* const src = src_string_->GetValue() + offset_;
-      if (compressible) {
-        for (int i = 0; i < length; ++i) {
-          string->GetValueCompressed()[i] = static_cast<uint8_t>(src[i]);
-        }
-      } else {
-        memcpy(string->GetValue(), src, length * sizeof(uint16_t));
-      }
-    }
-  }
-
- private:
-  const int32_t count_;
-  Handle<String> src_string_;
-  const int32_t offset_;
-};
-
 inline uint16_t String::CharAt(int32_t index) {
   int32_t count = GetLength();
   if (UNLIKELY((index < 0) || (index >= count))) {
@@ -195,93 +68,6 @@ int32_t String::FastIndexOf(MemoryType* chars, int32_t ch, int32_t start) {
   return -1;
 }
 
-template <bool kIsInstrumented, typename PreFenceVisitor>
-inline String* String::Alloc(Thread* self, int32_t utf16_length_with_flag,
-                             gc::AllocatorType allocator_type,
-                             const PreFenceVisitor& pre_fence_visitor) {
-  constexpr size_t header_size = sizeof(String);
-  const bool compressible = kUseStringCompression && String::IsCompressed(utf16_length_with_flag);
-  const size_t block_size = (compressible) ? sizeof(uint8_t) : sizeof(uint16_t);
-  size_t length = String::GetLengthFromCount(utf16_length_with_flag);
-  static_assert(sizeof(length) <= sizeof(size_t),
-                "static_cast<size_t>(utf16_length) must not lose bits.");
-  size_t data_size = block_size * length;
-  size_t size = header_size + data_size;
-  // String.equals() intrinsics assume zero-padding up to kObjectAlignment,
-  // so make sure the allocator clears the padding as well.
-  // http://b/23528461
-  size_t alloc_size = RoundUp(size, kObjectAlignment);
-
-  Runtime* runtime = Runtime::Current();
-  ObjPtr<Class> string_class = GetClassRoot<String>(runtime->GetClassLinker());
-  // Check for overflow and throw OutOfMemoryError if this was an unreasonable request.
-  // Do this by comparing with the maximum length that will _not_ cause an overflow.
-  const size_t overflow_length = (-header_size) / block_size;   // Unsigned arithmetic.
-  const size_t max_alloc_length = overflow_length - 1u;
-  static_assert(IsAligned<sizeof(uint16_t)>(kObjectAlignment),
-                "kObjectAlignment must be at least as big as Java char alignment");
-  const size_t max_length = RoundDown(max_alloc_length, kObjectAlignment / block_size);
-  if (UNLIKELY(length > max_length)) {
-    self->ThrowOutOfMemoryError(
-        android::base::StringPrintf("%s of length %d would overflow",
-                                    Class::PrettyDescriptor(string_class).c_str(),
-                                    static_cast<int>(length)).c_str());
-    return nullptr;
-  }
-
-  gc::Heap* heap = runtime->GetHeap();
-  return down_cast<String*>(
-      heap->AllocObjectWithAllocator<kIsInstrumented, true>(self, string_class, alloc_size,
-                                                            allocator_type, pre_fence_visitor));
-}
-
-template <bool kIsInstrumented>
-inline String* String::AllocEmptyString(Thread* self, gc::AllocatorType allocator_type) {
-  const int32_t length_with_flag = String::GetFlaggedCount(0, /* compressible= */ true);
-  SetStringCountVisitor visitor(length_with_flag);
-  return Alloc<kIsInstrumented>(self, length_with_flag, allocator_type, visitor);
-}
-
-template <bool kIsInstrumented>
-inline String* String::AllocFromByteArray(Thread* self, int32_t byte_length,
-                                          Handle<ByteArray> array, int32_t offset,
-                                          int32_t high_byte, gc::AllocatorType allocator_type) {
-  const uint8_t* const src = reinterpret_cast<uint8_t*>(array->GetData()) + offset;
-  high_byte &= 0xff;  // Extract the relevant bits before determining `compressible`.
-  const bool compressible =
-      kUseStringCompression && String::AllASCII<uint8_t>(src, byte_length) && (high_byte == 0);
-  const int32_t length_with_flag = String::GetFlaggedCount(byte_length, compressible);
-  SetStringCountAndBytesVisitor visitor(length_with_flag, array, offset, high_byte << 8);
-  String* string = Alloc<kIsInstrumented>(self, length_with_flag, allocator_type, visitor);
-  return string;
-}
-
-template <bool kIsInstrumented>
-inline String* String::AllocFromCharArray(Thread* self, int32_t count,
-                                          Handle<CharArray> array, int32_t offset,
-                                          gc::AllocatorType allocator_type) {
-  // It is a caller error to have a count less than the actual array's size.
-  DCHECK_GE(array->GetLength(), count);
-  const bool compressible = kUseStringCompression &&
-                            String::AllASCII<uint16_t>(array->GetData() + offset, count);
-  const int32_t length_with_flag = String::GetFlaggedCount(count, compressible);
-  SetStringCountAndValueVisitorFromCharArray visitor(length_with_flag, array, offset);
-  String* new_string = Alloc<kIsInstrumented>(self, length_with_flag, allocator_type, visitor);
-  return new_string;
-}
-
-template <bool kIsInstrumented>
-inline String* String::AllocFromString(Thread* self, int32_t string_length, Handle<String> string,
-                                       int32_t offset, gc::AllocatorType allocator_type) {
-  const bool compressible = kUseStringCompression &&
-      ((string->IsCompressed()) ? true : String::AllASCII<uint16_t>(string->GetValue() + offset,
-                                                                    string_length));
-  const int32_t length_with_flag = String::GetFlaggedCount(string_length, compressible);
-  SetStringCountAndValueVisitorFromString visitor(length_with_flag, string, offset);
-  String* new_string = Alloc<kIsInstrumented>(self, length_with_flag, allocator_type, visitor);
-  return new_string;
-}
-
 inline int32_t String::GetHashCode() {
   int32_t result = GetField32(OFFSET_OF_OBJECT_MEMBER(String, hash_code_));
   if (UNLIKELY(result == 0)) {