| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "string-alloc-inl.h" |
| |
| #include "arch/memcmp16.h" |
| #include "array-alloc-inl.h" |
| #include "base/array_ref.h" |
| #include "base/casts.h" |
| #include "base/stl_util.h" |
| #include "class-inl.h" |
| #include "dex/descriptors_names.h" |
| #include "dex/utf-inl.h" |
| #include "gc/accounting/card_table-inl.h" |
| #include "handle_scope-inl.h" |
| #include "intern_table.h" |
| #include "object-inl.h" |
| #include "runtime.h" |
| #include "string-inl.h" |
| #include "thread.h" |
| |
| namespace art { |
| namespace mirror { |
| |
| int32_t String::FastIndexOf(int32_t ch, int32_t start) { |
| int32_t count = GetLength(); |
| if (start < 0) { |
| start = 0; |
| } else if (start > count) { |
| start = count; |
| } |
| if (IsCompressed()) { |
| return FastIndexOf<uint8_t>(GetValueCompressed(), ch, start); |
| } else { |
| return FastIndexOf<uint16_t>(GetValue(), ch, start); |
| } |
| } |
| |
| int32_t String::ComputeAndSetHashCode() { |
| int32_t new_hash_code = ComputeHashCode(); |
| SetHashCode(new_hash_code); |
| return new_hash_code; |
| } |
| |
| inline bool String::AllASCIIExcept(const uint16_t* chars, int32_t length, uint16_t non_ascii) { |
| DCHECK(!IsASCII(non_ascii)); |
| for (int32_t i = 0; i < length; ++i) { |
| if (!IsASCII(chars[i]) && chars[i] != non_ascii) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| ObjPtr<String> String::DoReplace(Thread* self, Handle<String> src, uint16_t old_c, uint16_t new_c) { |
| int32_t length = src->GetLength(); |
| DCHECK(src->IsCompressed() |
| ? ContainsElement(ArrayRef<uint8_t>(src->value_compressed_, length), old_c) |
| : ContainsElement(ArrayRef<uint16_t>(src->value_, length), old_c)); |
| bool compressible = |
| kUseStringCompression && |
| IsASCII(new_c) && |
| (src->IsCompressed() || (!IsASCII(old_c) && AllASCIIExcept(src->value_, length, old_c))); |
| gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator(); |
| const int32_t length_with_flag = String::GetFlaggedCount(length, compressible); |
| |
| auto visitor = [=](ObjPtr<Object> obj, size_t usable_size) REQUIRES_SHARED(Locks::mutator_lock_) { |
| SetStringCountVisitor set_string_count_visitor(length_with_flag); |
| set_string_count_visitor(obj, usable_size); |
| ObjPtr<String> new_string = obj->AsString(); |
| if (compressible) { |
| auto replace = [old_c, new_c](uint16_t c) { |
| return dchecked_integral_cast<uint8_t>((old_c != c) ? c : new_c); |
| }; |
| uint8_t* out = new_string->value_compressed_; |
| if (LIKELY(src->IsCompressed())) { // LIKELY(compressible == src->IsCompressed()) |
| std::transform(src->value_compressed_, src->value_compressed_ + length, out, replace); |
| } else { |
| std::transform(src->value_, src->value_ + length, out, replace); |
| } |
| DCHECK(kUseStringCompression && AllASCII(out, length)); |
| } else { |
| auto replace = [old_c, new_c](uint16_t c) { |
| return (old_c != c) ? c : new_c; |
| }; |
| uint16_t* out = new_string->value_; |
| if (UNLIKELY(src->IsCompressed())) { // LIKELY(compressible == src->IsCompressed()) |
| std::transform(src->value_compressed_, src->value_compressed_ + length, out, replace); |
| } else { |
| std::transform(src->value_, src->value_ + length, out, replace); |
| } |
| DCHECK_IMPLIES(kUseStringCompression, !AllASCII(out, length)); |
| } |
| }; |
| return Alloc(self, length_with_flag, allocator_type, visitor); |
| } |
| |
| ObjPtr<String> String::DoConcat(Thread* self, Handle<String> h_this, Handle<String> h_arg) { |
| int32_t length_this = h_this->GetLength(); |
| int32_t length_arg = h_arg->GetLength(); |
| gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator(); |
| const bool compressible = |
| kUseStringCompression && (h_this->IsCompressed() && h_arg->IsCompressed()); |
| const int32_t length_with_flag = String::GetFlaggedCount(length_this + length_arg, compressible); |
| |
| auto visitor = [=](ObjPtr<Object> obj, size_t usable_size) REQUIRES_SHARED(Locks::mutator_lock_) { |
| SetStringCountVisitor set_string_count_visitor(length_with_flag); |
| set_string_count_visitor(obj, usable_size); |
| ObjPtr<String> new_string = obj->AsString(); |
| if (compressible) { |
| uint8_t* new_value = new_string->GetValueCompressed(); |
| memcpy(new_value, h_this->GetValueCompressed(), length_this * sizeof(uint8_t)); |
| memcpy(new_value + length_this, h_arg->GetValueCompressed(), length_arg * sizeof(uint8_t)); |
| } else { |
| uint16_t* new_value = new_string->GetValue(); |
| if (h_this->IsCompressed()) { |
| const uint8_t* value_this = h_this->GetValueCompressed(); |
| for (int i = 0; i < length_this; ++i) { |
| new_value[i] = value_this[i]; |
| } |
| } else { |
| memcpy(new_value, h_this->GetValue(), length_this * sizeof(uint16_t)); |
| } |
| if (h_arg->IsCompressed()) { |
| const uint8_t* value_arg = h_arg->GetValueCompressed(); |
| for (int i = 0; i < length_arg; ++i) { |
| new_value[i + length_this] = value_arg[i]; |
| } |
| } else { |
| memcpy(new_value + length_this, h_arg->GetValue(), length_arg * sizeof(uint16_t)); |
| } |
| } |
| }; |
| return Alloc(self, length_with_flag, allocator_type, visitor); |
| } |
| |
| template<typename T> |
| static void RepeatCharacters(ObjPtr<String> new_string, Handle<String> h_this, int32_t count) |
| REQUIRES_SHARED(Locks::mutator_lock_) { |
| T *new_value, *h_this_value; |
| if constexpr (std::is_same_v<T, uint8_t>) { |
| new_value = new_string->GetValueCompressed(); |
| h_this_value = h_this->GetValueCompressed(); |
| } else { |
| new_value = new_string->GetValue(); |
| h_this_value = h_this->GetValue(); |
| } |
| int32_t length_this = h_this->GetLength(); |
| if (length_this == 1) { |
| // compiler is smart enough to use memset for uint8_t |
| std::fill(new_value, new_value + count, h_this_value[0]); |
| } else { |
| memcpy(new_value, h_this_value, length_this * sizeof(T)); |
| int32_t copied = length_this; |
| int32_t limit = length_this * count; |
| for (; copied < limit - copied; copied <<= 1) { |
| memcpy(new_value + copied, new_value, copied * sizeof(T)); |
| } |
| memcpy(new_value + copied, new_value, (limit - copied) * sizeof(T)); |
| } |
| } |
| |
| ObjPtr<String> String::DoRepeat(Thread* self, Handle<String> h_this, int32_t count) { |
| int32_t length_this = h_this->GetLength(); |
| DCHECK_GT(count, 1); |
| DCHECK_LE(length_this, std::numeric_limits<int32_t>::max() / count); |
| gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator(); |
| const bool compressible = kUseStringCompression && (h_this->IsCompressed()); |
| const int32_t length_with_flag = String::GetFlaggedCount(length_this * count, compressible); |
| |
| auto visitor = [=](ObjPtr<Object> obj, size_t usable_size) REQUIRES_SHARED(Locks::mutator_lock_) { |
| SetStringCountVisitor set_string_count_visitor(length_with_flag); |
| set_string_count_visitor(obj, usable_size); |
| ObjPtr<String> new_string = obj->AsString(); |
| |
| if (compressible) { |
| RepeatCharacters<uint8_t>(new_string, h_this, count); |
| } else { |
| RepeatCharacters<uint16_t>(new_string, h_this, count); |
| } |
| }; |
| return Alloc(self, length_with_flag, allocator_type, visitor); |
| } |
| |
| ObjPtr<String> String::AllocFromUtf16(Thread* self, |
| int32_t utf16_length, |
| const uint16_t* utf16_data_in) { |
| CHECK_IMPLIES(utf16_data_in == nullptr, utf16_length == 0); |
| gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator(); |
| const bool compressible = kUseStringCompression && |
| String::AllASCII<uint16_t>(utf16_data_in, utf16_length); |
| int32_t length_with_flag = String::GetFlaggedCount(utf16_length, compressible); |
| |
| auto visitor = [=](ObjPtr<Object> obj, size_t usable_size) REQUIRES_SHARED(Locks::mutator_lock_) { |
| SetStringCountVisitor set_string_count_visitor(length_with_flag); |
| set_string_count_visitor(obj, usable_size); |
| ObjPtr<String> new_string = obj->AsString(); |
| if (compressible) { |
| uint8_t* value = new_string->GetValueCompressed(); |
| for (int i = 0; i < utf16_length; ++i) { |
| value[i] = static_cast<uint8_t>(utf16_data_in[i]); |
| } |
| } else { |
| memcpy(new_string->GetValue(), utf16_data_in, utf16_length * sizeof(uint16_t)); |
| } |
| }; |
| return Alloc(self, length_with_flag, allocator_type, visitor); |
| } |
| |
| ObjPtr<String> String::AllocFromModifiedUtf8(Thread* self, const char* utf) { |
| DCHECK(utf != nullptr); |
| size_t byte_count = strlen(utf); |
| size_t char_count = CountModifiedUtf8Chars(utf, byte_count); |
| return AllocFromModifiedUtf8(self, char_count, utf, byte_count); |
| } |
| |
| ObjPtr<String> String::AllocFromModifiedUtf8(Thread* self, |
| int32_t utf16_length, |
| const char* utf8_data_in) { |
| return AllocFromModifiedUtf8(self, utf16_length, utf8_data_in, strlen(utf8_data_in)); |
| } |
| |
| ObjPtr<String> String::AllocFromModifiedUtf8(Thread* self, |
| int32_t utf16_length, |
| const char* utf8_data_in, |
| int32_t utf8_length) { |
| gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator(); |
| const bool compressible = kUseStringCompression && (utf16_length == utf8_length); |
| const int32_t length_with_flag = String::GetFlaggedCount(utf16_length, compressible); |
| |
| auto visitor = [=](ObjPtr<Object> obj, size_t usable_size) REQUIRES_SHARED(Locks::mutator_lock_) { |
| SetStringCountVisitor set_string_count_visitor(length_with_flag); |
| set_string_count_visitor(obj, usable_size); |
| ObjPtr<String> new_string = obj->AsString(); |
| if (compressible) { |
| memcpy(new_string->GetValueCompressed(), utf8_data_in, utf16_length * sizeof(uint8_t)); |
| } else { |
| uint16_t* utf16_data_out = new_string->GetValue(); |
| ConvertModifiedUtf8ToUtf16(utf16_data_out, utf16_length, utf8_data_in, utf8_length); |
| } |
| }; |
| return Alloc(self, length_with_flag, allocator_type, visitor); |
| } |
| |
| bool String::Equals(ObjPtr<String> that) { |
| if (this == that) { |
| // Quick reference equality test |
| return true; |
| } else if (that == nullptr) { |
| // Null isn't an instanceof anything |
| return false; |
| } else if (this->GetCount() != that->GetCount()) { |
| // Quick length and compression inequality test |
| return false; |
| } else { |
| // Note: don't short circuit on hash code as we're presumably here as the |
| // hash code was already equal |
| if (this->IsCompressed()) { |
| return memcmp(this->GetValueCompressed(), that->GetValueCompressed(), this->GetLength()) == 0; |
| } else { |
| return memcmp(this->GetValue(), that->GetValue(), sizeof(uint16_t) * this->GetLength()) == 0; |
| } |
| } |
| } |
| |
| bool String::Equals(const char* modified_utf8) { |
| const int32_t length = GetLength(); |
| if (IsCompressed()) { |
| return strlen(modified_utf8) == dchecked_integral_cast<uint32_t>(length) && |
| memcmp(modified_utf8, GetValueCompressed(), length) == 0; |
| } |
| const uint16_t* value = GetValue(); |
| int32_t i = 0; |
| while (i < length) { |
| const uint32_t ch = GetUtf16FromUtf8(&modified_utf8); |
| if (ch == '\0') { |
| return false; |
| } |
| |
| if (GetLeadingUtf16Char(ch) != value[i++]) { |
| return false; |
| } |
| |
| const uint16_t trailing = GetTrailingUtf16Char(ch); |
| if (trailing != 0) { |
| if (i == length) { |
| return false; |
| } |
| |
| if (value[i++] != trailing) { |
| return false; |
| } |
| } |
| } |
| return *modified_utf8 == '\0'; |
| } |
| |
| // Create a modified UTF-8 encoded std::string from a java/lang/String object. |
| std::string String::ToModifiedUtf8() { |
| if (IsCompressed()) { |
| return std::string(reinterpret_cast<const char*>(GetValueCompressed()), GetLength()); |
| } else { |
| size_t byte_count = GetUtfLength(); |
| std::string result(byte_count, static_cast<char>(0)); |
| ConvertUtf16ToModifiedUtf8(&result[0], byte_count, GetValue(), GetLength()); |
| return result; |
| } |
| } |
| |
| int32_t String::CompareTo(ObjPtr<String> rhs) { |
| // Quick test for comparison of a string with itself. |
| ObjPtr<String> lhs = this; |
| if (lhs == rhs) { |
| return 0; |
| } |
| int32_t lhs_count = lhs->GetLength(); |
| int32_t rhs_count = rhs->GetLength(); |
| int32_t count_diff = lhs_count - rhs_count; |
| int32_t min_count = (count_diff < 0) ? lhs_count : rhs_count; |
| if (lhs->IsCompressed() && rhs->IsCompressed()) { |
| const uint8_t* lhs_chars = lhs->GetValueCompressed(); |
| const uint8_t* rhs_chars = rhs->GetValueCompressed(); |
| for (int32_t i = 0; i < min_count; ++i) { |
| int32_t char_diff = static_cast<int32_t>(lhs_chars[i]) - static_cast<int32_t>(rhs_chars[i]); |
| if (char_diff != 0) { |
| return char_diff; |
| } |
| } |
| } else if (lhs->IsCompressed() || rhs->IsCompressed()) { |
| const uint8_t* compressed_chars = |
| lhs->IsCompressed() ? lhs->GetValueCompressed() : rhs->GetValueCompressed(); |
| const uint16_t* uncompressed_chars = lhs->IsCompressed() ? rhs->GetValue() : lhs->GetValue(); |
| for (int32_t i = 0; i < min_count; ++i) { |
| int32_t char_diff = |
| static_cast<int32_t>(compressed_chars[i]) - static_cast<int32_t>(uncompressed_chars[i]); |
| if (char_diff != 0) { |
| return lhs->IsCompressed() ? char_diff : -char_diff; |
| } |
| } |
| } else { |
| const uint16_t* lhs_chars = lhs->GetValue(); |
| const uint16_t* rhs_chars = rhs->GetValue(); |
| // FIXME: The MemCmp16() name is misleading. It returns the char difference on mismatch |
| // where memcmp() only guarantees that the returned value has the same sign. |
| int32_t char_diff = MemCmp16(lhs_chars, rhs_chars, min_count); |
| if (char_diff != 0) { |
| return char_diff; |
| } |
| } |
| return count_diff; |
| } |
| |
| ObjPtr<CharArray> String::ToCharArray(Handle<String> h_this, Thread* self) { |
| ObjPtr<CharArray> result = CharArray::Alloc(self, h_this->GetLength()); |
| if (result != nullptr) { |
| if (h_this->IsCompressed()) { |
| int32_t length = h_this->GetLength(); |
| const uint8_t* src = h_this->GetValueCompressed(); |
| uint16_t* dest = result->GetData(); |
| for (int i = 0; i < length; ++i) { |
| dest[i] = src[i]; |
| } |
| } else { |
| memcpy(result->GetData(), h_this->GetValue(), h_this->GetLength() * sizeof(uint16_t)); |
| } |
| } else { |
| self->AssertPendingOOMException(); |
| } |
| return result; |
| } |
| |
| void String::GetChars(int32_t start, int32_t end, Handle<CharArray> array, int32_t index) { |
| uint16_t* data = array->GetData() + index; |
| DCHECK_LE(start, end); |
| int32_t length = end - start; |
| if (IsCompressed()) { |
| const uint8_t* value = GetValueCompressed() + start; |
| for (int i = 0; i < length; ++i) { |
| data[i] = value[i]; |
| } |
| } else { |
| uint16_t* value = GetValue() + start; |
| memcpy(data, value, length * sizeof(uint16_t)); |
| } |
| } |
| |
| void String::FillBytesLatin1(Handle<ByteArray> array, int32_t index) { |
| int8_t* data = array->GetData() + index; |
| int32_t length = GetLength(); |
| if (IsCompressed()) { |
| const uint8_t* value = GetValueCompressed(); |
| memcpy(data, value, length * sizeof(uint8_t)); |
| } else { |
| // Drop the high byte of the characters. |
| // The caller should check that all dropped high bytes are zeros. |
| const uint16_t* value = GetValue(); |
| for (int32_t i = 0; i < length; ++i) { |
| data[i] = static_cast<int8_t>(dchecked_integral_cast<uint8_t>(value[i])); |
| } |
| } |
| } |
| |
| void String::FillBytesUTF16(Handle<ByteArray> array, int32_t index) { |
| int8_t* data = array->GetData() + index; |
| int32_t length = GetLength(); |
| if (IsCompressed()) { |
| const uint8_t* value = GetValueCompressed(); |
| uint32_t d_index = 0; |
| for (int i = 0; i < length; ++i) { |
| data[d_index++] = static_cast<int8_t>(value[i]); |
| data[d_index++] = 0; |
| } |
| } else { |
| const uint16_t* value = GetValue(); |
| memcpy(data, value, length * sizeof(uint16_t)); |
| } |
| } |
| |
| bool String::IsValueNull() { |
| return (IsCompressed()) ? (GetValueCompressed() == nullptr) : (GetValue() == nullptr); |
| } |
| |
| std::string String::PrettyStringDescriptor(ObjPtr<mirror::String> java_descriptor) { |
| if (java_descriptor == nullptr) { |
| return "null"; |
| } |
| return java_descriptor->PrettyStringDescriptor(); |
| } |
| |
| std::string String::PrettyStringDescriptor() { |
| return PrettyDescriptor(ToModifiedUtf8().c_str()); |
| } |
| |
| ObjPtr<String> String::Intern() { |
| return Runtime::Current()->GetInternTable()->InternWeak(this); |
| } |
| |
| } // namespace mirror |
| } // namespace art |