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_UTILS_H_
18 #define ART_RUNTIME_UTILS_H_
19
20 #include <pthread.h>
21
22 #include <limits>
23 #include <memory>
24 #include <string>
25 #include <vector>
26
27 #include "base/logging.h"
28 #include "base/mutex.h"
29 #include "globals.h"
30 #include "instruction_set.h"
31 #include "primitive.h"
32
33 #ifdef HAVE_ANDROID_OS
34 #include "cutils/properties.h"
35 #endif
36
37 namespace art {
38
39 class DexFile;
40
41 namespace mirror {
42 class ArtField;
43 class ArtMethod;
44 class Class;
45 class Object;
46 class String;
47 } // namespace mirror
48
49 enum TimeUnit {
50 kTimeUnitNanosecond,
51 kTimeUnitMicrosecond,
52 kTimeUnitMillisecond,
53 kTimeUnitSecond,
54 };
55
56 template <typename T>
ParseUint(const char * in,T * out)57 bool ParseUint(const char *in, T* out) {
58 char* end;
59 unsigned long long int result = strtoull(in, &end, 0); // NOLINT(runtime/int)
60 if (in == end || *end != '\0') {
61 return false;
62 }
63 if (std::numeric_limits<T>::max() < result) {
64 return false;
65 }
66 *out = static_cast<T>(result);
67 return true;
68 }
69
70 template <typename T>
ParseInt(const char * in,T * out)71 bool ParseInt(const char* in, T* out) {
72 char* end;
73 long long int result = strtoll(in, &end, 0); // NOLINT(runtime/int)
74 if (in == end || *end != '\0') {
75 return false;
76 }
77 if (result < std::numeric_limits<T>::min() || std::numeric_limits<T>::max() < result) {
78 return false;
79 }
80 *out = static_cast<T>(result);
81 return true;
82 }
83
84 template<typename T>
IsPowerOfTwo(T x)85 static constexpr bool IsPowerOfTwo(T x) {
86 return (x & (x - 1)) == 0;
87 }
88
89 template<int n, typename T>
IsAligned(T x)90 static inline bool IsAligned(T x) {
91 COMPILE_ASSERT((n & (n - 1)) == 0, n_not_power_of_two);
92 return (x & (n - 1)) == 0;
93 }
94
95 template<int n, typename T>
IsAligned(T * x)96 static inline bool IsAligned(T* x) {
97 return IsAligned<n>(reinterpret_cast<const uintptr_t>(x));
98 }
99
100 template<typename T>
IsAlignedParam(T x,int n)101 static inline bool IsAlignedParam(T x, int n) {
102 return (x & (n - 1)) == 0;
103 }
104
105 #define CHECK_ALIGNED(value, alignment) \
106 CHECK(::art::IsAligned<alignment>(value)) << reinterpret_cast<const void*>(value)
107
108 #define DCHECK_ALIGNED(value, alignment) \
109 DCHECK(::art::IsAligned<alignment>(value)) << reinterpret_cast<const void*>(value)
110
111 #define DCHECK_ALIGNED_PARAM(value, alignment) \
112 DCHECK(::art::IsAlignedParam(value, alignment)) << reinterpret_cast<const void*>(value)
113
114 // Check whether an N-bit two's-complement representation can hold value.
IsInt(int N,word value)115 static inline bool IsInt(int N, word value) {
116 CHECK_LT(0, N);
117 CHECK_LT(N, kBitsPerWord);
118 word limit = static_cast<word>(1) << (N - 1);
119 return (-limit <= value) && (value < limit);
120 }
121
IsUint(int N,word value)122 static inline bool IsUint(int N, word value) {
123 CHECK_LT(0, N);
124 CHECK_LT(N, kBitsPerWord);
125 word limit = static_cast<word>(1) << N;
126 return (0 <= value) && (value < limit);
127 }
128
IsAbsoluteUint(int N,word value)129 static inline bool IsAbsoluteUint(int N, word value) {
130 CHECK_LT(0, N);
131 CHECK_LT(N, kBitsPerWord);
132 if (value < 0) value = -value;
133 return IsUint(N, value);
134 }
135
Low16Bits(uint32_t value)136 static inline uint16_t Low16Bits(uint32_t value) {
137 return static_cast<uint16_t>(value);
138 }
139
High16Bits(uint32_t value)140 static inline uint16_t High16Bits(uint32_t value) {
141 return static_cast<uint16_t>(value >> 16);
142 }
143
Low32Bits(uint64_t value)144 static inline uint32_t Low32Bits(uint64_t value) {
145 return static_cast<uint32_t>(value);
146 }
147
High32Bits(uint64_t value)148 static inline uint32_t High32Bits(uint64_t value) {
149 return static_cast<uint32_t>(value >> 32);
150 }
151
152 // A static if which determines whether to return type A or B based on the condition boolean.
153 template <bool condition, typename A, typename B>
154 struct TypeStaticIf {
155 typedef A type;
156 };
157
158 // Specialization to handle the false case.
159 template <typename A, typename B>
160 struct TypeStaticIf<false, A, B> {
161 typedef B type;
162 };
163
164 // Type identity.
165 template <typename T>
166 struct TypeIdentity {
167 typedef T type;
168 };
169
170 // For rounding integers.
171 template<typename T>
172 static constexpr T RoundDown(T x, typename TypeIdentity<T>::type n) WARN_UNUSED;
173
174 template<typename T>
175 static constexpr T RoundDown(T x, typename TypeIdentity<T>::type n) {
176 return
177 DCHECK_CONSTEXPR(IsPowerOfTwo(n), , T(0))
178 (x & -n);
179 }
180
181 template<typename T>
182 static constexpr T RoundUp(T x, typename TypeIdentity<T>::type n) WARN_UNUSED;
183
184 template<typename T>
185 static constexpr T RoundUp(T x, typename TypeIdentity<T>::type n) {
186 return RoundDown(x + n - 1, n);
187 }
188
189 // For aligning pointers.
190 template<typename T>
191 static inline T* AlignDown(T* x, uintptr_t n) WARN_UNUSED;
192
193 template<typename T>
194 static inline T* AlignDown(T* x, uintptr_t n) {
195 return reinterpret_cast<T*>(RoundDown(reinterpret_cast<uintptr_t>(x), n));
196 }
197
198 template<typename T>
199 static inline T* AlignUp(T* x, uintptr_t n) WARN_UNUSED;
200
201 template<typename T>
202 static inline T* AlignUp(T* x, uintptr_t n) {
203 return reinterpret_cast<T*>(RoundUp(reinterpret_cast<uintptr_t>(x), n));
204 }
205
206 // Implementation is from "Hacker's Delight" by Henry S. Warren, Jr.,
207 // figure 3-3, page 48, where the function is called clp2.
208 static inline uint32_t RoundUpToPowerOfTwo(uint32_t x) {
209 x = x - 1;
210 x = x | (x >> 1);
211 x = x | (x >> 2);
212 x = x | (x >> 4);
213 x = x | (x >> 8);
214 x = x | (x >> 16);
215 return x + 1;
216 }
217
218 template<typename T>
219 static constexpr int CLZ(T x) {
220 return (sizeof(T) == sizeof(uint32_t))
221 ? __builtin_clz(x)
222 : __builtin_clzll(x);
223 }
224
225 template<typename T>
226 static constexpr int CTZ(T x) {
227 return (sizeof(T) == sizeof(uint32_t))
228 ? __builtin_ctz(x)
229 : __builtin_ctzll(x);
230 }
231
232 template<typename T>
233 static constexpr int POPCOUNT(T x) {
234 return (sizeof(T) == sizeof(uint32_t))
235 ? __builtin_popcount(x)
236 : __builtin_popcountll(x);
237 }
238
239 static inline uint32_t PointerToLowMemUInt32(const void* p) {
240 uintptr_t intp = reinterpret_cast<uintptr_t>(p);
241 DCHECK_LE(intp, 0xFFFFFFFFU);
242 return intp & 0xFFFFFFFFU;
243 }
244
245 static inline bool NeedsEscaping(uint16_t ch) {
246 return (ch < ' ' || ch > '~');
247 }
248
249 // Interpret the bit pattern of input (type U) as type V. Requires the size
250 // of V >= size of U (compile-time checked).
251 template<typename U, typename V>
252 static inline V bit_cast(U in) {
253 COMPILE_ASSERT(sizeof(U) <= sizeof(V), size_of_u_not_le_size_of_v);
254 union {
255 U u;
256 V v;
257 } tmp;
258 tmp.u = in;
259 return tmp.v;
260 }
261
262 std::string PrintableChar(uint16_t ch);
263
264 // Returns an ASCII string corresponding to the given UTF-8 string.
265 // Java escapes are used for non-ASCII characters.
266 std::string PrintableString(const char* utf8);
267
268 // Tests whether 's' starts with 'prefix'.
269 bool StartsWith(const std::string& s, const char* prefix);
270
271 // Tests whether 's' starts with 'suffix'.
272 bool EndsWith(const std::string& s, const char* suffix);
273
274 // Used to implement PrettyClass, PrettyField, PrettyMethod, and PrettyTypeOf,
275 // one of which is probably more useful to you.
276 // Returns a human-readable equivalent of 'descriptor'. So "I" would be "int",
277 // "[[I" would be "int[][]", "[Ljava/lang/String;" would be
278 // "java.lang.String[]", and so forth.
279 std::string PrettyDescriptor(mirror::String* descriptor)
280 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
281 std::string PrettyDescriptor(const char* descriptor);
282 std::string PrettyDescriptor(mirror::Class* klass)
283 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
284 std::string PrettyDescriptor(Primitive::Type type);
285
286 // Returns a human-readable signature for 'f'. Something like "a.b.C.f" or
287 // "int a.b.C.f" (depending on the value of 'with_type').
288 std::string PrettyField(mirror::ArtField* f, bool with_type = true)
289 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
290 std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type = true);
291
292 // Returns a human-readable signature for 'm'. Something like "a.b.C.m" or
293 // "a.b.C.m(II)V" (depending on the value of 'with_signature').
294 std::string PrettyMethod(mirror::ArtMethod* m, bool with_signature = true)
295 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
296 std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature = true);
297
298 // Returns a human-readable form of the name of the *class* of the given object.
299 // So given an instance of java.lang.String, the output would
300 // be "java.lang.String". Given an array of int, the output would be "int[]".
301 // Given String.class, the output would be "java.lang.Class<java.lang.String>".
302 std::string PrettyTypeOf(mirror::Object* obj)
303 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
304
305 // Returns a human-readable form of the type at an index in the specified dex file.
306 // Example outputs: char[], java.lang.String.
307 std::string PrettyType(uint32_t type_idx, const DexFile& dex_file);
308
309 // Returns a human-readable form of the name of the given class.
310 // Given String.class, the output would be "java.lang.Class<java.lang.String>".
311 std::string PrettyClass(mirror::Class* c)
312 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
313
314 // Returns a human-readable form of the name of the given class with its class loader.
315 std::string PrettyClassAndClassLoader(mirror::Class* c)
316 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
317
318 // Returns a human-readable size string such as "1MB".
319 std::string PrettySize(int64_t size_in_bytes);
320
321 // Returns a human-readable time string which prints every nanosecond while trying to limit the
322 // number of trailing zeros. Prints using the largest human readable unit up to a second.
323 // e.g. "1ms", "1.000000001s", "1.001us"
324 std::string PrettyDuration(uint64_t nano_duration, size_t max_fraction_digits = 3);
325
326 // Format a nanosecond time to specified units.
327 std::string FormatDuration(uint64_t nano_duration, TimeUnit time_unit,
328 size_t max_fraction_digits);
329
330 // Get the appropriate unit for a nanosecond duration.
331 TimeUnit GetAppropriateTimeUnit(uint64_t nano_duration);
332
333 // Get the divisor to convert from a nanoseconds to a time unit.
334 uint64_t GetNsToTimeUnitDivisor(TimeUnit time_unit);
335
336 // Performs JNI name mangling as described in section 11.3 "Linking Native Methods"
337 // of the JNI spec.
338 std::string MangleForJni(const std::string& s);
339
340 // Turn "java.lang.String" into "Ljava/lang/String;".
341 std::string DotToDescriptor(const char* class_name);
342
343 // Turn "Ljava/lang/String;" into "java.lang.String" using the conventions of
344 // java.lang.Class.getName().
345 std::string DescriptorToDot(const char* descriptor);
346
347 // Turn "Ljava/lang/String;" into "java/lang/String" using the opposite conventions of
348 // java.lang.Class.getName().
349 std::string DescriptorToName(const char* descriptor);
350
351 // Tests for whether 's' is a valid class name in the three common forms:
352 bool IsValidBinaryClassName(const char* s); // "java.lang.String"
353 bool IsValidJniClassName(const char* s); // "java/lang/String"
354 bool IsValidDescriptor(const char* s); // "Ljava/lang/String;"
355
356 // Returns whether the given string is a valid field or method name,
357 // additionally allowing names that begin with '<' and end with '>'.
358 bool IsValidMemberName(const char* s);
359
360 // Returns the JNI native function name for the non-overloaded method 'm'.
361 std::string JniShortName(mirror::ArtMethod* m)
362 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
363 // Returns the JNI native function name for the overloaded method 'm'.
364 std::string JniLongName(mirror::ArtMethod* m)
365 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
366
367 bool ReadFileToString(const std::string& file_name, std::string* result);
368
369 // Returns the current date in ISO yyyy-mm-dd hh:mm:ss format.
370 std::string GetIsoDate();
371
372 // Returns the monotonic time since some unspecified starting point in milliseconds.
373 uint64_t MilliTime();
374
375 // Returns the monotonic time since some unspecified starting point in microseconds.
376 uint64_t MicroTime();
377
378 // Returns the monotonic time since some unspecified starting point in nanoseconds.
379 uint64_t NanoTime();
380
381 // Returns the thread-specific CPU-time clock in nanoseconds or -1 if unavailable.
382 uint64_t ThreadCpuNanoTime();
383
384 // Converts the given number of nanoseconds to milliseconds.
385 static constexpr inline uint64_t NsToMs(uint64_t ns) {
386 return ns / 1000 / 1000;
387 }
388
389 // Converts the given number of milliseconds to nanoseconds
390 static constexpr inline uint64_t MsToNs(uint64_t ns) {
391 return ns * 1000 * 1000;
392 }
393
394 #if defined(__APPLE__)
395 // No clocks to specify on OS/X, fake value to pass to routines that require a clock.
396 #define CLOCK_REALTIME 0xebadf00d
397 #endif
398
399 // Sleep for the given number of nanoseconds, a bad way to handle contention.
400 void NanoSleep(uint64_t ns);
401
402 // Initialize a timespec to either an absolute or relative time.
403 void InitTimeSpec(bool absolute, int clock, int64_t ms, int32_t ns, timespec* ts);
404
405 // Splits a string using the given separator character into a vector of
406 // strings. Empty strings will be omitted.
407 void Split(const std::string& s, char separator, std::vector<std::string>& result);
408
409 // Trims whitespace off both ends of the given string.
410 std::string Trim(std::string s);
411
412 // Joins a vector of strings into a single string, using the given separator.
413 template <typename StringT> std::string Join(std::vector<StringT>& strings, char separator);
414
415 // Returns the calling thread's tid. (The C libraries don't expose this.)
416 pid_t GetTid();
417
418 // Returns the given thread's name.
419 std::string GetThreadName(pid_t tid);
420
421 // Returns details of the given thread's stack.
422 void GetThreadStack(pthread_t thread, void** stack_base, size_t* stack_size, size_t* guard_size);
423
424 // Reads data from "/proc/self/task/${tid}/stat".
425 void GetTaskStats(pid_t tid, char* state, int* utime, int* stime, int* task_cpu);
426
427 // Returns the name of the scheduler group for the given thread the current process, or the empty string.
428 std::string GetSchedulerGroupName(pid_t tid);
429
430 // Sets the name of the current thread. The name may be truncated to an
431 // implementation-defined limit.
432 void SetThreadName(const char* thread_name);
433
434 // Dumps the native stack for thread 'tid' to 'os'.
435 void DumpNativeStack(std::ostream& os, pid_t tid, const char* prefix = "",
436 mirror::ArtMethod* current_method = nullptr)
437 NO_THREAD_SAFETY_ANALYSIS;
438
439 // Dumps the kernel stack for thread 'tid' to 'os'. Note that this is only available on linux-x86.
440 void DumpKernelStack(std::ostream& os, pid_t tid, const char* prefix = "", bool include_count = true);
441
442 // Find $ANDROID_ROOT, /system, or abort.
443 const char* GetAndroidRoot();
444
445 // Find $ANDROID_DATA, /data, or abort.
446 const char* GetAndroidData();
447 // Find $ANDROID_DATA, /data, or return nullptr.
448 const char* GetAndroidDataSafe(std::string* error_msg);
449
450 // Returns the dalvik-cache location, or dies trying. subdir will be
451 // appended to the cache location.
452 std::string GetDalvikCacheOrDie(const char* subdir, bool create_if_absent = true);
453 // Return true if we found the dalvik cache and stored it in the dalvik_cache argument.
454 // have_android_data will be set to true if we have an ANDROID_DATA that exists,
455 // dalvik_cache_exists will be true if there is a dalvik-cache directory that is present.
456 // The flag is_global_cache tells whether this cache is /data/dalvik-cache.
457 void GetDalvikCache(const char* subdir, bool create_if_absent, std::string* dalvik_cache,
458 bool* have_android_data, bool* dalvik_cache_exists, bool* is_global_cache);
459
460 // Returns the absolute dalvik-cache path for a DexFile or OatFile. The path returned will be
461 // rooted at cache_location.
462 bool GetDalvikCacheFilename(const char* file_location, const char* cache_location,
463 std::string* filename, std::string* error_msg);
464 // Returns the absolute dalvik-cache path for a DexFile or OatFile, or
465 // dies trying. The path returned will be rooted at cache_location.
466 std::string GetDalvikCacheFilenameOrDie(const char* file_location,
467 const char* cache_location);
468
469 // Returns the system location for an image
470 std::string GetSystemImageFilename(const char* location, InstructionSet isa);
471
472 // Returns an .odex file name next adjacent to the dex location.
473 // For example, for "/foo/bar/baz.jar", return "/foo/bar/<isa>/baz.odex".
474 // Note: does not support multidex location strings.
475 std::string DexFilenameToOdexFilename(const std::string& location, InstructionSet isa);
476
477 // Check whether the given magic matches a known file type.
478 bool IsZipMagic(uint32_t magic);
479 bool IsDexMagic(uint32_t magic);
480 bool IsOatMagic(uint32_t magic);
481
482 // Wrapper on fork/execv to run a command in a subprocess.
483 bool Exec(std::vector<std::string>& arg_vector, std::string* error_msg);
484
485 class VoidFunctor {
486 public:
487 template <typename A>
488 inline void operator() (A a) const {
489 UNUSED(a);
490 }
491
492 template <typename A, typename B>
493 inline void operator() (A a, B b) const {
494 UNUSED(a);
495 UNUSED(b);
496 }
497
498 template <typename A, typename B, typename C>
499 inline void operator() (A a, B b, C c) const {
500 UNUSED(a);
501 UNUSED(b);
502 UNUSED(c);
503 }
504 };
505
506 // Deleter using free() for use with std::unique_ptr<>. See also UniqueCPtr<> below.
507 struct FreeDelete {
508 // NOTE: Deleting a const object is valid but free() takes a non-const pointer.
509 void operator()(const void* ptr) const {
510 free(const_cast<void*>(ptr));
511 }
512 };
513
514 // Alias for std::unique_ptr<> that uses the C function free() to delete objects.
515 template <typename T>
516 using UniqueCPtr = std::unique_ptr<T, FreeDelete>;
517
518 } // namespace art
519
520 #endif // ART_RUNTIME_UTILS_H_
521