1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ART_RUNTIME_UTILS_H_ 18 #define ART_RUNTIME_UTILS_H_ 19 20 #include <pthread.h> 21 22 #include <limits> 23 #include <memory> 24 #include <string> 25 #include <type_traits> 26 #include <vector> 27 28 #include "arch/instruction_set.h" 29 #include "base/logging.h" 30 #include "base/mutex.h" 31 #include "globals.h" 32 #include "primitive.h" 33 34 namespace art { 35 36 class ArtField; 37 class ArtMethod; 38 class DexFile; 39 40 namespace mirror { 41 class Class; 42 class Object; 43 class String; 44 } // namespace mirror 45 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 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 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 } 91 92 static inline bool NeedsEscaping(uint16_t ch) { 93 return (ch < ' ' || ch > '~'); 94 } 95 96 std::string PrintableChar(uint16_t ch); 97 98 // Returns an ASCII string corresponding to the given UTF-8 string. 99 // Java escapes are used for non-ASCII characters. 100 std::string PrintableString(const char* utf8); 101 102 // Tests whether 's' starts with 'prefix'. 103 bool StartsWith(const std::string& s, const char* prefix); 104 105 // Tests whether 's' ends with 'suffix'. 106 bool EndsWith(const std::string& s, const char* suffix); 107 108 // Used to implement PrettyClass, PrettyField, PrettyMethod, and PrettyTypeOf, 109 // one of which is probably more useful to you. 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. 113 std::string PrettyDescriptor(mirror::String* descriptor) 114 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 115 std::string PrettyDescriptor(const char* descriptor); 116 std::string PrettyDescriptor(mirror::Class* klass) 117 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 118 std::string PrettyDescriptor(Primitive::Type type); 119 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'). 122 std::string PrettyField(ArtField* f, bool with_type = true) 123 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 124 std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type = true); 125 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'). 128 std::string PrettyMethod(ArtMethod* m, bool with_signature = true) 129 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 130 std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature = true); 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 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>". 136 std::string PrettyTypeOf(mirror::Object* obj) 137 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 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. 141 std::string PrettyType(uint32_t type_idx, const DexFile& dex_file); 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>". 145 std::string PrettyClass(mirror::Class* c) 146 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 147 148 // Returns a human-readable form of the name of the given class with its class loader. 149 std::string PrettyClassAndClassLoader(mirror::Class* c) 150 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 151 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 156 // Returns a human-readable size string such as "1MB". 157 std::string PrettySize(int64_t size_in_bytes); 158 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 163 // Turn "java.lang.String" into "Ljava/lang/String;". 164 std::string DotToDescriptor(const char* class_name); 165 166 // Turn "Ljava/lang/String;" into "java.lang.String" using the conventions of 167 // java.lang.Class.getName(). 168 std::string DescriptorToDot(const char* descriptor); 169 170 // Turn "Ljava/lang/String;" into "java/lang/String" using the opposite conventions of 171 // java.lang.Class.getName(). 172 std::string DescriptorToName(const char* descriptor); 173 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;" 178 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 183 // Returns the JNI native function name for the non-overloaded method 'm'. 184 std::string JniShortName(ArtMethod* m) 185 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 186 // Returns the JNI native function name for the overloaded method 'm'. 187 std::string JniLongName(ArtMethod* m) 188 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 189 190 bool ReadFileToString(const std::string& file_name, std::string* result); 191 bool PrintFileToLog(const std::string& file_name, LogSeverity level); 192 193 // Splits a string using the given separator character into a vector of 194 // strings. Empty strings will be omitted. 195 void Split(const std::string& s, char separator, std::vector<std::string>* result); 196 197 // Trims whitespace off both ends of the given string. 198 std::string Trim(const std::string& s); 199 200 // Joins a vector of strings into a single string, using the given separator. 201 template <typename StringT> std::string Join(const std::vector<StringT>& strings, char separator); 202 203 // Returns the calling thread's tid. (The C libraries don't expose this.) 204 pid_t GetTid(); 205 206 // Returns the given thread's name. 207 std::string GetThreadName(pid_t tid); 208 209 // Returns details of the given thread's stack. 210 void GetThreadStack(pthread_t thread, void** stack_base, size_t* stack_size, size_t* guard_size); 211 212 // Reads data from "/proc/self/task/${tid}/stat". 213 void GetTaskStats(pid_t tid, char* state, int* utime, int* stime, int* task_cpu); 214 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 218 // Sets the name of the current thread. The name may be truncated to an 219 // implementation-defined limit. 220 void SetThreadName(const char* thread_name); 221 222 // Dumps the native stack for thread 'tid' to 'os'. 223 void DumpNativeStack(std::ostream& os, pid_t tid, const char* prefix = "", 224 ArtMethod* current_method = nullptr, void* ucontext = nullptr) 225 NO_THREAD_SAFETY_ANALYSIS; 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 230 // Find $ANDROID_ROOT, /system, or abort. 231 const char* GetAndroidRoot(); 232 233 // Find $ANDROID_DATA, /data, or abort. 234 const char* GetAndroidData(); 235 // Find $ANDROID_DATA, /data, or return null. 236 const char* GetAndroidDataSafe(std::string* error_msg); 237 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); 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); 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. 247 // The flag is_global_cache tells whether this cache is /data/dalvik-cache. 248 void GetDalvikCache(const char* subdir, bool create_if_absent, std::string* dalvik_cache, 249 bool* have_android_data, bool* dalvik_cache_exists, bool* is_global_cache); 250 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); 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); 259 260 // Returns the system location for an image 261 std::string GetSystemImageFilename(const char* location, InstructionSet isa); 262 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); 267 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 271 class VoidFunctor { 272 public: 273 template <typename A> 274 inline void operator() (A a) const { 275 UNUSED(a); 276 } 277 278 template <typename A, typename B> 279 inline void operator() (A a, B b) const { 280 UNUSED(a, b); 281 } 282 283 template <typename A, typename B, typename C> 284 inline void operator() (A a, B b, C c) const { 285 UNUSED(a, b, c); 286 } 287 }; 288 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 } 296 297 void EncodeUnsignedLeb128(uint32_t data, std::vector<uint8_t>* buf); 298 void EncodeSignedLeb128(int32_t data, std::vector<uint8_t>* buf); 299 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 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 319 inline bool TestBitmap(size_t idx, const uint8_t* bitmap) { 320 return ((bitmap[idx / kBitsPerByte] >> (idx % kBitsPerByte)) & 0x01) != 0; 321 } 322 323 static inline constexpr bool ValidPointerSize(size_t pointer_size) { 324 return pointer_size == 4 || pointer_size == 8; 325 } 326 327 } // namespace art 328 329 #endif // ART_RUNTIME_UTILS_H_ 330