Elliott Hughes | 2faa5f1 | 2012-01-30 14:42:07 -0800 | [diff] [blame] | 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 | */ |
Carl Shapiro | a5d5cfd | 2011-06-21 12:46:59 -0700 | [diff] [blame] | 16 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 17 | #ifndef ART_RUNTIME_UTILS_H_ |
| 18 | #define ART_RUNTIME_UTILS_H_ |
Carl Shapiro | a5d5cfd | 2011-06-21 12:46:59 -0700 | [diff] [blame] | 19 | |
Elliott Hughes | 92b3b56 | 2011-09-08 16:32:26 -0700 | [diff] [blame] | 20 | #include <pthread.h> |
Elliott Hughes | e222ee0 | 2012-12-13 14:41:43 -0800 | [diff] [blame] | 21 | |
Alex Light | 53cb16b | 2014-06-12 11:26:29 -0700 | [diff] [blame] | 22 | #include <limits> |
Vladimir Marko | aa4497d | 2014-09-05 14:01:17 +0100 | [diff] [blame] | 23 | #include <memory> |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 24 | #include <string> |
Andreas Gampe | ab1eb0d | 2015-02-13 19:23:55 -0800 | [diff] [blame] | 25 | #include <type_traits> |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 26 | #include <vector> |
| 27 | |
Ian Rogers | d582fa4 | 2014-11-05 23:46:43 -0800 | [diff] [blame] | 28 | #include "arch/instruction_set.h" |
Elliott Hughes | e222ee0 | 2012-12-13 14:41:43 -0800 | [diff] [blame] | 29 | #include "base/logging.h" |
Ian Rogers | 68d8b42 | 2014-07-17 11:09:10 -0700 | [diff] [blame] | 30 | #include "base/mutex.h" |
Elliott Hughes | e222ee0 | 2012-12-13 14:41:43 -0800 | [diff] [blame] | 31 | #include "globals.h" |
Ian Rogers | 68d8b42 | 2014-07-17 11:09:10 -0700 | [diff] [blame] | 32 | #include "primitive.h" |
Calin Juravle | bb0b53f | 2014-05-23 17:33:29 +0100 | [diff] [blame] | 33 | |
Carl Shapiro | 6b6b5f0 | 2011-06-21 15:05:09 -0700 | [diff] [blame] | 34 | namespace art { |
Carl Shapiro | a5d5cfd | 2011-06-21 12:46:59 -0700 | [diff] [blame] | 35 | |
Mathieu Chartier | c785344 | 2015-03-27 14:35:38 -0700 | [diff] [blame] | 36 | class ArtField; |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame^] | 37 | class ArtMethod; |
Ian Rogers | 0571d35 | 2011-11-03 19:51:38 -0700 | [diff] [blame] | 38 | class DexFile; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 39 | |
| 40 | namespace mirror { |
| 41 | class Class; |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 42 | class Object; |
Elliott Hughes | 5174fe6 | 2011-08-23 15:12:35 -0700 | [diff] [blame] | 43 | class String; |
Ian Rogers | 2dd0e2c | 2013-01-24 12:42:14 -0800 | [diff] [blame] | 44 | } // namespace mirror |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 45 | |
Alex Light | 53cb16b | 2014-06-12 11:26:29 -0700 | [diff] [blame] | 46 | template <typename T> |
| 47 | bool ParseUint(const char *in, T* out) { |
| 48 | char* end; |
| 49 | unsigned long long int result = strtoull(in, &end, 0); // NOLINT(runtime/int) |
| 50 | if (in == end || *end != '\0') { |
| 51 | return false; |
| 52 | } |
| 53 | if (std::numeric_limits<T>::max() < result) { |
| 54 | return false; |
| 55 | } |
| 56 | *out = static_cast<T>(result); |
| 57 | return true; |
| 58 | } |
| 59 | |
| 60 | template <typename T> |
| 61 | bool ParseInt(const char* in, T* out) { |
| 62 | char* end; |
| 63 | long long int result = strtoll(in, &end, 0); // NOLINT(runtime/int) |
| 64 | if (in == end || *end != '\0') { |
| 65 | return false; |
| 66 | } |
| 67 | if (result < std::numeric_limits<T>::min() || std::numeric_limits<T>::max() < result) { |
| 68 | return false; |
| 69 | } |
| 70 | *out = static_cast<T>(result); |
| 71 | return true; |
| 72 | } |
| 73 | |
Nicolas Geoffray | 0d22184 | 2015-04-27 08:53:46 +0000 | [diff] [blame] | 74 | // Return whether x / divisor == x * (1.0f / divisor), for every float x. |
| 75 | static constexpr bool CanDivideByReciprocalMultiplyFloat(int32_t divisor) { |
| 76 | // True, if the most significant bits of divisor are 0. |
| 77 | return ((divisor & 0x7fffff) == 0); |
| 78 | } |
| 79 | |
| 80 | // Return whether x / divisor == x * (1.0 / divisor), for every double x. |
| 81 | static constexpr bool CanDivideByReciprocalMultiplyDouble(int64_t divisor) { |
| 82 | // True, if the most significant bits of divisor are 0. |
| 83 | return ((divisor & ((UINT64_C(1) << 52) - 1)) == 0); |
| 84 | } |
| 85 | |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 86 | static inline uint32_t PointerToLowMemUInt32(const void* p) { |
| 87 | uintptr_t intp = reinterpret_cast<uintptr_t>(p); |
| 88 | DCHECK_LE(intp, 0xFFFFFFFFU); |
| 89 | return intp & 0xFFFFFFFFU; |
| 90 | } |
Brian Carlstrom | db4d540 | 2011-08-09 12:18:28 -0700 | [diff] [blame] | 91 | |
Elliott Hughes | 46b92ba | 2011-08-12 17:57:34 -0700 | [diff] [blame] | 92 | static inline bool NeedsEscaping(uint16_t ch) { |
| 93 | return (ch < ' ' || ch > '~'); |
| 94 | } |
| 95 | |
Ian Rogers | 576ca0c | 2014-06-06 15:58:22 -0700 | [diff] [blame] | 96 | std::string PrintableChar(uint16_t ch); |
Elliott Hughes | c7ac37f | 2011-08-12 12:21:58 -0700 | [diff] [blame] | 97 | |
Elliott Hughes | 82914b6 | 2012-04-09 15:56:29 -0700 | [diff] [blame] | 98 | // Returns an ASCII string corresponding to the given UTF-8 string. |
| 99 | // Java escapes are used for non-ASCII characters. |
Ian Rogers | 68b5685 | 2014-08-29 20:19:11 -0700 | [diff] [blame] | 100 | std::string PrintableString(const char* utf8); |
Elliott Hughes | c7ac37f | 2011-08-12 12:21:58 -0700 | [diff] [blame] | 101 | |
Elliott Hughes | f1a5adc | 2012-02-10 18:09:35 -0800 | [diff] [blame] | 102 | // Tests whether 's' starts with 'prefix'. |
| 103 | bool StartsWith(const std::string& s, const char* prefix); |
| 104 | |
Dan Albert | 6eb987d | 2015-03-12 17:26:05 -0700 | [diff] [blame] | 105 | // Tests whether 's' ends with 'suffix'. |
Brian Carlstrom | 7a967b3 | 2012-03-28 15:23:10 -0700 | [diff] [blame] | 106 | bool EndsWith(const std::string& s, const char* suffix); |
| 107 | |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 108 | // Used to implement PrettyClass, PrettyField, PrettyMethod, and PrettyTypeOf, |
| 109 | // one of which is probably more useful to you. |
Elliott Hughes | a0b8feb | 2011-08-20 09:50:55 -0700 | [diff] [blame] | 110 | // Returns a human-readable equivalent of 'descriptor'. So "I" would be "int", |
| 111 | // "[[I" would be "int[][]", "[Ljava/lang/String;" would be |
| 112 | // "java.lang.String[]", and so forth. |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 113 | std::string PrettyDescriptor(mirror::String* descriptor) |
| 114 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Ian Rogers | 1ff3c98 | 2014-08-12 02:30:58 -0700 | [diff] [blame] | 115 | std::string PrettyDescriptor(const char* descriptor); |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 116 | std::string PrettyDescriptor(mirror::Class* klass) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 117 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Ian Rogers | 68d8b42 | 2014-07-17 11:09:10 -0700 | [diff] [blame] | 118 | std::string PrettyDescriptor(Primitive::Type type); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 119 | |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 120 | // Returns a human-readable signature for 'f'. Something like "a.b.C.f" or |
| 121 | // "int a.b.C.f" (depending on the value of 'with_type'). |
Mathieu Chartier | c785344 | 2015-03-27 14:35:38 -0700 | [diff] [blame] | 122 | std::string PrettyField(ArtField* f, bool with_type = true) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 123 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Brian Carlstrom | 6f29d0e | 2012-05-11 15:50:29 -0700 | [diff] [blame] | 124 | std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type = true); |
Elliott Hughes | a250199 | 2011-08-26 19:39:54 -0700 | [diff] [blame] | 125 | |
Elliott Hughes | a0b8feb | 2011-08-20 09:50:55 -0700 | [diff] [blame] | 126 | // Returns a human-readable signature for 'm'. Something like "a.b.C.m" or |
| 127 | // "a.b.C.m(II)V" (depending on the value of 'with_signature'). |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame^] | 128 | std::string PrettyMethod(ArtMethod* m, bool with_signature = true) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 129 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Ian Rogers | 0571d35 | 2011-11-03 19:51:38 -0700 | [diff] [blame] | 130 | std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature = true); |
Elliott Hughes | a0b8feb | 2011-08-20 09:50:55 -0700 | [diff] [blame] | 131 | |
| 132 | // Returns a human-readable form of the name of the *class* of the given object. |
| 133 | // So given an instance of java.lang.String, the output would |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 134 | // be "java.lang.String". Given an array of int, the output would be "int[]". |
| 135 | // Given String.class, the output would be "java.lang.Class<java.lang.String>". |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 136 | std::string PrettyTypeOf(mirror::Object* obj) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 137 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Mathieu Chartier | 4c70d77 | 2012-09-10 14:08:32 -0700 | [diff] [blame] | 138 | |
| 139 | // Returns a human-readable form of the type at an index in the specified dex file. |
| 140 | // Example outputs: char[], java.lang.String. |
Mathieu Chartier | 18c24b6 | 2012-09-10 08:54:25 -0700 | [diff] [blame] | 141 | std::string PrettyType(uint32_t type_idx, const DexFile& dex_file); |
Elliott Hughes | 54e7df1 | 2011-09-16 11:47:04 -0700 | [diff] [blame] | 142 | |
| 143 | // Returns a human-readable form of the name of the given class. |
| 144 | // Given String.class, the output would be "java.lang.Class<java.lang.String>". |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 145 | std::string PrettyClass(mirror::Class* c) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 146 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Elliott Hughes | 11e4507 | 2011-08-16 17:40:46 -0700 | [diff] [blame] | 147 | |
Ian Rogers | d81871c | 2011-10-03 13:57:23 -0700 | [diff] [blame] | 148 | // Returns a human-readable form of the name of the given class with its class loader. |
Ian Rogers | ef7d42f | 2014-01-06 12:55:46 -0800 | [diff] [blame] | 149 | std::string PrettyClassAndClassLoader(mirror::Class* c) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 150 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Ian Rogers | d81871c | 2011-10-03 13:57:23 -0700 | [diff] [blame] | 151 | |
Andreas Gampe | c0d8229 | 2014-09-23 10:38:30 -0700 | [diff] [blame] | 152 | // Returns a human-readable version of the Java part of the access flags, e.g., "private static " |
| 153 | // (note the trailing whitespace). |
| 154 | std::string PrettyJavaAccessFlags(uint32_t access_flags); |
| 155 | |
Elliott Hughes | c967f78 | 2012-04-16 10:23:15 -0700 | [diff] [blame] | 156 | // Returns a human-readable size string such as "1MB". |
Mathieu Chartier | e6da9af | 2013-12-16 11:54:42 -0800 | [diff] [blame] | 157 | std::string PrettySize(int64_t size_in_bytes); |
Ian Rogers | 3bb17a6 | 2012-01-27 23:56:44 -0800 | [diff] [blame] | 158 | |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 159 | // Performs JNI name mangling as described in section 11.3 "Linking Native Methods" |
| 160 | // of the JNI spec. |
| 161 | std::string MangleForJni(const std::string& s); |
| 162 | |
Brian Carlstrom | f91c8c3 | 2011-09-21 17:30:34 -0700 | [diff] [blame] | 163 | // Turn "java.lang.String" into "Ljava/lang/String;". |
| 164 | std::string DotToDescriptor(const char* class_name); |
| 165 | |
Ian Rogers | 1ff3c98 | 2014-08-12 02:30:58 -0700 | [diff] [blame] | 166 | // Turn "Ljava/lang/String;" into "java.lang.String" using the conventions of |
| 167 | // java.lang.Class.getName(). |
Elliott Hughes | f1a5adc | 2012-02-10 18:09:35 -0800 | [diff] [blame] | 168 | std::string DescriptorToDot(const char* descriptor); |
Brian Carlstrom | aded5f7 | 2011-10-07 17:15:04 -0700 | [diff] [blame] | 169 | |
Ian Rogers | 1ff3c98 | 2014-08-12 02:30:58 -0700 | [diff] [blame] | 170 | // Turn "Ljava/lang/String;" into "java/lang/String" using the opposite conventions of |
| 171 | // java.lang.Class.getName(). |
Elliott Hughes | 91bf6cd | 2012-02-14 17:27:48 -0800 | [diff] [blame] | 172 | std::string DescriptorToName(const char* descriptor); |
| 173 | |
Elliott Hughes | 906e685 | 2011-10-28 14:52:10 -0700 | [diff] [blame] | 174 | // Tests for whether 's' is a valid class name in the three common forms: |
| 175 | bool IsValidBinaryClassName(const char* s); // "java.lang.String" |
| 176 | bool IsValidJniClassName(const char* s); // "java/lang/String" |
| 177 | bool IsValidDescriptor(const char* s); // "Ljava/lang/String;" |
Elliott Hughes | 64bf5a3 | 2011-09-20 14:43:12 -0700 | [diff] [blame] | 178 | |
jeffhao | 10037c8 | 2012-01-23 15:06:23 -0800 | [diff] [blame] | 179 | // Returns whether the given string is a valid field or method name, |
| 180 | // additionally allowing names that begin with '<' and end with '>'. |
| 181 | bool IsValidMemberName(const char* s); |
| 182 | |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 183 | // Returns the JNI native function name for the non-overloaded method 'm'. |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame^] | 184 | std::string JniShortName(ArtMethod* m) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 185 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 186 | // Returns the JNI native function name for the overloaded method 'm'. |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame^] | 187 | std::string JniLongName(ArtMethod* m) |
Ian Rogers | b726dcb | 2012-09-05 08:57:23 -0700 | [diff] [blame] | 188 | SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); |
Elliott Hughes | 79082e3 | 2011-08-25 12:07:32 -0700 | [diff] [blame] | 189 | |
Elliott Hughes | d92bec4 | 2011-09-02 17:04:36 -0700 | [diff] [blame] | 190 | bool ReadFileToString(const std::string& file_name, std::string* result); |
Andreas Gampe | a6dfdae | 2015-02-24 15:50:19 -0800 | [diff] [blame] | 191 | bool PrintFileToLog(const std::string& file_name, LogSeverity level); |
buzbee | c143c55 | 2011-08-20 17:38:58 -0700 | [diff] [blame] | 192 | |
Elliott Hughes | 48436bb | 2012-02-07 15:23:28 -0800 | [diff] [blame] | 193 | // Splits a string using the given separator character into a vector of |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 194 | // strings. Empty strings will be omitted. |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 195 | void Split(const std::string& s, char separator, std::vector<std::string>* result); |
Elliott Hughes | 48436bb | 2012-02-07 15:23:28 -0800 | [diff] [blame] | 196 | |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 197 | // Trims whitespace off both ends of the given string. |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 198 | std::string Trim(const std::string& s); |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 199 | |
Elliott Hughes | 48436bb | 2012-02-07 15:23:28 -0800 | [diff] [blame] | 200 | // Joins a vector of strings into a single string, using the given separator. |
Ian Rogers | 6f3dbba | 2014-10-14 17:41:57 -0700 | [diff] [blame] | 201 | template <typename StringT> std::string Join(const std::vector<StringT>& strings, char separator); |
Elliott Hughes | 3402380 | 2011-08-30 12:06:17 -0700 | [diff] [blame] | 202 | |
Elliott Hughes | 42ee142 | 2011-09-06 12:33:32 -0700 | [diff] [blame] | 203 | // Returns the calling thread's tid. (The C libraries don't expose this.) |
| 204 | pid_t GetTid(); |
| 205 | |
Elliott Hughes | 289be85 | 2012-06-12 13:57:20 -0700 | [diff] [blame] | 206 | // Returns the given thread's name. |
| 207 | std::string GetThreadName(pid_t tid); |
| 208 | |
Ian Rogers | 120f1c7 | 2012-09-28 17:17:10 -0700 | [diff] [blame] | 209 | // Returns details of the given thread's stack. |
Elliott Hughes | 6d3fc56 | 2014-08-27 11:47:01 -0700 | [diff] [blame] | 210 | void GetThreadStack(pthread_t thread, void** stack_base, size_t* stack_size, size_t* guard_size); |
Elliott Hughes | e188419 | 2012-04-23 12:38:15 -0700 | [diff] [blame] | 211 | |
Elliott Hughes | bfe487b | 2011-10-26 15:48:55 -0700 | [diff] [blame] | 212 | // Reads data from "/proc/self/task/${tid}/stat". |
Brian Carlstrom | 2921201 | 2013-09-12 22:18:30 -0700 | [diff] [blame] | 213 | void GetTaskStats(pid_t tid, char* state, int* utime, int* stime, int* task_cpu); |
Elliott Hughes | bfe487b | 2011-10-26 15:48:55 -0700 | [diff] [blame] | 214 | |
Elliott Hughes | 1bac54f | 2012-03-16 12:48:31 -0700 | [diff] [blame] | 215 | // Returns the name of the scheduler group for the given thread the current process, or the empty string. |
| 216 | std::string GetSchedulerGroupName(pid_t tid); |
| 217 | |
Elliott Hughes | dcc2474 | 2011-09-07 14:02:44 -0700 | [diff] [blame] | 218 | // Sets the name of the current thread. The name may be truncated to an |
| 219 | // implementation-defined limit. |
Elliott Hughes | 22869a9 | 2012-03-27 14:08:24 -0700 | [diff] [blame] | 220 | void SetThreadName(const char* thread_name); |
Elliott Hughes | dcc2474 | 2011-09-07 14:02:44 -0700 | [diff] [blame] | 221 | |
Elliott Hughes | 46e251b | 2012-05-22 15:10:45 -0700 | [diff] [blame] | 222 | // Dumps the native stack for thread 'tid' to 'os'. |
Kenny Root | 067d20f | 2014-03-05 14:57:21 -0800 | [diff] [blame] | 223 | void DumpNativeStack(std::ostream& os, pid_t tid, const char* prefix = "", |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame^] | 224 | ArtMethod* current_method = nullptr, void* ucontext = nullptr) |
Kenny Root | 067d20f | 2014-03-05 14:57:21 -0800 | [diff] [blame] | 225 | NO_THREAD_SAFETY_ANALYSIS; |
Elliott Hughes | 46e251b | 2012-05-22 15:10:45 -0700 | [diff] [blame] | 226 | |
| 227 | // Dumps the kernel stack for thread 'tid' to 'os'. Note that this is only available on linux-x86. |
| 228 | void DumpKernelStack(std::ostream& os, pid_t tid, const char* prefix = "", bool include_count = true); |
| 229 | |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 230 | // Find $ANDROID_ROOT, /system, or abort. |
Brian Carlstrom | a56fcd6 | 2012-02-04 21:23:01 -0800 | [diff] [blame] | 231 | const char* GetAndroidRoot(); |
| 232 | |
Dave Allison | 7020278 | 2013-10-22 17:52:19 -0700 | [diff] [blame] | 233 | // Find $ANDROID_DATA, /data, or abort. |
Brian Carlstrom | a56fcd6 | 2012-02-04 21:23:01 -0800 | [diff] [blame] | 234 | const char* GetAndroidData(); |
Mathieu Chartier | 2cebb24 | 2015-04-21 16:50:40 -0700 | [diff] [blame] | 235 | // Find $ANDROID_DATA, /data, or return null. |
Alex Light | a59dd80 | 2014-07-02 16:28:08 -0700 | [diff] [blame] | 236 | const char* GetAndroidDataSafe(std::string* error_msg); |
Brian Carlstrom | a56fcd6 | 2012-02-04 21:23:01 -0800 | [diff] [blame] | 237 | |
Andreas Gampe | 40da286 | 2015-02-27 12:49:04 -0800 | [diff] [blame] | 238 | // Returns the dalvik-cache location, with subdir appended. Returns the empty string if the cache |
| 239 | // could not be found (or created). |
| 240 | std::string GetDalvikCache(const char* subdir, bool create_if_absent = true); |
Narayan Kamath | 11d9f06 | 2014-04-23 20:24:57 +0100 | [diff] [blame] | 241 | // Returns the dalvik-cache location, or dies trying. subdir will be |
| 242 | // appended to the cache location. |
| 243 | std::string GetDalvikCacheOrDie(const char* subdir, bool create_if_absent = true); |
Alex Light | a59dd80 | 2014-07-02 16:28:08 -0700 | [diff] [blame] | 244 | // Return true if we found the dalvik cache and stored it in the dalvik_cache argument. |
| 245 | // have_android_data will be set to true if we have an ANDROID_DATA that exists, |
| 246 | // dalvik_cache_exists will be true if there is a dalvik-cache directory that is present. |
Andreas Gampe | 3c13a79 | 2014-09-18 20:56:04 -0700 | [diff] [blame] | 247 | // The flag is_global_cache tells whether this cache is /data/dalvik-cache. |
Alex Light | a59dd80 | 2014-07-02 16:28:08 -0700 | [diff] [blame] | 248 | void GetDalvikCache(const char* subdir, bool create_if_absent, std::string* dalvik_cache, |
Andreas Gampe | 3c13a79 | 2014-09-18 20:56:04 -0700 | [diff] [blame] | 249 | bool* have_android_data, bool* dalvik_cache_exists, bool* is_global_cache); |
Brian Carlstrom | a9f1978 | 2011-10-13 00:14:47 -0700 | [diff] [blame] | 250 | |
Alex Light | a59dd80 | 2014-07-02 16:28:08 -0700 | [diff] [blame] | 251 | // Returns the absolute dalvik-cache path for a DexFile or OatFile. The path returned will be |
| 252 | // rooted at cache_location. |
| 253 | bool GetDalvikCacheFilename(const char* file_location, const char* cache_location, |
| 254 | std::string* filename, std::string* error_msg); |
Narayan Kamath | 11d9f06 | 2014-04-23 20:24:57 +0100 | [diff] [blame] | 255 | // Returns the absolute dalvik-cache path for a DexFile or OatFile, or |
| 256 | // dies trying. The path returned will be rooted at cache_location. |
| 257 | std::string GetDalvikCacheFilenameOrDie(const char* file_location, |
| 258 | const char* cache_location); |
jeffhao | 262bf46 | 2011-10-20 18:36:32 -0700 | [diff] [blame] | 259 | |
Brian Carlstrom | 0e12bdc | 2014-05-14 17:44:28 -0700 | [diff] [blame] | 260 | // Returns the system location for an image |
Brian Carlstrom | 2afe494 | 2014-05-19 10:25:33 -0700 | [diff] [blame] | 261 | std::string GetSystemImageFilename(const char* location, InstructionSet isa); |
Brian Carlstrom | 0e12bdc | 2014-05-14 17:44:28 -0700 | [diff] [blame] | 262 | |
Brian Carlstrom | 7c3d13a | 2013-09-04 17:15:11 -0700 | [diff] [blame] | 263 | // Check whether the given magic matches a known file type. |
| 264 | bool IsZipMagic(uint32_t magic); |
| 265 | bool IsDexMagic(uint32_t magic); |
| 266 | bool IsOatMagic(uint32_t magic); |
Brian Carlstrom | b7bbba4 | 2011-10-13 14:58:47 -0700 | [diff] [blame] | 267 | |
Brian Carlstrom | 6449c62 | 2014-02-10 23:48:36 -0800 | [diff] [blame] | 268 | // Wrapper on fork/execv to run a command in a subprocess. |
| 269 | bool Exec(std::vector<std::string>& arg_vector, std::string* error_msg); |
| 270 | |
Mathieu Chartier | d22d548 | 2012-11-06 17:14:12 -0800 | [diff] [blame] | 271 | class VoidFunctor { |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 272 | public: |
Mathieu Chartier | d22d548 | 2012-11-06 17:14:12 -0800 | [diff] [blame] | 273 | template <typename A> |
Brian Carlstrom | df62950 | 2013-07-17 22:39:56 -0700 | [diff] [blame] | 274 | inline void operator() (A a) const { |
Mathieu Chartier | d22d548 | 2012-11-06 17:14:12 -0800 | [diff] [blame] | 275 | UNUSED(a); |
| 276 | } |
| 277 | |
| 278 | template <typename A, typename B> |
Brian Carlstrom | df62950 | 2013-07-17 22:39:56 -0700 | [diff] [blame] | 279 | inline void operator() (A a, B b) const { |
Ian Rogers | 6a3c1fc | 2014-10-31 00:33:20 -0700 | [diff] [blame] | 280 | UNUSED(a, b); |
Mathieu Chartier | d22d548 | 2012-11-06 17:14:12 -0800 | [diff] [blame] | 281 | } |
| 282 | |
| 283 | template <typename A, typename B, typename C> |
Brian Carlstrom | df62950 | 2013-07-17 22:39:56 -0700 | [diff] [blame] | 284 | inline void operator() (A a, B b, C c) const { |
Ian Rogers | 6a3c1fc | 2014-10-31 00:33:20 -0700 | [diff] [blame] | 285 | UNUSED(a, b, c); |
Mathieu Chartier | d22d548 | 2012-11-06 17:14:12 -0800 | [diff] [blame] | 286 | } |
Mathieu Chartier | 357e9be | 2012-08-01 11:00:14 -0700 | [diff] [blame] | 287 | }; |
| 288 | |
Vladimir Marko | 80b96d1 | 2015-02-19 15:50:28 +0000 | [diff] [blame] | 289 | template <typename Alloc> |
| 290 | void Push32(std::vector<uint8_t, Alloc>* buf, int32_t data) { |
| 291 | buf->push_back(data & 0xff); |
| 292 | buf->push_back((data >> 8) & 0xff); |
| 293 | buf->push_back((data >> 16) & 0xff); |
| 294 | buf->push_back((data >> 24) & 0xff); |
| 295 | } |
Tong Shen | 547cdfd | 2014-08-05 01:54:19 -0700 | [diff] [blame] | 296 | |
| 297 | void EncodeUnsignedLeb128(uint32_t data, std::vector<uint8_t>* buf); |
| 298 | void EncodeSignedLeb128(int32_t data, std::vector<uint8_t>* buf); |
| 299 | |
Vladimir Marko | aa4497d | 2014-09-05 14:01:17 +0100 | [diff] [blame] | 300 | // Deleter using free() for use with std::unique_ptr<>. See also UniqueCPtr<> below. |
| 301 | struct FreeDelete { |
| 302 | // NOTE: Deleting a const object is valid but free() takes a non-const pointer. |
| 303 | void operator()(const void* ptr) const { |
| 304 | free(const_cast<void*>(ptr)); |
| 305 | } |
| 306 | }; |
| 307 | |
| 308 | // Alias for std::unique_ptr<> that uses the C function free() to delete objects. |
| 309 | template <typename T> |
| 310 | using UniqueCPtr = std::unique_ptr<T, FreeDelete>; |
| 311 | |
Igor Murashkin | aaebaa0 | 2015-01-26 10:55:53 -0800 | [diff] [blame] | 312 | // C++14 from-the-future import (std::make_unique) |
| 313 | // Invoke the constructor of 'T' with the provided args, and wrap the result in a unique ptr. |
| 314 | template <typename T, typename ... Args> |
| 315 | std::unique_ptr<T> MakeUnique(Args&& ... args) { |
| 316 | return std::unique_ptr<T>(new T(std::forward<Args>(args)...)); |
| 317 | } |
| 318 | |
Mathieu Chartier | 50030ef | 2015-05-08 14:19:26 -0700 | [diff] [blame] | 319 | inline bool TestBitmap(size_t idx, const uint8_t* bitmap) { |
| 320 | return ((bitmap[idx / kBitsPerByte] >> (idx % kBitsPerByte)) & 0x01) != 0; |
| 321 | } |
| 322 | |
Mathieu Chartier | e401d14 | 2015-04-22 13:56:20 -0700 | [diff] [blame^] | 323 | static inline constexpr bool ValidPointerSize(size_t pointer_size) { |
| 324 | return pointer_size == 4 || pointer_size == 8; |
| 325 | } |
Mathieu Chartier | 50030ef | 2015-05-08 14:19:26 -0700 | [diff] [blame] | 326 | |
Carl Shapiro | 6b6b5f0 | 2011-06-21 15:05:09 -0700 | [diff] [blame] | 327 | } // namespace art |
Carl Shapiro | a5d5cfd | 2011-06-21 12:46:59 -0700 | [diff] [blame] | 328 | |
Brian Carlstrom | fc0e321 | 2013-07-17 14:40:12 -0700 | [diff] [blame] | 329 | #endif // ART_RUNTIME_UTILS_H_ |