blob: 4b39acd5cf85f17667f9e4c5a39da2ffd3cb5a2a [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
Elliott Hughes34023802011-08-30 12:06:17 -070022#include <string>
23#include <vector>
24
Elliott Hughese222ee02012-12-13 14:41:43 -080025#include "base/logging.h"
26#include "base/stringpiece.h"
27#include "base/stringprintf.h"
28#include "globals.h"
29#include "primitive.h"
30
Carl Shapiro6b6b5f02011-06-21 15:05:09 -070031namespace art {
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -070032
Ian Rogers0571d352011-11-03 19:51:38 -070033class DexFile;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080034
35namespace mirror {
Brian Carlstromea46f952013-07-30 01:26:50 -070036class ArtField;
37class ArtMethod;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080038class Class;
Elliott Hughes11e45072011-08-16 17:40:46 -070039class Object;
Elliott Hughes5174fe62011-08-23 15:12:35 -070040class String;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080041} // namespace mirror
Elliott Hughes11e45072011-08-16 17:40:46 -070042
Mathieu Chartier0325e622012-09-05 14:22:51 -070043enum TimeUnit {
44 kTimeUnitNanosecond,
45 kTimeUnitMicrosecond,
46 kTimeUnitMillisecond,
47 kTimeUnitSecond,
48};
49
Carl Shapiroa2e18e12011-06-21 18:57:55 -070050template<typename T>
51static inline bool IsPowerOfTwo(T x) {
52 return (x & (x - 1)) == 0;
53}
54
Elliott Hughes06b37d92011-10-16 11:51:29 -070055template<int n, typename T>
56static inline bool IsAligned(T x) {
57 COMPILE_ASSERT((n & (n - 1)) == 0, n_not_power_of_two);
Carl Shapiroa2e18e12011-06-21 18:57:55 -070058 return (x & (n - 1)) == 0;
59}
60
Elliott Hughes06b37d92011-10-16 11:51:29 -070061template<int n, typename T>
62static inline bool IsAligned(T* x) {
Brian Carlstrom89521892011-12-07 22:05:07 -080063 return IsAligned<n>(reinterpret_cast<const uintptr_t>(x));
Carl Shapiroa2e18e12011-06-21 18:57:55 -070064}
65
Elliott Hughes06b37d92011-10-16 11:51:29 -070066#define CHECK_ALIGNED(value, alignment) \
Brian Carlstrom89521892011-12-07 22:05:07 -080067 CHECK(::art::IsAligned<alignment>(value)) << reinterpret_cast<const void*>(value)
Elliott Hughes06b37d92011-10-16 11:51:29 -070068
69#define DCHECK_ALIGNED(value, alignment) \
Brian Carlstrom89521892011-12-07 22:05:07 -080070 DCHECK(::art::IsAligned<alignment>(value)) << reinterpret_cast<const void*>(value)
Elliott Hughes06b37d92011-10-16 11:51:29 -070071
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -070072// Check whether an N-bit two's-complement representation can hold value.
73static inline bool IsInt(int N, word value) {
74 CHECK_LT(0, N);
75 CHECK_LT(N, kBitsPerWord);
76 word limit = static_cast<word>(1) << (N - 1);
77 return (-limit <= value) && (value < limit);
78}
79
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -070080static inline bool IsUint(int N, word value) {
81 CHECK_LT(0, N);
82 CHECK_LT(N, kBitsPerWord);
83 word limit = static_cast<word>(1) << N;
84 return (0 <= value) && (value < limit);
85}
86
Carl Shapiroa2e18e12011-06-21 18:57:55 -070087static inline bool IsAbsoluteUint(int N, word value) {
88 CHECK_LT(0, N);
89 CHECK_LT(N, kBitsPerWord);
90 if (value < 0) value = -value;
91 return IsUint(N, value);
92}
93
buzbee4ef3e452012-12-14 13:35:28 -080094static inline uint16_t Low16Bits(uint32_t value) {
95 return static_cast<uint16_t>(value);
Ian Rogersb033c752011-07-20 12:22:35 -070096}
97
buzbee4ef3e452012-12-14 13:35:28 -080098static inline uint16_t High16Bits(uint32_t value) {
99 return static_cast<uint16_t>(value >> 16);
Ian Rogersb033c752011-07-20 12:22:35 -0700100}
Carl Shapiroa2e18e12011-06-21 18:57:55 -0700101
buzbee4ef3e452012-12-14 13:35:28 -0800102static inline uint32_t Low32Bits(uint64_t value) {
103 return static_cast<uint32_t>(value);
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -0700104}
105
buzbee4ef3e452012-12-14 13:35:28 -0800106static inline uint32_t High32Bits(uint64_t value) {
107 return static_cast<uint32_t>(value >> 32);
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -0700108}
109
Mathieu Chartier0a9dc052013-07-25 11:01:28 -0700110// A static if which determines whether to return type A or B based on the condition boolean.
111template <const bool condition, typename A, typename B>
112struct TypeStaticIf {
113 typedef A value;
114};
115
116// Specialization to handle the false case.
117template <typename A, typename B>
118struct TypeStaticIf<false, A, B> {
119 typedef B value;
120};
121
Hiroshi Yamauchi0941b042013-11-05 11:34:03 -0800122// For rounding integers.
Carl Shapiro61e019d2011-07-14 16:53:09 -0700123template<typename T>
124static inline T RoundDown(T x, int n) {
Mathieu Chartier590fee92013-09-13 13:46:47 -0700125 DCHECK(IsPowerOfTwo(n));
Carl Shapiro61e019d2011-07-14 16:53:09 -0700126 return (x & -n);
127}
128
129template<typename T>
130static inline T RoundUp(T x, int n) {
131 return RoundDown(x + n - 1, n);
132}
133
Hiroshi Yamauchi0941b042013-11-05 11:34:03 -0800134// For aligning pointers.
135template<typename T>
136static inline T* AlignDown(T* x, int n) {
137 CHECK(IsPowerOfTwo(n));
138 return reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(x) & -static_cast<uintptr_t>(n));
139}
140
141template<typename T>
142static inline T* AlignUp(T* x, int n) {
143 return AlignDown(reinterpret_cast<T*>(reinterpret_cast<uintptr_t>(x) + static_cast<uintptr_t>(n - 1)), n);
144}
145
Carl Shapiroa2e18e12011-06-21 18:57:55 -0700146// Implementation is from "Hacker's Delight" by Henry S. Warren, Jr.,
Carl Shapiro1fb86202011-06-27 17:43:13 -0700147// figure 3-3, page 48, where the function is called clp2.
148static inline uint32_t RoundUpToPowerOfTwo(uint32_t x) {
149 x = x - 1;
150 x = x | (x >> 1);
151 x = x | (x >> 2);
152 x = x | (x >> 4);
153 x = x | (x >> 8);
154 x = x | (x >> 16);
155 return x + 1;
156}
157
158// Implementation is from "Hacker's Delight" by Henry S. Warren, Jr.,
Carl Shapiroa2e18e12011-06-21 18:57:55 -0700159// figure 5-2, page 66, where the function is called pop.
160static inline int CountOneBits(uint32_t x) {
161 x = x - ((x >> 1) & 0x55555555);
162 x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
163 x = (x + (x >> 4)) & 0x0F0F0F0F;
164 x = x + (x >> 8);
165 x = x + (x >> 16);
166 return static_cast<int>(x & 0x0000003F);
167}
168
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700169#define CLZ(x) __builtin_clz(x)
Elliott Hughes105afd22012-04-10 15:04:25 -0700170#define CTZ(x) __builtin_ctz(x)
Brian Carlstromdb4d5402011-08-09 12:18:28 -0700171
Elliott Hughes46b92ba2011-08-12 17:57:34 -0700172static inline bool NeedsEscaping(uint16_t ch) {
173 return (ch < ' ' || ch > '~');
174}
175
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700176static inline std::string PrintableChar(uint16_t ch) {
177 std::string result;
Elliott Hughes46b92ba2011-08-12 17:57:34 -0700178 result += '\'';
179 if (NeedsEscaping(ch)) {
180 StringAppendF(&result, "\\u%04x", ch);
181 } else {
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700182 result += ch;
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700183 }
Elliott Hughes46b92ba2011-08-12 17:57:34 -0700184 result += '\'';
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700185 return result;
186}
187
Elliott Hughes82914b62012-04-09 15:56:29 -0700188// Returns an ASCII string corresponding to the given UTF-8 string.
189// Java escapes are used for non-ASCII characters.
190std::string PrintableString(const std::string& utf8);
Elliott Hughesc7ac37f2011-08-12 12:21:58 -0700191
Elliott Hughesf1a5adc2012-02-10 18:09:35 -0800192// Tests whether 's' starts with 'prefix'.
193bool StartsWith(const std::string& s, const char* prefix);
194
Brian Carlstrom7a967b32012-03-28 15:23:10 -0700195// Tests whether 's' starts with 'suffix'.
196bool EndsWith(const std::string& s, const char* suffix);
197
Elliott Hughes54e7df12011-09-16 11:47:04 -0700198// Used to implement PrettyClass, PrettyField, PrettyMethod, and PrettyTypeOf,
199// one of which is probably more useful to you.
Elliott Hughesa0b8feb2011-08-20 09:50:55 -0700200// Returns a human-readable equivalent of 'descriptor'. So "I" would be "int",
201// "[[I" would be "int[][]", "[Ljava/lang/String;" would be
202// "java.lang.String[]", and so forth.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800203std::string PrettyDescriptor(const mirror::String* descriptor);
Elliott Hughes6c8867d2011-10-03 16:34:05 -0700204std::string PrettyDescriptor(const std::string& descriptor);
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700205std::string PrettyDescriptor(Primitive::Type type);
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800206std::string PrettyDescriptor(const mirror::Class* klass)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700207 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes11e45072011-08-16 17:40:46 -0700208
Elliott Hughes54e7df12011-09-16 11:47:04 -0700209// Returns a human-readable signature for 'f'. Something like "a.b.C.f" or
210// "int a.b.C.f" (depending on the value of 'with_type').
Brian Carlstromea46f952013-07-30 01:26:50 -0700211std::string PrettyField(const mirror::ArtField* f, bool with_type = true)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700212 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom6f29d0e2012-05-11 15:50:29 -0700213std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type = true);
Elliott Hughesa2501992011-08-26 19:39:54 -0700214
Elliott Hughesa0b8feb2011-08-20 09:50:55 -0700215// Returns a human-readable signature for 'm'. Something like "a.b.C.m" or
216// "a.b.C.m(II)V" (depending on the value of 'with_signature').
Brian Carlstromea46f952013-07-30 01:26:50 -0700217std::string PrettyMethod(const mirror::ArtMethod* m, bool with_signature = true)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700218 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -0700219std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature = true);
Elliott Hughesa0b8feb2011-08-20 09:50:55 -0700220
221// Returns a human-readable form of the name of the *class* of the given object.
222// So given an instance of java.lang.String, the output would
Elliott Hughes11e45072011-08-16 17:40:46 -0700223// be "java.lang.String". Given an array of int, the output would be "int[]".
224// Given String.class, the output would be "java.lang.Class<java.lang.String>".
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800225std::string PrettyTypeOf(const mirror::Object* obj)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700226 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Mathieu Chartier4c70d772012-09-10 14:08:32 -0700227
228// Returns a human-readable form of the type at an index in the specified dex file.
229// Example outputs: char[], java.lang.String.
Mathieu Chartier18c24b62012-09-10 08:54:25 -0700230std::string PrettyType(uint32_t type_idx, const DexFile& dex_file);
Elliott Hughes54e7df12011-09-16 11:47:04 -0700231
232// Returns a human-readable form of the name of the given class.
233// Given String.class, the output would be "java.lang.Class<java.lang.String>".
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800234std::string PrettyClass(const mirror::Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700235 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes11e45072011-08-16 17:40:46 -0700236
Ian Rogersd81871c2011-10-03 13:57:23 -0700237// Returns a human-readable form of the name of the given class with its class loader.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800238std::string PrettyClassAndClassLoader(const mirror::Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700239 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogersd81871c2011-10-03 13:57:23 -0700240
Elliott Hughesc967f782012-04-16 10:23:15 -0700241// Returns a human-readable size string such as "1MB".
Ian Rogers3bb17a62012-01-27 23:56:44 -0800242std::string PrettySize(size_t size_in_bytes);
243
244// Returns a human-readable time string which prints every nanosecond while trying to limit the
245// number of trailing zeros. Prints using the largest human readable unit up to a second.
246// e.g. "1ms", "1.000000001s", "1.001us"
247std::string PrettyDuration(uint64_t nano_duration);
248
Mathieu Chartier0325e622012-09-05 14:22:51 -0700249// Format a nanosecond time to specified units.
250std::string FormatDuration(uint64_t nano_duration, TimeUnit time_unit);
251
252// Get the appropriate unit for a nanosecond duration.
253TimeUnit GetAppropriateTimeUnit(uint64_t nano_duration);
254
Dave Allison70202782013-10-22 17:52:19 -0700255// Get the divisor to convert from a nanoseconds to a time unit.
Mathieu Chartier0325e622012-09-05 14:22:51 -0700256uint64_t GetNsToTimeUnitDivisor(TimeUnit time_unit);
257
Elliott Hughes79082e32011-08-25 12:07:32 -0700258// Performs JNI name mangling as described in section 11.3 "Linking Native Methods"
259// of the JNI spec.
260std::string MangleForJni(const std::string& s);
261
Brian Carlstromf91c8c32011-09-21 17:30:34 -0700262// Turn "java.lang.String" into "Ljava/lang/String;".
263std::string DotToDescriptor(const char* class_name);
264
Brian Carlstromaded5f72011-10-07 17:15:04 -0700265// Turn "Ljava/lang/String;" into "java.lang.String".
Elliott Hughesf1a5adc2012-02-10 18:09:35 -0800266std::string DescriptorToDot(const char* descriptor);
Brian Carlstromaded5f72011-10-07 17:15:04 -0700267
Elliott Hughes91bf6cd2012-02-14 17:27:48 -0800268// Turn "Ljava/lang/String;" into "java/lang/String".
269std::string DescriptorToName(const char* descriptor);
270
Elliott Hughes906e6852011-10-28 14:52:10 -0700271// Tests for whether 's' is a valid class name in the three common forms:
272bool IsValidBinaryClassName(const char* s); // "java.lang.String"
273bool IsValidJniClassName(const char* s); // "java/lang/String"
274bool IsValidDescriptor(const char* s); // "Ljava/lang/String;"
Elliott Hughes64bf5a32011-09-20 14:43:12 -0700275
jeffhao10037c82012-01-23 15:06:23 -0800276// Returns whether the given string is a valid field or method name,
277// additionally allowing names that begin with '<' and end with '>'.
278bool IsValidMemberName(const char* s);
279
Elliott Hughes79082e32011-08-25 12:07:32 -0700280// Returns the JNI native function name for the non-overloaded method 'm'.
Brian Carlstromea46f952013-07-30 01:26:50 -0700281std::string JniShortName(const mirror::ArtMethod* m)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700282 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes79082e32011-08-25 12:07:32 -0700283// Returns the JNI native function name for the overloaded method 'm'.
Brian Carlstromea46f952013-07-30 01:26:50 -0700284std::string JniLongName(const mirror::ArtMethod* m)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700285 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Elliott Hughes79082e32011-08-25 12:07:32 -0700286
Elliott Hughesd92bec42011-09-02 17:04:36 -0700287bool ReadFileToString(const std::string& file_name, std::string* result);
buzbeec143c552011-08-20 17:38:58 -0700288
Elliott Hughese27955c2011-08-26 15:21:24 -0700289// Returns the current date in ISO yyyy-mm-dd hh:mm:ss format.
290std::string GetIsoDate();
291
Elliott Hughes0512f022012-03-15 22:10:52 -0700292// Returns the monotonic time since some unspecified starting point in milliseconds.
Elliott Hughes7162ad92011-10-27 14:08:42 -0700293uint64_t MilliTime();
294
Elliott Hughes0512f022012-03-15 22:10:52 -0700295// Returns the monotonic time since some unspecified starting point in microseconds.
jeffhaoa9ef3fd2011-12-13 18:33:43 -0800296uint64_t MicroTime();
297
Elliott Hughes0512f022012-03-15 22:10:52 -0700298// Returns the monotonic time since some unspecified starting point in nanoseconds.
Elliott Hughes83df2ac2011-10-11 16:37:54 -0700299uint64_t NanoTime();
300
Elliott Hughes0512f022012-03-15 22:10:52 -0700301// Returns the thread-specific CPU-time clock in nanoseconds or -1 if unavailable.
302uint64_t ThreadCpuNanoTime();
303
Elliott Hughesbb551fa2012-01-25 16:35:29 -0800304// Converts the given number of nanoseconds to milliseconds.
Mathieu Chartier720ef762013-08-17 14:46:54 -0700305static constexpr inline uint64_t NsToMs(uint64_t ns) {
Ian Rogers3bb17a62012-01-27 23:56:44 -0800306 return ns / 1000 / 1000;
307}
308
309// Converts the given number of milliseconds to nanoseconds
Mathieu Chartier720ef762013-08-17 14:46:54 -0700310static constexpr inline uint64_t MsToNs(uint64_t ns) {
Ian Rogers3bb17a62012-01-27 23:56:44 -0800311 return ns * 1000 * 1000;
312}
313
Brian Carlstrombcc29262012-11-02 11:36:03 -0700314#if defined(__APPLE__)
315// No clocks to specify on OS/X, fake value to pass to routines that require a clock.
316#define CLOCK_REALTIME 0xebadf00d
317#endif
318
Ian Rogers56edc432013-01-18 16:51:51 -0800319// Sleep for the given number of nanoseconds, a bad way to handle contention.
320void NanoSleep(uint64_t ns);
321
Brian Carlstrombcc29262012-11-02 11:36:03 -0700322// Initialize a timespec to either an absolute or relative time.
323void InitTimeSpec(bool absolute, int clock, int64_t ms, int32_t ns, timespec* ts);
324
Elliott Hughes48436bb2012-02-07 15:23:28 -0800325// Splits a string using the given separator character into a vector of
Elliott Hughes34023802011-08-30 12:06:17 -0700326// strings. Empty strings will be omitted.
Elliott Hughes48436bb2012-02-07 15:23:28 -0800327void Split(const std::string& s, char separator, std::vector<std::string>& result);
328
Dave Allison70202782013-10-22 17:52:19 -0700329// Trims whitespace off both ends of the given string.
330std::string Trim(std::string s);
331
Elliott Hughes48436bb2012-02-07 15:23:28 -0800332// Joins a vector of strings into a single string, using the given separator.
333template <typename StringT> std::string Join(std::vector<StringT>& strings, char separator);
Elliott Hughes34023802011-08-30 12:06:17 -0700334
Elliott Hughes42ee1422011-09-06 12:33:32 -0700335// Returns the calling thread's tid. (The C libraries don't expose this.)
336pid_t GetTid();
337
Elliott Hughes289be852012-06-12 13:57:20 -0700338// Returns the given thread's name.
339std::string GetThreadName(pid_t tid);
340
Ian Rogers120f1c72012-09-28 17:17:10 -0700341// Returns details of the given thread's stack.
Brian Carlstrom29212012013-09-12 22:18:30 -0700342void GetThreadStack(pthread_t thread, void** stack_base, size_t* stack_size);
Elliott Hughese1884192012-04-23 12:38:15 -0700343
Elliott Hughesbfe487b2011-10-26 15:48:55 -0700344// Reads data from "/proc/self/task/${tid}/stat".
Brian Carlstrom29212012013-09-12 22:18:30 -0700345void GetTaskStats(pid_t tid, char* state, int* utime, int* stime, int* task_cpu);
Elliott Hughesbfe487b2011-10-26 15:48:55 -0700346
Elliott Hughes1bac54f2012-03-16 12:48:31 -0700347// Returns the name of the scheduler group for the given thread the current process, or the empty string.
348std::string GetSchedulerGroupName(pid_t tid);
349
Elliott Hughesdcc24742011-09-07 14:02:44 -0700350// Sets the name of the current thread. The name may be truncated to an
351// implementation-defined limit.
Elliott Hughes22869a92012-03-27 14:08:24 -0700352void SetThreadName(const char* thread_name);
Elliott Hughesdcc24742011-09-07 14:02:44 -0700353
Elliott Hughes46e251b2012-05-22 15:10:45 -0700354// Dumps the native stack for thread 'tid' to 'os'.
355void DumpNativeStack(std::ostream& os, pid_t tid, const char* prefix = "", bool include_count = true);
356
357// Dumps the kernel stack for thread 'tid' to 'os'. Note that this is only available on linux-x86.
358void DumpKernelStack(std::ostream& os, pid_t tid, const char* prefix = "", bool include_count = true);
359
Dave Allison70202782013-10-22 17:52:19 -0700360// Find $ANDROID_ROOT, /system, or abort.
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800361const char* GetAndroidRoot();
362
Dave Allison70202782013-10-22 17:52:19 -0700363// Find $ANDROID_DATA, /data, or abort.
Brian Carlstroma56fcd62012-02-04 21:23:01 -0800364const char* GetAndroidData();
365
Brian Carlstrom7675e162013-06-10 16:18:04 -0700366// Returns the dalvik-cache location, or dies trying.
367std::string GetDalvikCacheOrDie(const char* android_data);
Brian Carlstroma9f19782011-10-13 00:14:47 -0700368
Brian Carlstrom7675e162013-06-10 16:18:04 -0700369// Returns the dalvik-cache location for a DexFile or OatFile, or dies trying.
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700370std::string GetDalvikCacheFilenameOrDie(const char* location);
jeffhao262bf462011-10-20 18:36:32 -0700371
Brian Carlstrom7c3d13a2013-09-04 17:15:11 -0700372// Check whether the given magic matches a known file type.
373bool IsZipMagic(uint32_t magic);
374bool IsDexMagic(uint32_t magic);
375bool IsOatMagic(uint32_t magic);
Brian Carlstromb7bbba42011-10-13 14:58:47 -0700376
Mathieu Chartierd22d5482012-11-06 17:14:12 -0800377class VoidFunctor {
Mathieu Chartier357e9be2012-08-01 11:00:14 -0700378 public:
Mathieu Chartierd22d5482012-11-06 17:14:12 -0800379 template <typename A>
Brian Carlstromdf629502013-07-17 22:39:56 -0700380 inline void operator() (A a) const {
Mathieu Chartierd22d5482012-11-06 17:14:12 -0800381 UNUSED(a);
382 }
383
384 template <typename A, typename B>
Brian Carlstromdf629502013-07-17 22:39:56 -0700385 inline void operator() (A a, B b) const {
Mathieu Chartierd22d5482012-11-06 17:14:12 -0800386 UNUSED(a);
387 UNUSED(b);
388 }
389
390 template <typename A, typename B, typename C>
Brian Carlstromdf629502013-07-17 22:39:56 -0700391 inline void operator() (A a, B b, C c) const {
Mathieu Chartierd22d5482012-11-06 17:14:12 -0800392 UNUSED(a);
393 UNUSED(b);
394 UNUSED(c);
395 }
Mathieu Chartier357e9be2012-08-01 11:00:14 -0700396};
397
Carl Shapiro6b6b5f02011-06-21 15:05:09 -0700398} // namespace art
Carl Shapiroa5d5cfd2011-06-21 12:46:59 -0700399
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700400#endif // ART_RUNTIME_UTILS_H_