blob: f9622b71107dba2b505cf7801c1ef3fb808634a4 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
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 */
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -070016
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_UTILS_H_
18#define ART_RUNTIME_UTILS_H_
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -070019
Elliott Hughes92b3b562011-09-08 16:32:26 -070020#include <pthread.h>
Elliott Hughese222ee02012-12-13 14:41:43 -080021
Alex Light53cb16b2014-06-12 11:26:29 -070022#include <limits>
Vladimir Markoaa4497d2014-09-05 14:01:17 +010023#include <memory>
Elliott Hughes34023802011-08-30 12:06:17 -070024#include <string>
25#include <vector>
26
Ian Rogersd582fa42014-11-05 23:46:43 -080027#include "arch/instruction_set.h"
Elliott Hughese222ee02012-12-13 14:41:43 -080028#include "base/logging.h"
Ian Rogers68d8b422014-07-17 11:09:10 -070029#include "base/mutex.h"
Elliott Hughese222ee02012-12-13 14:41:43 -080030#include "globals.h"
Ian Rogers68d8b422014-07-17 11:09:10 -070031#include "primitive.h"
Calin Juravlebb0b53f2014-05-23 17:33:29 +010032
Carl Shapiro6b6b5f02011-06-21 15:05:09 -070033namespace art {
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -070034
Ian Rogers0571d352011-11-03 19:51:38 -070035class DexFile;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080036
37namespace mirror {
Brian Carlstromea46f952013-07-30 01:26:50 -070038class ArtField;
39class ArtMethod;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080040class Class;
Elliott Hughes11e45072011-08-16 17:40:46 -070041class Object;
Elliott Hughes5174fe62011-08-23 15:12:35 -070042class String;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080043} // namespace mirror
Elliott Hughes11e45072011-08-16 17:40:46 -070044
Mathieu Chartier0325e622012-09-05 14:22:51 -070045enum TimeUnit {
46 kTimeUnitNanosecond,
47 kTimeUnitMicrosecond,
48 kTimeUnitMillisecond,
49 kTimeUnitSecond,
50};
51
Alex Light53cb16b2014-06-12 11:26:29 -070052template <typename T>
53bool ParseUint(const char *in, T* out) {
54 char* end;
55 unsigned long long int result = strtoull(in, &end, 0); // NOLINT(runtime/int)
56 if (in == end || *end != '\0') {
57 return false;
58 }
59 if (std::numeric_limits<T>::max() < result) {
60 return false;
61 }
62 *out = static_cast<T>(result);
63 return true;
64}
65
66template <typename T>
67bool ParseInt(const char* in, T* out) {
68 char* end;
69 long long int result = strtoll(in, &end, 0); // NOLINT(runtime/int)
70 if (in == end || *end != '\0') {
71 return false;
72 }
73 if (result < std::numeric_limits<T>::min() || std::numeric_limits<T>::max() < result) {
74 return false;
75 }
76 *out = static_cast<T>(result);
77 return true;
78}
79
Carl Shapiroa2e18e12011-06-21 18:57:55 -070080template<typename T>
Vladimir Marko81949632014-05-02 11:53:22 +010081static constexpr bool IsPowerOfTwo(T x) {
Carl Shapiroa2e18e12011-06-21 18:57:55 -070082 return (x & (x - 1)) == 0;
83}
84
Elliott Hughes06b37d92011-10-16 11:51:29 -070085template<int n, typename T>
86static inline bool IsAligned(T x) {
Andreas Gampe575e78c2014-11-03 23:41:03 -080087 static_assert((n & (n - 1)) == 0, "n is not a power of two");
Carl Shapiroa2e18e12011-06-21 18:57:55 -070088 return (x & (n - 1)) == 0;
89}
90
Elliott Hughes06b37d92011-10-16 11:51:29 -070091template<int n, typename T>
92static inline bool IsAligned(T* x) {
Brian Carlstrom89521892011-12-07 22:05:07 -080093 return IsAligned<n>(reinterpret_cast<const uintptr_t>(x));
Carl Shapiroa2e18e12011-06-21 18:57:55 -070094}
95
Andreas Gampeaf13ad92014-04-11 12:07:48 -070096template<typename T>
97static inline bool IsAlignedParam(T x, int n) {
98 return (x & (n - 1)) == 0;
99}
100
Elliott Hughes06b37d92011-10-16 11:51:29 -0700101#define CHECK_ALIGNED(value, alignment) \
Brian Carlstrom89521892011-12-07 22:05:07 -0800102 CHECK(::art::IsAligned<alignment>(value)) << reinterpret_cast<const void*>(value)
Elliott Hughes06b37d92011-10-16 11:51:29 -0700103
104#define DCHECK_ALIGNED(value, alignment) \
Brian Carlstrom89521892011-12-07 22:05:07 -0800105 DCHECK(::art::IsAligned<alignment>(value)) << reinterpret_cast<const void*>(value)
Elliott Hughes06b37d92011-10-16 11:51:29 -0700106
Andreas Gampeaf13ad92014-04-11 12:07:48 -0700107#define DCHECK_ALIGNED_PARAM(value, alignment) \
108 DCHECK(::art::IsAlignedParam(value, alignment)) << reinterpret_cast<const void*>(value)
109
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -0700110// Check whether an N-bit two's-complement representation can hold value.
Ian Rogers13735952014-10-08 12:43:28 -0700111static inline bool IsInt(int N, intptr_t value) {
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -0700112 CHECK_LT(0, N);
Ian Rogers13735952014-10-08 12:43:28 -0700113 CHECK_LT(N, kBitsPerIntPtrT);
114 intptr_t limit = static_cast<intptr_t>(1) << (N - 1);
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -0700115 return (-limit <= value) && (value < limit);
116}
117
Andreas Gampe851df202014-11-12 14:05:46 -0800118static inline bool IsInt32(int N, int32_t value) {
119 CHECK_LT(0, N);
120 CHECK_LT(static_cast<size_t>(N), 8 * sizeof(int32_t));
121 int32_t limit = static_cast<int32_t>(1) << (N - 1);
122 return (-limit <= value) && (value < limit);
123}
124
125static inline bool IsInt64(int N, int64_t value) {
126 CHECK_LT(0, N);
127 CHECK_LT(static_cast<size_t>(N), 8 * sizeof(int64_t));
128 int64_t limit = static_cast<int64_t>(1) << (N - 1);
129 return (-limit <= value) && (value < limit);
130}
131
Ian Rogers13735952014-10-08 12:43:28 -0700132static inline bool IsUint(int N, intptr_t value) {
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -0700133 CHECK_LT(0, N);
Ian Rogers13735952014-10-08 12:43:28 -0700134 CHECK_LT(N, kBitsPerIntPtrT);
135 intptr_t limit = static_cast<intptr_t>(1) << N;
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -0700136 return (0 <= value) && (value < limit);
137}
138
Ian Rogers13735952014-10-08 12:43:28 -0700139static inline bool IsAbsoluteUint(int N, intptr_t value) {
Carl Shapiroa2e18e12011-06-21 18:57:55 -0700140 CHECK_LT(0, N);
Ian Rogers13735952014-10-08 12:43:28 -0700141 CHECK_LT(N, kBitsPerIntPtrT);
Carl Shapiroa2e18e12011-06-21 18:57:55 -0700142 if (value < 0) value = -value;
143 return IsUint(N, value);
144}
145
buzbee4ef3e452012-12-14 13:35:28 -0800146static inline uint16_t Low16Bits(uint32_t value) {
147 return static_cast<uint16_t>(value);
Ian Rogersb033c752011-07-20 12:22:35 -0700148}
149
buzbee4ef3e452012-12-14 13:35:28 -0800150static inline uint16_t High16Bits(uint32_t value) {
151 return static_cast<uint16_t>(value >> 16);
Ian Rogersb033c752011-07-20 12:22:35 -0700152}
Carl Shapiroa2e18e12011-06-21 18:57:55 -0700153
buzbee4ef3e452012-12-14 13:35:28 -0800154static inline uint32_t Low32Bits(uint64_t value) {
155 return static_cast<uint32_t>(value);
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -0700156}
157
buzbee4ef3e452012-12-14 13:35:28 -0800158static inline uint32_t High32Bits(uint64_t value) {
159 return static_cast<uint32_t>(value >> 32);
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -0700160}
161
Vladimir Marko81949632014-05-02 11:53:22 +0100162// Type identity.
163template <typename T>
164struct TypeIdentity {
165 typedef T type;
Mathieu Chartier0a9dc052013-07-25 11:01:28 -0700166};
167
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800168// Like sizeof, but count how many bits a type takes. Pass type explicitly.
169template <typename T>
170static constexpr size_t BitSizeOf() {
171 return sizeof(T) * CHAR_BIT;
172}
173
174// Like sizeof, but count how many bits a type takes. Infers type from parameter.
175template <typename T>
176static constexpr size_t BitSizeOf(T /*x*/) {
177 return sizeof(T) * CHAR_BIT;
178}
179
Hiroshi Yamauchi0941b042013-11-05 11:34:03 -0800180// For rounding integers.
Carl Shapiro61e019d2011-07-14 16:53:09 -0700181template<typename T>
Mathieu Chartier4c13a3f2014-07-14 14:57:16 -0700182static constexpr T RoundDown(T x, typename TypeIdentity<T>::type n) WARN_UNUSED;
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700183
184template<typename T>
Vladimir Marko81949632014-05-02 11:53:22 +0100185static constexpr T RoundDown(T x, typename TypeIdentity<T>::type n) {
186 return
Vladimir Marko83642482014-06-11 12:12:07 +0100187 DCHECK_CONSTEXPR(IsPowerOfTwo(n), , T(0))
188 (x & -n);
Carl Shapiro61e019d2011-07-14 16:53:09 -0700189}
190
191template<typename T>
Mathieu Chartier4c13a3f2014-07-14 14:57:16 -0700192static constexpr T RoundUp(T x, typename TypeIdentity<T>::type n) WARN_UNUSED;
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700193
194template<typename T>
Vladimir Marko81949632014-05-02 11:53:22 +0100195static constexpr T RoundUp(T x, typename TypeIdentity<T>::type n) {
Carl Shapiro61e019d2011-07-14 16:53:09 -0700196 return RoundDown(x + n - 1, n);
197}
198
Hiroshi Yamauchi0941b042013-11-05 11:34:03 -0800199// For aligning pointers.
200template<typename T>
Mathieu Chartier4c13a3f2014-07-14 14:57:16 -0700201static inline T* AlignDown(T* x, uintptr_t n) WARN_UNUSED;
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700202
203template<typename T>
Vladimir Marko81949632014-05-02 11:53:22 +0100204static inline T* AlignDown(T* x, uintptr_t n) {
205 return reinterpret_cast<T*>(RoundDown(reinterpret_cast<uintptr_t>(x), n));
Hiroshi Yamauchi0941b042013-11-05 11:34:03 -0800206}
207
208template<typename T>
Mathieu Chartier4c13a3f2014-07-14 14:57:16 -0700209static inline T* AlignUp(T* x, uintptr_t n) WARN_UNUSED;
Mingyao Yang98d1cc82014-05-15 17:02:16 -0700210
211template<typename T>
Vladimir Marko81949632014-05-02 11:53:22 +0100212static inline T* AlignUp(T* x, uintptr_t n) {
213 return reinterpret_cast<T*>(RoundUp(reinterpret_cast<uintptr_t>(x), n));
Hiroshi Yamauchi0941b042013-11-05 11:34:03 -0800214}
215
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800216namespace utils {
217namespace detail { // Private, implementation-specific namespace. Do not poke outside of this file.
218template <typename T>
219static constexpr inline T RoundUpToPowerOfTwoRecursive(T x, size_t bit) {
220 return bit == (BitSizeOf<T>()) ? x: RoundUpToPowerOfTwoRecursive(x | x >> bit, bit << 1);
221}
222} // namespace detail
223} // namespace utils
224
225// Recursive implementation is from "Hacker's Delight" by Henry S. Warren, Jr.,
226// figure 3-3, page 48, where the function is called clp2.
227template <typename T>
228static constexpr inline T RoundUpToPowerOfTwo(T x) {
229 return art::utils::detail::RoundUpToPowerOfTwoRecursive(x - 1, 1) + 1;
230}
231
232// Find the bit position of the most significant bit (0-based), or -1 if there were no bits set.
233template <typename T>
234static constexpr ssize_t MostSignificantBit(T value) {
235 return (value == 0) ? -1 : (MostSignificantBit(value >> 1) + 1);
236}
237
238// How many bits (minimally) does it take to store the constant 'value'? i.e. 1 for 1, 3 for 5, etc.
239template <typename T>
240static constexpr size_t MinimumBitsToStore(T value) {
241 return static_cast<size_t>(MostSignificantBit(value) + 1);
242}
243
Vladimir Marko81949632014-05-02 11:53:22 +0100244template<typename T>
245static constexpr int CLZ(T x) {
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800246 static_assert(sizeof(T) <= sizeof(long long), "T too large, must be smaller than long long"); // NOLINT [runtime/int] [4]
Vladimir Marko81949632014-05-02 11:53:22 +0100247 return (sizeof(T) == sizeof(uint32_t))
Igor Murashkinf5b4c502014-11-14 15:01:59 -0800248 ? __builtin_clz(x) // TODO: __builtin_clz[ll] has undefined behavior for x=0
Vladimir Marko81949632014-05-02 11:53:22 +0100249 : __builtin_clzll(x);
Carl Shapiroa2e18e12011-06-21 18:57:55 -0700250}
251
Ian Rogersef7d42f2014-01-06 12:55:46 -0800252template<typename T>
Vladimir Marko81949632014-05-02 11:53:22 +0100253static constexpr int CTZ(T x) {
254 return (sizeof(T) == sizeof(uint32_t))
255 ? __builtin_ctz(x)
256 : __builtin_ctzll(x);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800257}
258
259template<typename T>
Vladimir Marko81949632014-05-02 11:53:22 +0100260static constexpr int POPCOUNT(T x) {
261 return (sizeof(T) == sizeof(uint32_t))
262 ? __builtin_popcount(x)
263 : __builtin_popcountll(x);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800264}
265
266static inline uint32_t PointerToLowMemUInt32(const void* p) {
267 uintptr_t intp = reinterpret_cast<uintptr_t>(p);
268 DCHECK_LE(intp, 0xFFFFFFFFU);
269 return intp & 0xFFFFFFFFU;
270}
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700271
Elliott Hughes46b92ba2011-08-12 17:57:34 -0700272static inline bool NeedsEscaping(uint16_t ch) {
273 return (ch < ' ' || ch > '~');
274}
275
Andreas Gampec200a4a2014-06-16 18:39:09 -0700276// Interpret the bit pattern of input (type U) as type V. Requires the size
277// of V >= size of U (compile-time checked).
278template<typename U, typename V>
279static inline V bit_cast(U in) {
Andreas Gampe575e78c2014-11-03 23:41:03 -0800280 static_assert(sizeof(U) <= sizeof(V), "Size of U not <= size of V");
Andreas Gampec200a4a2014-06-16 18:39:09 -0700281 union {
282 U u;
283 V v;
284 } tmp;
285 tmp.u = in;
286 return tmp.v;
287}
288
Ian Rogers576ca0c2014-06-06 15:58:22 -0700289std::string PrintableChar(uint16_t ch);
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700290
Elliott Hughes82914b62012-04-09 15:56:29 -0700291// Returns an ASCII string corresponding to the given UTF-8 string.
292// Java escapes are used for non-ASCII characters.
Ian Rogers68b56852014-08-29 20:19:11 -0700293std::string PrintableString(const char* utf8);
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700294
Elliott Hughesf1a5adc2012-02-10 18:09:35 -0800295// Tests whether 's' starts with 'prefix'.
296bool StartsWith(const std::string& s, const char* prefix);
297
Brian Carlstrom7a967b32012-03-28 15:23:10 -0700298// Tests whether 's' starts with 'suffix'.
299bool EndsWith(const std::string& s, const char* suffix);
300
Elliott Hughes54e7df12011-09-16 11:47:04 -0700301// Used to implement PrettyClass, PrettyField, PrettyMethod, and PrettyTypeOf,
302// one of which is probably more useful to you.
Elliott Hughesa0b8feb2011-08-20 09:50:55 -0700303// Returns a human-readable equivalent of 'descriptor'. So "I" would be "int",
304// "[[I" would be "int[][]", "[Ljava/lang/String;" would be
305// "java.lang.String[]", and so forth.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800306std::string PrettyDescriptor(mirror::String* descriptor)
307 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers1ff3c982014-08-12 02:30:58 -0700308std::string PrettyDescriptor(const char* descriptor);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800309std::string PrettyDescriptor(mirror::Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700310 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers68d8b422014-07-17 11:09:10 -0700311std::string PrettyDescriptor(Primitive::Type type);
Elliott Hughes11e45072011-08-16 17:40:46 -0700312
Elliott Hughes54e7df12011-09-16 11:47:04 -0700313// Returns a human-readable signature for 'f'. Something like "a.b.C.f" or
314// "int a.b.C.f" (depending on the value of 'with_type').
Ian Rogersef7d42f2014-01-06 12:55:46 -0800315std::string PrettyField(mirror::ArtField* f, bool with_type = true)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700316 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom6f29d0e2012-05-11 15:50:29 -0700317std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type = true);
Elliott Hughesa2501992011-08-26 19:39:54 -0700318
Elliott Hughesa0b8feb2011-08-20 09:50:55 -0700319// Returns a human-readable signature for 'm'. Something like "a.b.C.m" or
320// "a.b.C.m(II)V" (depending on the value of 'with_signature').
Ian Rogersef7d42f2014-01-06 12:55:46 -0800321std::string PrettyMethod(mirror::ArtMethod* m, bool with_signature = true)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700322 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -0700323std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature = true);
Elliott Hughesa0b8feb2011-08-20 09:50:55 -0700324
325// Returns a human-readable form of the name of the *class* of the given object.
326// So given an instance of java.lang.String, the output would
Elliott Hughes11e45072011-08-16 17:40:46 -0700327// be "java.lang.String". Given an array of int, the output would be "int[]".
328// Given String.class, the output would be "java.lang.Class<java.lang.String>".
Ian Rogersef7d42f2014-01-06 12:55:46 -0800329std::string PrettyTypeOf(mirror::Object* obj)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700330 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier4c70d772012-09-10 14:08:32 -0700331
332// Returns a human-readable form of the type at an index in the specified dex file.
333// Example outputs: char[], java.lang.String.
Mathieu Chartier18c24b62012-09-10 08:54:25 -0700334std::string PrettyType(uint32_t type_idx, const DexFile& dex_file);
Elliott Hughes54e7df12011-09-16 11:47:04 -0700335
336// Returns a human-readable form of the name of the given class.
337// Given String.class, the output would be "java.lang.Class<java.lang.String>".
Ian Rogersef7d42f2014-01-06 12:55:46 -0800338std::string PrettyClass(mirror::Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700339 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes11e45072011-08-16 17:40:46 -0700340
Ian Rogersd81871c2011-10-03 13:57:23 -0700341// Returns a human-readable form of the name of the given class with its class loader.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800342std::string PrettyClassAndClassLoader(mirror::Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700343 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersd81871c2011-10-03 13:57:23 -0700344
Andreas Gampec0d82292014-09-23 10:38:30 -0700345// Returns a human-readable version of the Java part of the access flags, e.g., "private static "
346// (note the trailing whitespace).
347std::string PrettyJavaAccessFlags(uint32_t access_flags);
348
Elliott Hughesc967f782012-04-16 10:23:15 -0700349// Returns a human-readable size string such as "1MB".
Mathieu Chartiere6da9af2013-12-16 11:54:42 -0800350std::string PrettySize(int64_t size_in_bytes);
Ian Rogers3bb17a62012-01-27 23:56:44 -0800351
352// Returns a human-readable time string which prints every nanosecond while trying to limit the
353// number of trailing zeros. Prints using the largest human readable unit up to a second.
354// e.g. "1ms", "1.000000001s", "1.001us"
Mathieu Chartierf5997b42014-06-20 10:37:54 -0700355std::string PrettyDuration(uint64_t nano_duration, size_t max_fraction_digits = 3);
Ian Rogers3bb17a62012-01-27 23:56:44 -0800356
Mathieu Chartier0325e622012-09-05 14:22:51 -0700357// Format a nanosecond time to specified units.
Mathieu Chartierf5997b42014-06-20 10:37:54 -0700358std::string FormatDuration(uint64_t nano_duration, TimeUnit time_unit,
359 size_t max_fraction_digits);
Mathieu Chartier0325e622012-09-05 14:22:51 -0700360
361// Get the appropriate unit for a nanosecond duration.
362TimeUnit GetAppropriateTimeUnit(uint64_t nano_duration);
363
Dave Allison70202782013-10-22 17:52:19 -0700364// Get the divisor to convert from a nanoseconds to a time unit.
Mathieu Chartier0325e622012-09-05 14:22:51 -0700365uint64_t GetNsToTimeUnitDivisor(TimeUnit time_unit);
366
Elliott Hughes79082e32011-08-25 12:07:32 -0700367// Performs JNI name mangling as described in section 11.3 "Linking Native Methods"
368// of the JNI spec.
369std::string MangleForJni(const std::string& s);
370
Brian Carlstromf91c8c32011-09-21 17:30:34 -0700371// Turn "java.lang.String" into "Ljava/lang/String;".
372std::string DotToDescriptor(const char* class_name);
373
Ian Rogers1ff3c982014-08-12 02:30:58 -0700374// Turn "Ljava/lang/String;" into "java.lang.String" using the conventions of
375// java.lang.Class.getName().
Elliott Hughesf1a5adc2012-02-10 18:09:35 -0800376std::string DescriptorToDot(const char* descriptor);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700377
Ian Rogers1ff3c982014-08-12 02:30:58 -0700378// Turn "Ljava/lang/String;" into "java/lang/String" using the opposite conventions of
379// java.lang.Class.getName().
Elliott Hughes91bf6cd2012-02-14 17:27:48 -0800380std::string DescriptorToName(const char* descriptor);
381
Elliott Hughes906e6852011-10-28 14:52:10 -0700382// Tests for whether 's' is a valid class name in the three common forms:
383bool IsValidBinaryClassName(const char* s); // "java.lang.String"
384bool IsValidJniClassName(const char* s); // "java/lang/String"
385bool IsValidDescriptor(const char* s); // "Ljava/lang/String;"
Elliott Hughes64bf5a32011-09-20 14:43:12 -0700386
jeffhao10037c82012-01-23 15:06:23 -0800387// Returns whether the given string is a valid field or method name,
388// additionally allowing names that begin with '<' and end with '>'.
389bool IsValidMemberName(const char* s);
390
Elliott Hughes79082e32011-08-25 12:07:32 -0700391// Returns the JNI native function name for the non-overloaded method 'm'.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800392std::string JniShortName(mirror::ArtMethod* m)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700393 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes79082e32011-08-25 12:07:32 -0700394// Returns the JNI native function name for the overloaded method 'm'.
Ian Rogersef7d42f2014-01-06 12:55:46 -0800395std::string JniLongName(mirror::ArtMethod* m)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700396 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes79082e32011-08-25 12:07:32 -0700397
Elliott Hughesd92bec42011-09-02 17:04:36 -0700398bool ReadFileToString(const std::string& file_name, std::string* result);
buzbeec143c552011-08-20 17:38:58 -0700399
Elliott Hughese27955c2011-08-26 15:21:24 -0700400// Returns the current date in ISO yyyy-mm-dd hh:mm:ss format.
401std::string GetIsoDate();
402
Elliott Hughes0512f022012-03-15 22:10:52 -0700403// Returns the monotonic time since some unspecified starting point in milliseconds.
Elliott Hughes7162ad92011-10-27 14:08:42 -0700404uint64_t MilliTime();
405
Elliott Hughes0512f022012-03-15 22:10:52 -0700406// Returns the monotonic time since some unspecified starting point in microseconds.
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800407uint64_t MicroTime();
408
Elliott Hughes0512f022012-03-15 22:10:52 -0700409// Returns the monotonic time since some unspecified starting point in nanoseconds.
Elliott Hughes83df2ac2011-10-11 16:37:54 -0700410uint64_t NanoTime();
411
Elliott Hughes0512f022012-03-15 22:10:52 -0700412// Returns the thread-specific CPU-time clock in nanoseconds or -1 if unavailable.
413uint64_t ThreadCpuNanoTime();
414
Elliott Hughesbb551fa2012-01-25 16:35:29 -0800415// Converts the given number of nanoseconds to milliseconds.
Mathieu Chartier720ef762013-08-17 14:46:54 -0700416static constexpr inline uint64_t NsToMs(uint64_t ns) {
Ian Rogers3bb17a62012-01-27 23:56:44 -0800417 return ns / 1000 / 1000;
418}
419
420// Converts the given number of milliseconds to nanoseconds
Mathieu Chartier720ef762013-08-17 14:46:54 -0700421static constexpr inline uint64_t MsToNs(uint64_t ns) {
Ian Rogers3bb17a62012-01-27 23:56:44 -0800422 return ns * 1000 * 1000;
423}
424
Brian Carlstrombcc29262012-11-02 11:36:03 -0700425#if defined(__APPLE__)
426// No clocks to specify on OS/X, fake value to pass to routines that require a clock.
427#define CLOCK_REALTIME 0xebadf00d
428#endif
429
Ian Rogers56edc432013-01-18 16:51:51 -0800430// Sleep for the given number of nanoseconds, a bad way to handle contention.
431void NanoSleep(uint64_t ns);
432
Hans Boehm5567c112014-12-02 18:31:31 -0800433// Initialize a timespec to either a relative time (ms,ns), or to the absolute
434// time corresponding to the indicated clock value plus the supplied offset.
Brian Carlstrombcc29262012-11-02 11:36:03 -0700435void InitTimeSpec(bool absolute, int clock, int64_t ms, int32_t ns, timespec* ts);
436
Elliott Hughes48436bb2012-02-07 15:23:28 -0800437// Splits a string using the given separator character into a vector of
Elliott Hughes34023802011-08-30 12:06:17 -0700438// strings. Empty strings will be omitted.
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700439void Split(const std::string& s, char separator, std::vector<std::string>* result);
Elliott Hughes48436bb2012-02-07 15:23:28 -0800440
Dave Allison70202782013-10-22 17:52:19 -0700441// Trims whitespace off both ends of the given string.
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700442std::string Trim(const std::string& s);
Dave Allison70202782013-10-22 17:52:19 -0700443
Elliott Hughes48436bb2012-02-07 15:23:28 -0800444// Joins a vector of strings into a single string, using the given separator.
Ian Rogers6f3dbba2014-10-14 17:41:57 -0700445template <typename StringT> std::string Join(const std::vector<StringT>& strings, char separator);
Elliott Hughes34023802011-08-30 12:06:17 -0700446
Elliott Hughes42ee1422011-09-06 12:33:32 -0700447// Returns the calling thread's tid. (The C libraries don't expose this.)
448pid_t GetTid();
449
Elliott Hughes289be852012-06-12 13:57:20 -0700450// Returns the given thread's name.
451std::string GetThreadName(pid_t tid);
452
Ian Rogers120f1c72012-09-28 17:17:10 -0700453// Returns details of the given thread's stack.
Elliott Hughes6d3fc562014-08-27 11:47:01 -0700454void GetThreadStack(pthread_t thread, void** stack_base, size_t* stack_size, size_t* guard_size);
Elliott Hughese1884192012-04-23 12:38:15 -0700455
Elliott Hughesbfe487b2011-10-26 15:48:55 -0700456// Reads data from "/proc/self/task/${tid}/stat".
Brian Carlstrom29212012013-09-12 22:18:30 -0700457void GetTaskStats(pid_t tid, char* state, int* utime, int* stime, int* task_cpu);
Elliott Hughesbfe487b2011-10-26 15:48:55 -0700458
Elliott Hughes1bac54f2012-03-16 12:48:31 -0700459// Returns the name of the scheduler group for the given thread the current process, or the empty string.
460std::string GetSchedulerGroupName(pid_t tid);
461
Elliott Hughesdcc24742011-09-07 14:02:44 -0700462// Sets the name of the current thread. The name may be truncated to an
463// implementation-defined limit.
Elliott Hughes22869a92012-03-27 14:08:24 -0700464void SetThreadName(const char* thread_name);
Elliott Hughesdcc24742011-09-07 14:02:44 -0700465
Elliott Hughes46e251b2012-05-22 15:10:45 -0700466// Dumps the native stack for thread 'tid' to 'os'.
Kenny Root067d20f2014-03-05 14:57:21 -0800467void DumpNativeStack(std::ostream& os, pid_t tid, const char* prefix = "",
Christopher Ferrisa2cee182014-04-16 19:13:59 -0700468 mirror::ArtMethod* current_method = nullptr)
Kenny Root067d20f2014-03-05 14:57:21 -0800469 NO_THREAD_SAFETY_ANALYSIS;
Elliott Hughes46e251b2012-05-22 15:10:45 -0700470
471// Dumps the kernel stack for thread 'tid' to 'os'. Note that this is only available on linux-x86.
472void DumpKernelStack(std::ostream& os, pid_t tid, const char* prefix = "", bool include_count = true);
473
Dave Allison70202782013-10-22 17:52:19 -0700474// Find $ANDROID_ROOT, /system, or abort.
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800475const char* GetAndroidRoot();
476
Dave Allison70202782013-10-22 17:52:19 -0700477// Find $ANDROID_DATA, /data, or abort.
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800478const char* GetAndroidData();
Alex Lighta59dd802014-07-02 16:28:08 -0700479// Find $ANDROID_DATA, /data, or return nullptr.
480const char* GetAndroidDataSafe(std::string* error_msg);
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800481
Narayan Kamath11d9f062014-04-23 20:24:57 +0100482// Returns the dalvik-cache location, or dies trying. subdir will be
483// appended to the cache location.
484std::string GetDalvikCacheOrDie(const char* subdir, bool create_if_absent = true);
Alex Lighta59dd802014-07-02 16:28:08 -0700485// Return true if we found the dalvik cache and stored it in the dalvik_cache argument.
486// have_android_data will be set to true if we have an ANDROID_DATA that exists,
487// dalvik_cache_exists will be true if there is a dalvik-cache directory that is present.
Andreas Gampe3c13a792014-09-18 20:56:04 -0700488// The flag is_global_cache tells whether this cache is /data/dalvik-cache.
Alex Lighta59dd802014-07-02 16:28:08 -0700489void GetDalvikCache(const char* subdir, bool create_if_absent, std::string* dalvik_cache,
Andreas Gampe3c13a792014-09-18 20:56:04 -0700490 bool* have_android_data, bool* dalvik_cache_exists, bool* is_global_cache);
Brian Carlstroma9f19782011-10-13 00:14:47 -0700491
Alex Lighta59dd802014-07-02 16:28:08 -0700492// Returns the absolute dalvik-cache path for a DexFile or OatFile. The path returned will be
493// rooted at cache_location.
494bool GetDalvikCacheFilename(const char* file_location, const char* cache_location,
495 std::string* filename, std::string* error_msg);
Narayan Kamath11d9f062014-04-23 20:24:57 +0100496// Returns the absolute dalvik-cache path for a DexFile or OatFile, or
497// dies trying. The path returned will be rooted at cache_location.
498std::string GetDalvikCacheFilenameOrDie(const char* file_location,
499 const char* cache_location);
jeffhao262bf462011-10-20 18:36:32 -0700500
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -0700501// Returns the system location for an image
Brian Carlstrom2afe4942014-05-19 10:25:33 -0700502std::string GetSystemImageFilename(const char* location, InstructionSet isa);
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -0700503
504// Returns an .odex file name next adjacent to the dex location.
505// For example, for "/foo/bar/baz.jar", return "/foo/bar/<isa>/baz.odex".
Andreas Gampe833a4852014-05-21 18:46:59 -0700506// Note: does not support multidex location strings.
Brian Carlstrom2afe4942014-05-19 10:25:33 -0700507std::string DexFilenameToOdexFilename(const std::string& location, InstructionSet isa);
Brian Carlstrom0e12bdc2014-05-14 17:44:28 -0700508
Brian Carlstrom7c3d13a2013-09-04 17:15:11 -0700509// Check whether the given magic matches a known file type.
510bool IsZipMagic(uint32_t magic);
511bool IsDexMagic(uint32_t magic);
512bool IsOatMagic(uint32_t magic);
Brian Carlstromb7bbba42011-10-13 14:58:47 -0700513
Brian Carlstrom6449c622014-02-10 23:48:36 -0800514// Wrapper on fork/execv to run a command in a subprocess.
515bool Exec(std::vector<std::string>& arg_vector, std::string* error_msg);
516
Mathieu Chartierd22d5482012-11-06 17:14:12 -0800517class VoidFunctor {
Mathieu Chartier357e9be2012-08-01 11:00:14 -0700518 public:
Mathieu Chartierd22d5482012-11-06 17:14:12 -0800519 template <typename A>
Brian Carlstromdf629502013-07-17 22:39:56 -0700520 inline void operator() (A a) const {
Mathieu Chartierd22d5482012-11-06 17:14:12 -0800521 UNUSED(a);
522 }
523
524 template <typename A, typename B>
Brian Carlstromdf629502013-07-17 22:39:56 -0700525 inline void operator() (A a, B b) const {
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700526 UNUSED(a, b);
Mathieu Chartierd22d5482012-11-06 17:14:12 -0800527 }
528
529 template <typename A, typename B, typename C>
Brian Carlstromdf629502013-07-17 22:39:56 -0700530 inline void operator() (A a, B b, C c) const {
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700531 UNUSED(a, b, c);
Mathieu Chartierd22d5482012-11-06 17:14:12 -0800532 }
Mathieu Chartier357e9be2012-08-01 11:00:14 -0700533};
534
Tong Shen547cdfd2014-08-05 01:54:19 -0700535void PushWord(std::vector<uint8_t>* buf, int32_t data);
536
537void EncodeUnsignedLeb128(uint32_t data, std::vector<uint8_t>* buf);
538void EncodeSignedLeb128(int32_t data, std::vector<uint8_t>* buf);
539
Vladimir Markoaa4497d2014-09-05 14:01:17 +0100540// Deleter using free() for use with std::unique_ptr<>. See also UniqueCPtr<> below.
541struct FreeDelete {
542 // NOTE: Deleting a const object is valid but free() takes a non-const pointer.
543 void operator()(const void* ptr) const {
544 free(const_cast<void*>(ptr));
545 }
546};
547
548// Alias for std::unique_ptr<> that uses the C function free() to delete objects.
549template <typename T>
550using UniqueCPtr = std::unique_ptr<T, FreeDelete>;
551
Carl Shapiro6b6b5f02011-06-21 15:05:09 -0700552} // namespace art
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -0700553
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700554#endif // ART_RUNTIME_UTILS_H_