blob: a31588b9668cebad5427690185356b8aeed837f3 [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
17#ifndef ART_SRC_UTILS_H_
18#define ART_SRC_UTILS_H_
19
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070020#include "globals.h"
Brian Carlstromdb4d5402011-08-09 12:18:28 -070021#include "logging.h"
Brian Carlstrom6b4ef022011-10-23 14:59:04 -070022#include "primitive.h"
Elliott Hughes11e45072011-08-16 17:40:46 -070023#include "stringpiece.h"
Elliott Hughesc7ac37f2011-08-12 12:21:58 -070024#include "stringprintf.h"
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -070025
Elliott Hughes92b3b562011-09-08 16:32:26 -070026#include <pthread.h>
Elliott Hughes34023802011-08-30 12:06:17 -070027#include <string>
28#include <vector>
29
Carl Shapiro6b6b5f02011-06-21 15:05:09 -070030namespace art {
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -070031
Elliott Hughes54e7df12011-09-16 11:47:04 -070032class Class;
Ian Rogers0571d352011-11-03 19:51:38 -070033class DexFile;
Elliott Hughesa2501992011-08-26 19:39:54 -070034class Field;
Elliott Hughesa0b8feb2011-08-20 09:50:55 -070035class Method;
Elliott Hughes11e45072011-08-16 17:40:46 -070036class Object;
Elliott Hughes5174fe62011-08-23 15:12:35 -070037class String;
Elliott Hughes11e45072011-08-16 17:40:46 -070038
Carl Shapiroa2e18e12011-06-21 18:57:55 -070039template<typename T>
40static inline bool IsPowerOfTwo(T x) {
41 return (x & (x - 1)) == 0;
42}
43
Elliott Hughes06b37d92011-10-16 11:51:29 -070044template<int n, typename T>
45static inline bool IsAligned(T x) {
46 COMPILE_ASSERT((n & (n - 1)) == 0, n_not_power_of_two);
Carl Shapiroa2e18e12011-06-21 18:57:55 -070047 return (x & (n - 1)) == 0;
48}
49
Elliott Hughes06b37d92011-10-16 11:51:29 -070050template<int n, typename T>
51static inline bool IsAligned(T* x) {
Brian Carlstrom89521892011-12-07 22:05:07 -080052 return IsAligned<n>(reinterpret_cast<const uintptr_t>(x));
Carl Shapiroa2e18e12011-06-21 18:57:55 -070053}
54
Elliott Hughes06b37d92011-10-16 11:51:29 -070055#define CHECK_ALIGNED(value, alignment) \
Brian Carlstrom89521892011-12-07 22:05:07 -080056 CHECK(::art::IsAligned<alignment>(value)) << reinterpret_cast<const void*>(value)
Elliott Hughes06b37d92011-10-16 11:51:29 -070057
58#define DCHECK_ALIGNED(value, alignment) \
Brian Carlstrom89521892011-12-07 22:05:07 -080059 DCHECK(::art::IsAligned<alignment>(value)) << reinterpret_cast<const void*>(value)
Elliott Hughes06b37d92011-10-16 11:51:29 -070060
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -070061// Check whether an N-bit two's-complement representation can hold value.
62static inline bool IsInt(int N, word value) {
63 CHECK_LT(0, N);
64 CHECK_LT(N, kBitsPerWord);
65 word limit = static_cast<word>(1) << (N - 1);
66 return (-limit <= value) && (value < limit);
67}
68
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -070069static inline bool IsUint(int N, word value) {
70 CHECK_LT(0, N);
71 CHECK_LT(N, kBitsPerWord);
72 word limit = static_cast<word>(1) << N;
73 return (0 <= value) && (value < limit);
74}
75
Carl Shapiroa2e18e12011-06-21 18:57:55 -070076static inline bool IsAbsoluteUint(int N, word value) {
77 CHECK_LT(0, N);
78 CHECK_LT(N, kBitsPerWord);
79 if (value < 0) value = -value;
80 return IsUint(N, value);
81}
82
Ian Rogersb033c752011-07-20 12:22:35 -070083static inline int32_t Low16Bits(int32_t value) {
84 return static_cast<int32_t>(value & 0xffff);
85}
86
87static inline int32_t High16Bits(int32_t value) {
88 return static_cast<int32_t>(value >> 16);
89}
Carl Shapiroa2e18e12011-06-21 18:57:55 -070090
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -070091static inline int32_t Low32Bits(int64_t value) {
92 return static_cast<int32_t>(value);
93}
94
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -070095static inline int32_t High32Bits(int64_t value) {
96 return static_cast<int32_t>(value >> 32);
97}
98
Carl Shapiro61e019d2011-07-14 16:53:09 -070099template<typename T>
100static inline T RoundDown(T x, int n) {
101 CHECK(IsPowerOfTwo(n));
102 return (x & -n);
103}
104
105template<typename T>
106static inline T RoundUp(T x, int n) {
107 return RoundDown(x + n - 1, n);
108}
109
Carl Shapiroa2e18e12011-06-21 18:57:55 -0700110// Implementation is from "Hacker's Delight" by Henry S. Warren, Jr.,
Carl Shapiro1fb86202011-06-27 17:43:13 -0700111// figure 3-3, page 48, where the function is called clp2.
112static inline uint32_t RoundUpToPowerOfTwo(uint32_t x) {
113 x = x - 1;
114 x = x | (x >> 1);
115 x = x | (x >> 2);
116 x = x | (x >> 4);
117 x = x | (x >> 8);
118 x = x | (x >> 16);
119 return x + 1;
120}
121
122// Implementation is from "Hacker's Delight" by Henry S. Warren, Jr.,
Carl Shapiroa2e18e12011-06-21 18:57:55 -0700123// figure 5-2, page 66, where the function is called pop.
124static inline int CountOneBits(uint32_t x) {
125 x = x - ((x >> 1) & 0x55555555);
126 x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
127 x = (x + (x >> 4)) & 0x0F0F0F0F;
128 x = x + (x >> 8);
129 x = x + (x >> 16);
130 return static_cast<int>(x & 0x0000003F);
131}
132
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700133#define CLZ(x) __builtin_clz(x)
Elliott Hughes105afd22012-04-10 15:04:25 -0700134#define CTZ(x) __builtin_ctz(x)
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700135
Elliott Hughes46b92ba2011-08-12 17:57:34 -0700136static inline bool NeedsEscaping(uint16_t ch) {
137 return (ch < ' ' || ch > '~');
138}
139
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700140static inline std::string PrintableChar(uint16_t ch) {
141 std::string result;
Elliott Hughes46b92ba2011-08-12 17:57:34 -0700142 result += '\'';
143 if (NeedsEscaping(ch)) {
144 StringAppendF(&result, "\\u%04x", ch);
145 } else {
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700146 result += ch;
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700147 }
Elliott Hughes46b92ba2011-08-12 17:57:34 -0700148 result += '\'';
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700149 return result;
150}
151
Elliott Hughes82914b62012-04-09 15:56:29 -0700152// Returns an ASCII string corresponding to the given UTF-8 string.
153// Java escapes are used for non-ASCII characters.
154std::string PrintableString(const std::string& utf8);
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700155
Elliott Hughesf1a5adc2012-02-10 18:09:35 -0800156// Tests whether 's' starts with 'prefix'.
157bool StartsWith(const std::string& s, const char* prefix);
158
Brian Carlstrom7a967b32012-03-28 15:23:10 -0700159// Tests whether 's' starts with 'suffix'.
160bool EndsWith(const std::string& s, const char* suffix);
161
Elliott Hughes54e7df12011-09-16 11:47:04 -0700162// Used to implement PrettyClass, PrettyField, PrettyMethod, and PrettyTypeOf,
163// one of which is probably more useful to you.
Elliott Hughesa0b8feb2011-08-20 09:50:55 -0700164// Returns a human-readable equivalent of 'descriptor'. So "I" would be "int",
165// "[[I" would be "int[][]", "[Ljava/lang/String;" would be
166// "java.lang.String[]", and so forth.
Elliott Hughes5174fe62011-08-23 15:12:35 -0700167std::string PrettyDescriptor(const String* descriptor);
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700168std::string PrettyDescriptor(const std::string& descriptor);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700169std::string PrettyDescriptor(Primitive::Type type);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800170std::string PrettyDescriptor(const Class* klass);
Elliott Hughes11e45072011-08-16 17:40:46 -0700171
Elliott Hughes54e7df12011-09-16 11:47:04 -0700172// Returns a human-readable signature for 'f'. Something like "a.b.C.f" or
173// "int a.b.C.f" (depending on the value of 'with_type').
174std::string PrettyField(const Field* f, bool with_type = true);
Brian Carlstrom6f29d0e2012-05-11 15:50:29 -0700175std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type = true);
Elliott Hughesa2501992011-08-26 19:39:54 -0700176
Elliott Hughesa0b8feb2011-08-20 09:50:55 -0700177// Returns a human-readable signature for 'm'. Something like "a.b.C.m" or
178// "a.b.C.m(II)V" (depending on the value of 'with_signature').
buzbeedfd3d702011-08-28 12:56:51 -0700179std::string PrettyMethod(const Method* m, bool with_signature = true);
Ian Rogers0571d352011-11-03 19:51:38 -0700180std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature = true);
Elliott Hughesa0b8feb2011-08-20 09:50:55 -0700181
182// Returns a human-readable form of the name of the *class* of the given object.
183// So given an instance of java.lang.String, the output would
Elliott Hughes11e45072011-08-16 17:40:46 -0700184// be "java.lang.String". Given an array of int, the output would be "int[]".
185// Given String.class, the output would be "java.lang.Class<java.lang.String>".
Elliott Hughes54e7df12011-09-16 11:47:04 -0700186std::string PrettyTypeOf(const Object* obj);
187
188// Returns a human-readable form of the name of the given class.
189// Given String.class, the output would be "java.lang.Class<java.lang.String>".
190std::string PrettyClass(const Class* c);
Elliott Hughes11e45072011-08-16 17:40:46 -0700191
Ian Rogersd81871c2011-10-03 13:57:23 -0700192// Returns a human-readable form of the name of the given class with its class loader.
193std::string PrettyClassAndClassLoader(const Class* c);
194
Elliott Hughesc967f782012-04-16 10:23:15 -0700195// Returns a human-readable size string such as "1MB".
Ian Rogers3bb17a62012-01-27 23:56:44 -0800196std::string PrettySize(size_t size_in_bytes);
197
198// Returns a human-readable time string which prints every nanosecond while trying to limit the
199// number of trailing zeros. Prints using the largest human readable unit up to a second.
200// e.g. "1ms", "1.000000001s", "1.001us"
201std::string PrettyDuration(uint64_t nano_duration);
202
Elliott Hughes79082e32011-08-25 12:07:32 -0700203// Performs JNI name mangling as described in section 11.3 "Linking Native Methods"
204// of the JNI spec.
205std::string MangleForJni(const std::string& s);
206
Brian Carlstromf91c8c32011-09-21 17:30:34 -0700207// Turn "java.lang.String" into "Ljava/lang/String;".
208std::string DotToDescriptor(const char* class_name);
209
Brian Carlstromaded5f72011-10-07 17:15:04 -0700210// Turn "Ljava/lang/String;" into "java.lang.String".
Elliott Hughesf1a5adc2012-02-10 18:09:35 -0800211std::string DescriptorToDot(const char* descriptor);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700212
Elliott Hughes91bf6cd2012-02-14 17:27:48 -0800213// Turn "Ljava/lang/String;" into "java/lang/String".
214std::string DescriptorToName(const char* descriptor);
215
Elliott Hughes906e6852011-10-28 14:52:10 -0700216// Tests for whether 's' is a valid class name in the three common forms:
217bool IsValidBinaryClassName(const char* s); // "java.lang.String"
218bool IsValidJniClassName(const char* s); // "java/lang/String"
219bool IsValidDescriptor(const char* s); // "Ljava/lang/String;"
Elliott Hughes64bf5a32011-09-20 14:43:12 -0700220
jeffhao10037c82012-01-23 15:06:23 -0800221// Returns whether the given string is a valid field or method name,
222// additionally allowing names that begin with '<' and end with '>'.
223bool IsValidMemberName(const char* s);
224
Elliott Hughes79082e32011-08-25 12:07:32 -0700225// Returns the JNI native function name for the non-overloaded method 'm'.
226std::string JniShortName(const Method* m);
227// Returns the JNI native function name for the overloaded method 'm'.
228std::string JniLongName(const Method* m);
229
Elliott Hughesd92bec42011-09-02 17:04:36 -0700230bool ReadFileToString(const std::string& file_name, std::string* result);
buzbeec143c552011-08-20 17:38:58 -0700231
Elliott Hughese27955c2011-08-26 15:21:24 -0700232// Returns the current date in ISO yyyy-mm-dd hh:mm:ss format.
233std::string GetIsoDate();
234
Elliott Hughes0512f022012-03-15 22:10:52 -0700235// Returns the monotonic time since some unspecified starting point in milliseconds.
Elliott Hughes7162ad92011-10-27 14:08:42 -0700236uint64_t MilliTime();
237
Elliott Hughes0512f022012-03-15 22:10:52 -0700238// Returns the monotonic time since some unspecified starting point in microseconds.
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800239uint64_t MicroTime();
240
Elliott Hughes0512f022012-03-15 22:10:52 -0700241// Returns the monotonic time since some unspecified starting point in nanoseconds.
Elliott Hughes83df2ac2011-10-11 16:37:54 -0700242uint64_t NanoTime();
243
Elliott Hughes0512f022012-03-15 22:10:52 -0700244// Returns the thread-specific CPU-time clock in microseconds or -1 if unavailable.
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800245uint64_t ThreadCpuMicroTime();
246
Elliott Hughes0512f022012-03-15 22:10:52 -0700247// Returns the thread-specific CPU-time clock in nanoseconds or -1 if unavailable.
248uint64_t ThreadCpuNanoTime();
249
Elliott Hughesbb551fa2012-01-25 16:35:29 -0800250// Converts the given number of nanoseconds to milliseconds.
Ian Rogers3bb17a62012-01-27 23:56:44 -0800251static inline uint64_t NsToMs(uint64_t ns) {
252 return ns / 1000 / 1000;
253}
254
255// Converts the given number of milliseconds to nanoseconds
256static inline uint64_t MsToNs(uint64_t ns) {
257 return ns * 1000 * 1000;
258}
259
Elliott Hughes48436bb2012-02-07 15:23:28 -0800260// Splits a string using the given separator character into a vector of
Elliott Hughes34023802011-08-30 12:06:17 -0700261// strings. Empty strings will be omitted.
Elliott Hughes48436bb2012-02-07 15:23:28 -0800262void Split(const std::string& s, char separator, std::vector<std::string>& result);
263
264// Joins a vector of strings into a single string, using the given separator.
265template <typename StringT> std::string Join(std::vector<StringT>& strings, char separator);
Elliott Hughes34023802011-08-30 12:06:17 -0700266
Elliott Hughes42ee1422011-09-06 12:33:32 -0700267// Returns the calling thread's tid. (The C libraries don't expose this.)
268pid_t GetTid();
269
Elliott Hughes289be852012-06-12 13:57:20 -0700270// Returns the given thread's name.
271std::string GetThreadName(pid_t tid);
272
Elliott Hughese1884192012-04-23 12:38:15 -0700273// Returns details of the calling thread's stack.
274void GetThreadStack(void*& stack_base, size_t& stack_size);
275
Elliott Hughesbfe487b2011-10-26 15:48:55 -0700276// Reads data from "/proc/self/task/${tid}/stat".
277void GetTaskStats(pid_t tid, int& utime, int& stime, int& task_cpu);
278
Elliott Hughes1bac54f2012-03-16 12:48:31 -0700279// Returns the name of the scheduler group for the given thread the current process, or the empty string.
280std::string GetSchedulerGroupName(pid_t tid);
281
Elliott Hughesdcc24742011-09-07 14:02:44 -0700282// Sets the name of the current thread. The name may be truncated to an
283// implementation-defined limit.
Elliott Hughes22869a92012-03-27 14:08:24 -0700284void SetThreadName(const char* thread_name);
Elliott Hughesdcc24742011-09-07 14:02:44 -0700285
Elliott Hughes46e251b2012-05-22 15:10:45 -0700286// Dumps the native stack for thread 'tid' to 'os'.
287void DumpNativeStack(std::ostream& os, pid_t tid, const char* prefix = "", bool include_count = true);
288
289// Dumps the kernel stack for thread 'tid' to 'os'. Note that this is only available on linux-x86.
290void DumpKernelStack(std::ostream& os, pid_t tid, const char* prefix = "", bool include_count = true);
291
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800292// Find $ANDROID_ROOT, /system, or abort
293const char* GetAndroidRoot();
294
295// Find $ANDROID_DATA, /data, or abort
296const char* GetAndroidData();
297
Brian Carlstromb7bbba42011-10-13 14:58:47 -0700298// Returns the art-cache location, or dies trying.
Shih-wei Liao795e3302012-04-21 00:20:57 -0700299std::string GetArtCacheOrDie(const char* android_data);
Brian Carlstroma9f19782011-10-13 00:14:47 -0700300
jeffhao262bf462011-10-20 18:36:32 -0700301// Returns the art-cache location for a DexFile or OatFile, or dies trying.
302std::string GetArtCacheFilenameOrDie(const std::string& location);
303
Brian Carlstrom7a967b32012-03-28 15:23:10 -0700304// Check whether the given filename has a valid extension
jeffhao262bf462011-10-20 18:36:32 -0700305bool IsValidZipFilename(const std::string& filename);
306bool IsValidDexFilename(const std::string& filename);
Brian Carlstrom7a967b32012-03-28 15:23:10 -0700307bool IsValidOatFilename(const std::string& filename);
Brian Carlstromb7bbba42011-10-13 14:58:47 -0700308
Carl Shapiro6b6b5f02011-06-21 15:05:09 -0700309} // namespace art
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -0700310
311#endif // ART_SRC_UTILS_H_