1 /*
2  * Copyright (C) 2011 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifndef ART_RUNTIME_MIRROR_STRING_H_
18 #define ART_RUNTIME_MIRROR_STRING_H_
19 
20 #include "base/bit_utils.h"
21 #include "class.h"
22 #include "object.h"
23 #include "runtime_globals.h"
24 
25 namespace art {
26 
27 namespace gc {
28 enum AllocatorType : char;
29 }  // namespace gc
30 
31 template<class T> class Handle;
32 template<class MirrorType> class ObjPtr;
33 class StringBuilderAppend;
34 struct StringOffsets;
35 class StubTest_ReadBarrierForRoot_Test;
36 
37 namespace mirror {
38 
39 // String Compression
40 static constexpr bool kUseStringCompression = true;
41 enum class StringCompressionFlag : uint32_t {
42     kCompressed = 0u,
43     kUncompressed = 1u
44 };
45 
46 // C++ mirror of java.lang.String
47 class MANAGED String final : public Object {
48  public:
49   // Size of java.lang.String.class.
50   static uint32_t ClassSize(PointerSize pointer_size);
51 
52   // Size of an instance of java.lang.String not including its value array.
InstanceSize()53   static constexpr uint32_t InstanceSize() {
54     return sizeof(String);
55   }
56 
CountOffset()57   static constexpr MemberOffset CountOffset() {
58     return OFFSET_OF_OBJECT_MEMBER(String, count_);
59   }
60 
ValueOffset()61   static constexpr MemberOffset ValueOffset() {
62     return OFFSET_OF_OBJECT_MEMBER(String, value_);
63   }
64 
GetValue()65   uint16_t* GetValue() REQUIRES_SHARED(Locks::mutator_lock_) {
66     return &value_[0];
67   }
68 
GetValueCompressed()69   uint8_t* GetValueCompressed() REQUIRES_SHARED(Locks::mutator_lock_) {
70     return &value_compressed_[0];
71   }
72 
73   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
SizeOf()74   size_t SizeOf() REQUIRES_SHARED(Locks::mutator_lock_) {
75     size_t size = sizeof(String);
76     if (IsCompressed()) {
77       size += (sizeof(uint8_t) * GetLength<kVerifyFlags>());
78     } else {
79       size += (sizeof(uint16_t) * GetLength<kVerifyFlags>());
80     }
81     // String.equals() intrinsics assume zero-padding up to kObjectAlignment,
82     // so make sure the zero-padding is actually copied around if GC compaction
83     // chooses to copy only SizeOf() bytes.
84     // http://b/23528461
85     return RoundUp(size, kObjectAlignment);
86   }
87 
88   // Taking out the first/uppermost bit because it is not part of actual length value
89   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
GetLength()90   int32_t GetLength() REQUIRES_SHARED(Locks::mutator_lock_) {
91     return GetLengthFromCount(GetCount<kVerifyFlags>());
92   }
93 
94   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
GetCount()95   int32_t GetCount() REQUIRES_SHARED(Locks::mutator_lock_) {
96     return GetField32<kVerifyFlags>(OFFSET_OF_OBJECT_MEMBER(String, count_));
97   }
98 
SetCount(int32_t new_count)99   void SetCount(int32_t new_count) REQUIRES_SHARED(Locks::mutator_lock_) {
100     // Count is invariant so use non-transactional mode. Also disable check as we may run inside
101     // a transaction.
102     SetField32<false, false>(OFFSET_OF_OBJECT_MEMBER(String, count_), new_count);
103   }
104 
105   int32_t GetHashCode() REQUIRES_SHARED(Locks::mutator_lock_);
106 
107   // Computes, stores, and returns the hash code.
108   int32_t ComputeHashCode() REQUIRES_SHARED(Locks::mutator_lock_);
109 
110   int32_t GetUtfLength() REQUIRES_SHARED(Locks::mutator_lock_);
111 
112   uint16_t CharAt(int32_t index) REQUIRES_SHARED(Locks::mutator_lock_);
113 
114   // Create a new string where all occurences of `old_c` are replaced with `new_c`.
115   // String.doReplace(char, char) is called from String.replace(char, char) when there is a match.
116   static ObjPtr<String> DoReplace(Thread* self, Handle<String> src, uint16_t old_c, uint16_t new_c)
117       REQUIRES_SHARED(Locks::mutator_lock_);
118 
119   ObjPtr<String> Intern() REQUIRES_SHARED(Locks::mutator_lock_);
120 
121   template <bool kIsInstrumented = true>
122   ALWAYS_INLINE static ObjPtr<String> AllocFromByteArray(Thread* self,
123                                                          int32_t byte_length,
124                                                          Handle<ByteArray> array,
125                                                          int32_t offset,
126                                                          int32_t high_byte,
127                                                          gc::AllocatorType allocator_type)
128       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
129 
130   template <bool kIsInstrumented = true>
131   ALWAYS_INLINE static ObjPtr<String> AllocFromCharArray(Thread* self,
132                                                          int32_t count,
133                                                          Handle<CharArray> array,
134                                                          int32_t offset,
135                                                          gc::AllocatorType allocator_type)
136       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
137 
138   template <bool kIsInstrumented = true>
139   ALWAYS_INLINE static ObjPtr<String> AllocFromString(Thread* self,
140                                                       int32_t string_length,
141                                                       Handle<String> string,
142                                                       int32_t offset,
143                                                       gc::AllocatorType allocator_type)
144       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
145 
146   template <bool kIsInstrumented = true>
147   ALWAYS_INLINE static ObjPtr<String> AllocEmptyString(Thread* self,
148                                                        gc::AllocatorType allocator_type)
149       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
150 
151   static ObjPtr<String> AllocFromStrings(Thread* self,
152                                          Handle<String> string,
153                                          Handle<String> string2)
154       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
155 
156   static ObjPtr<String> AllocFromUtf16(Thread* self,
157                                        int32_t utf16_length,
158                                        const uint16_t* utf16_data_in)
159       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
160 
161   static ObjPtr<String> AllocFromModifiedUtf8(Thread* self, const char* utf)
162       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
163 
164   static ObjPtr<String> AllocFromModifiedUtf8(Thread* self,
165                                               int32_t utf16_length,
166                                               const char* utf8_data_in,
167                                               int32_t utf8_length)
168       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
169 
170   static ObjPtr<String> AllocFromModifiedUtf8(Thread* self,
171                                               int32_t utf16_length,
172                                               const char* utf8_data_in)
173       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
174 
175   bool Equals(const char* modified_utf8) REQUIRES_SHARED(Locks::mutator_lock_);
176 
177   bool Equals(ObjPtr<String> that) REQUIRES_SHARED(Locks::mutator_lock_);
178 
179   // Create a modified UTF-8 encoded std::string from a java/lang/String object.
180   std::string ToModifiedUtf8() REQUIRES_SHARED(Locks::mutator_lock_);
181 
182   int32_t FastIndexOf(int32_t ch, int32_t start) REQUIRES_SHARED(Locks::mutator_lock_);
183 
184   template <typename MemoryType>
185   int32_t FastIndexOf(MemoryType* chars, int32_t ch, int32_t start)
186       REQUIRES_SHARED(Locks::mutator_lock_);
187 
188   int32_t CompareTo(ObjPtr<String> other) REQUIRES_SHARED(Locks::mutator_lock_);
189 
190   static ObjPtr<CharArray> ToCharArray(Handle<String> h_this, Thread* self)
191       REQUIRES_SHARED(Locks::mutator_lock_)
192       REQUIRES(!Roles::uninterruptible_);
193 
194   void GetChars(int32_t start, int32_t end, Handle<CharArray> array, int32_t index)
195       REQUIRES_SHARED(Locks::mutator_lock_);
196 
197   template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
IsCompressed()198   bool IsCompressed() REQUIRES_SHARED(Locks::mutator_lock_) {
199     return kUseStringCompression && IsCompressed(GetCount());
200   }
201 
202   bool IsValueNull() REQUIRES_SHARED(Locks::mutator_lock_);
203 
204   template<typename MemoryType>
205   static bool AllASCII(const MemoryType* chars, const int length);
206 
207   static bool DexFileStringAllASCII(const char* chars, const int length);
208 
IsCompressed(int32_t count)209   ALWAYS_INLINE static bool IsCompressed(int32_t count) {
210     return GetCompressionFlagFromCount(count) == StringCompressionFlag::kCompressed;
211   }
212 
GetCompressionFlagFromCount(int32_t count)213   ALWAYS_INLINE static StringCompressionFlag GetCompressionFlagFromCount(int32_t count) {
214     return kUseStringCompression
215         ? static_cast<StringCompressionFlag>(static_cast<uint32_t>(count) & 1u)
216         : StringCompressionFlag::kUncompressed;
217   }
218 
GetLengthFromCount(int32_t count)219   ALWAYS_INLINE static int32_t GetLengthFromCount(int32_t count) {
220     return kUseStringCompression ? static_cast<int32_t>(static_cast<uint32_t>(count) >> 1) : count;
221   }
222 
GetFlaggedCount(int32_t length,bool compressible)223   ALWAYS_INLINE static int32_t GetFlaggedCount(int32_t length, bool compressible) {
224     return kUseStringCompression
225         ? static_cast<int32_t>((static_cast<uint32_t>(length) << 1) |
226                                (static_cast<uint32_t>(compressible
227                                                           ? StringCompressionFlag::kCompressed
228                                                           : StringCompressionFlag::kUncompressed)))
229         : length;
230   }
231 
232   // Returns a human-readable equivalent of 'descriptor'. So "I" would be "int",
233   // "[[I" would be "int[][]", "[Ljava/lang/String;" would be
234   // "java.lang.String[]", and so forth.
235   static std::string PrettyStringDescriptor(ObjPtr<mirror::String> descriptor)
236       REQUIRES_SHARED(Locks::mutator_lock_);
237   std::string PrettyStringDescriptor()
238       REQUIRES_SHARED(Locks::mutator_lock_);
239 
240  private:
IsASCII(uint16_t c)241   static constexpr bool IsASCII(uint16_t c) {
242     // Valid ASCII characters are in range 1..0x7f. Zero is not considered ASCII
243     // because it would complicate the detection of ASCII strings in Modified-UTF8.
244     return (c - 1u) < 0x7fu;
245   }
246 
247   static bool AllASCIIExcept(const uint16_t* chars, int32_t length, uint16_t non_ascii);
248 
SetHashCode(int32_t new_hash_code)249   void SetHashCode(int32_t new_hash_code) REQUIRES_SHARED(Locks::mutator_lock_) {
250     // Hash code is invariant so use non-transactional mode. Also disable check as we may run inside
251     // a transaction.
252     DCHECK_EQ(0, GetField32(OFFSET_OF_OBJECT_MEMBER(String, hash_code_)));
253     SetField32<false, false>(OFFSET_OF_OBJECT_MEMBER(String, hash_code_), new_hash_code);
254   }
255 
256   template <bool kIsInstrumented = true, typename PreFenceVisitor>
257   ALWAYS_INLINE static ObjPtr<String> Alloc(Thread* self,
258                                             int32_t utf16_length_with_flag,
259                                             gc::AllocatorType allocator_type,
260                                             const PreFenceVisitor& pre_fence_visitor)
261       REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
262 
263   // Field order required by test "ValidateFieldOrderOfJavaCppUnionClasses".
264 
265   // If string compression is enabled, count_ holds the StringCompressionFlag in the
266   // least significant bit and the length in the remaining bits, length = count_ >> 1.
267   int32_t count_;
268 
269   uint32_t hash_code_;
270 
271   // Compression of all-ASCII into 8-bit memory leads to usage one of these fields
272   union {
273     uint16_t value_[0];
274     uint8_t value_compressed_[0];
275   };
276 
277   friend class art::StringBuilderAppend;
278   friend struct art::StringOffsets;  // for verifying offset information
279 
280   DISALLOW_IMPLICIT_CONSTRUCTORS(String);
281 };
282 
283 }  // namespace mirror
284 }  // namespace art
285 
286 #endif  // ART_RUNTIME_MIRROR_STRING_H_
287