utils.h revision 47393386aa1f44c61a10045c7dbb5d559c9f7cab
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#include <stdlib.h> 22 23#include <limits> 24#include <memory> 25#include <random> 26#include <string> 27#include <type_traits> 28#include <vector> 29 30#include "arch/instruction_set.h" 31#include "base/casts.h" 32#include "base/logging.h" 33#include "base/mutex.h" 34#include "base/stringpiece.h" 35#include "globals.h" 36#include "primitive.h" 37 38class BacktraceMap; 39 40namespace art { 41 42class ArtField; 43class ArtMethod; 44class DexFile; 45 46namespace mirror { 47class Class; 48class Object; 49class String; 50} // namespace mirror 51 52template <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 80// Return whether x / divisor == x * (1.0f / divisor), for every float x. 81static constexpr bool CanDivideByReciprocalMultiplyFloat(int32_t divisor) { 82 // True, if the most significant bits of divisor are 0. 83 return ((divisor & 0x7fffff) == 0); 84} 85 86// Return whether x / divisor == x * (1.0 / divisor), for every double x. 87static constexpr bool CanDivideByReciprocalMultiplyDouble(int64_t divisor) { 88 // True, if the most significant bits of divisor are 0. 89 return ((divisor & ((UINT64_C(1) << 52) - 1)) == 0); 90} 91 92static inline uint32_t PointerToLowMemUInt32(const void* p) { 93 uintptr_t intp = reinterpret_cast<uintptr_t>(p); 94 DCHECK_LE(intp, 0xFFFFFFFFU); 95 return intp & 0xFFFFFFFFU; 96} 97 98static inline bool NeedsEscaping(uint16_t ch) { 99 return (ch < ' ' || ch > '~'); 100} 101 102template <typename T> T SafeAbs(T value) { 103 // std::abs has undefined behavior on min limits. 104 DCHECK_NE(value, std::numeric_limits<T>::min()); 105 return std::abs(value); 106} 107 108template <typename T> T AbsOrMin(T value) { 109 return (value == std::numeric_limits<T>::min()) 110 ? value 111 : std::abs(value); 112} 113 114template <typename T> 115inline typename std::make_unsigned<T>::type MakeUnsigned(T x) { 116 return static_cast<typename std::make_unsigned<T>::type>(x); 117} 118 119std::string PrintableChar(uint16_t ch); 120 121// Returns an ASCII string corresponding to the given UTF-8 string. 122// Java escapes are used for non-ASCII characters. 123std::string PrintableString(const char* utf8); 124 125// Tests whether 's' starts with 'prefix'. 126bool StartsWith(const std::string& s, const char* prefix); 127 128// Tests whether 's' ends with 'suffix'. 129bool EndsWith(const std::string& s, const char* suffix); 130 131// Used to implement PrettyClass, PrettyField, PrettyMethod, and PrettyTypeOf, 132// one of which is probably more useful to you. 133// Returns a human-readable equivalent of 'descriptor'. So "I" would be "int", 134// "[[I" would be "int[][]", "[Ljava/lang/String;" would be 135// "java.lang.String[]", and so forth. 136std::string PrettyDescriptor(mirror::String* descriptor) 137 SHARED_REQUIRES(Locks::mutator_lock_); 138std::string PrettyDescriptor(const char* descriptor); 139std::string PrettyDescriptor(mirror::Class* klass) 140 SHARED_REQUIRES(Locks::mutator_lock_); 141std::string PrettyDescriptor(Primitive::Type type); 142 143// Returns a human-readable signature for 'f'. Something like "a.b.C.f" or 144// "int a.b.C.f" (depending on the value of 'with_type'). 145std::string PrettyField(ArtField* f, bool with_type = true) 146 SHARED_REQUIRES(Locks::mutator_lock_); 147std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type = true); 148 149// Returns a human-readable signature for 'm'. Something like "a.b.C.m" or 150// "a.b.C.m(II)V" (depending on the value of 'with_signature'). 151std::string PrettyMethod(ArtMethod* m, bool with_signature = true) 152 SHARED_REQUIRES(Locks::mutator_lock_); 153std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature = true); 154 155// Returns a human-readable form of the name of the *class* of the given object. 156// So given an instance of java.lang.String, the output would 157// be "java.lang.String". Given an array of int, the output would be "int[]". 158// Given String.class, the output would be "java.lang.Class<java.lang.String>". 159std::string PrettyTypeOf(mirror::Object* obj) 160 SHARED_REQUIRES(Locks::mutator_lock_); 161 162// Returns a human-readable form of the type at an index in the specified dex file. 163// Example outputs: char[], java.lang.String. 164std::string PrettyType(uint32_t type_idx, const DexFile& dex_file); 165 166// Returns a human-readable form of the name of the given class. 167// Given String.class, the output would be "java.lang.Class<java.lang.String>". 168std::string PrettyClass(mirror::Class* c) 169 SHARED_REQUIRES(Locks::mutator_lock_); 170 171// Returns a human-readable form of the name of the given class with its class loader. 172std::string PrettyClassAndClassLoader(mirror::Class* c) 173 SHARED_REQUIRES(Locks::mutator_lock_); 174 175// Returns a human-readable version of the Java part of the access flags, e.g., "private static " 176// (note the trailing whitespace). 177std::string PrettyJavaAccessFlags(uint32_t access_flags); 178 179// Returns a human-readable size string such as "1MB". 180std::string PrettySize(int64_t size_in_bytes); 181 182// Performs JNI name mangling as described in section 11.3 "Linking Native Methods" 183// of the JNI spec. 184std::string MangleForJni(const std::string& s); 185 186// Turn "java.lang.String" into "Ljava/lang/String;". 187std::string DotToDescriptor(const char* class_name); 188 189// Turn "Ljava/lang/String;" into "java.lang.String" using the conventions of 190// java.lang.Class.getName(). 191std::string DescriptorToDot(const char* descriptor); 192 193// Turn "Ljava/lang/String;" into "java/lang/String" using the opposite conventions of 194// java.lang.Class.getName(). 195std::string DescriptorToName(const char* descriptor); 196 197// Tests for whether 's' is a valid class name in the three common forms: 198bool IsValidBinaryClassName(const char* s); // "java.lang.String" 199bool IsValidJniClassName(const char* s); // "java/lang/String" 200bool IsValidDescriptor(const char* s); // "Ljava/lang/String;" 201 202// Returns whether the given string is a valid field or method name, 203// additionally allowing names that begin with '<' and end with '>'. 204bool IsValidMemberName(const char* s); 205 206// Returns the JNI native function name for the non-overloaded method 'm'. 207std::string JniShortName(ArtMethod* m) 208 SHARED_REQUIRES(Locks::mutator_lock_); 209// Returns the JNI native function name for the overloaded method 'm'. 210std::string JniLongName(ArtMethod* m) 211 SHARED_REQUIRES(Locks::mutator_lock_); 212 213bool ReadFileToString(const std::string& file_name, std::string* result); 214bool PrintFileToLog(const std::string& file_name, LogSeverity level); 215 216// Splits a string using the given separator character into a vector of 217// strings. Empty strings will be omitted. 218void Split(const std::string& s, char separator, std::vector<std::string>* result); 219 220// Trims whitespace off both ends of the given string. 221std::string Trim(const std::string& s); 222 223// Joins a vector of strings into a single string, using the given separator. 224template <typename StringT> std::string Join(const std::vector<StringT>& strings, char separator); 225 226// Returns the calling thread's tid. (The C libraries don't expose this.) 227pid_t GetTid(); 228 229// Returns the given thread's name. 230std::string GetThreadName(pid_t tid); 231 232// Returns details of the given thread's stack. 233void GetThreadStack(pthread_t thread, void** stack_base, size_t* stack_size, size_t* guard_size); 234 235// Reads data from "/proc/self/task/${tid}/stat". 236void GetTaskStats(pid_t tid, char* state, int* utime, int* stime, int* task_cpu); 237 238// Returns the name of the scheduler group for the given thread the current process, or the empty string. 239std::string GetSchedulerGroupName(pid_t tid); 240 241// Sets the name of the current thread. The name may be truncated to an 242// implementation-defined limit. 243void SetThreadName(const char* thread_name); 244 245// Dumps the native stack for thread 'tid' to 'os'. 246void DumpNativeStack(std::ostream& os, 247 pid_t tid, 248 BacktraceMap* map = nullptr, 249 const char* prefix = "", 250 ArtMethod* current_method = nullptr, 251 void* ucontext = nullptr) 252 NO_THREAD_SAFETY_ANALYSIS; 253 254// Dumps the kernel stack for thread 'tid' to 'os'. Note that this is only available on linux-x86. 255void DumpKernelStack(std::ostream& os, 256 pid_t tid, 257 const char* prefix = "", 258 bool include_count = true); 259 260// Find $ANDROID_ROOT, /system, or abort. 261const char* GetAndroidRoot(); 262 263// Find $ANDROID_DATA, /data, or abort. 264const char* GetAndroidData(); 265// Find $ANDROID_DATA, /data, or return null. 266const char* GetAndroidDataSafe(std::string* error_msg); 267 268// Returns the dalvik-cache location, with subdir appended. Returns the empty string if the cache 269// could not be found (or created). 270std::string GetDalvikCache(const char* subdir, bool create_if_absent = true); 271// Returns the dalvik-cache location, or dies trying. subdir will be 272// appended to the cache location. 273std::string GetDalvikCacheOrDie(const char* subdir, bool create_if_absent = true); 274// Return true if we found the dalvik cache and stored it in the dalvik_cache argument. 275// have_android_data will be set to true if we have an ANDROID_DATA that exists, 276// dalvik_cache_exists will be true if there is a dalvik-cache directory that is present. 277// The flag is_global_cache tells whether this cache is /data/dalvik-cache. 278void GetDalvikCache(const char* subdir, bool create_if_absent, std::string* dalvik_cache, 279 bool* have_android_data, bool* dalvik_cache_exists, bool* is_global_cache); 280 281// Returns the absolute dalvik-cache path for a DexFile or OatFile. The path returned will be 282// rooted at cache_location. 283bool GetDalvikCacheFilename(const char* file_location, const char* cache_location, 284 std::string* filename, std::string* error_msg); 285// Returns the absolute dalvik-cache path for a DexFile or OatFile, or 286// dies trying. The path returned will be rooted at cache_location. 287std::string GetDalvikCacheFilenameOrDie(const char* file_location, 288 const char* cache_location); 289 290// Returns the system location for an image 291std::string GetSystemImageFilename(const char* location, InstructionSet isa); 292 293// Wrapper on fork/execv to run a command in a subprocess. 294bool Exec(std::vector<std::string>& arg_vector, std::string* error_msg); 295int ExecAndReturnCode(std::vector<std::string>& arg_vector, std::string* error_msg); 296 297// Returns true if the file exists. 298bool FileExists(const std::string& filename); 299bool FileExistsAndNotEmpty(const std::string& filename); 300 301class VoidFunctor { 302 public: 303 template <typename A> 304 inline void operator() (A a ATTRIBUTE_UNUSED) const { 305 } 306 307 template <typename A, typename B> 308 inline void operator() (A a ATTRIBUTE_UNUSED, B b ATTRIBUTE_UNUSED) const { 309 } 310 311 template <typename A, typename B, typename C> 312 inline void operator() (A a ATTRIBUTE_UNUSED, B b ATTRIBUTE_UNUSED, C c ATTRIBUTE_UNUSED) const { 313 } 314}; 315 316template <typename Vector> 317void Push32(Vector* buf, int32_t data) { 318 static_assert(std::is_same<typename Vector::value_type, uint8_t>::value, "Invalid value type"); 319 buf->push_back(data & 0xff); 320 buf->push_back((data >> 8) & 0xff); 321 buf->push_back((data >> 16) & 0xff); 322 buf->push_back((data >> 24) & 0xff); 323} 324 325inline bool TestBitmap(size_t idx, const uint8_t* bitmap) { 326 return ((bitmap[idx / kBitsPerByte] >> (idx % kBitsPerByte)) & 0x01) != 0; 327} 328 329static inline constexpr bool ValidPointerSize(size_t pointer_size) { 330 return pointer_size == 4 || pointer_size == 8; 331} 332 333void DumpMethodCFG(ArtMethod* method, std::ostream& os) SHARED_REQUIRES(Locks::mutator_lock_); 334void DumpMethodCFG(const DexFile* dex_file, uint32_t dex_method_idx, std::ostream& os); 335 336static inline const void* EntryPointToCodePointer(const void* entry_point) { 337 uintptr_t code = reinterpret_cast<uintptr_t>(entry_point); 338 // TODO: Make this Thumb2 specific. It is benign on other architectures as code is always at 339 // least 2 byte aligned. 340 code &= ~0x1; 341 return reinterpret_cast<const void*>(code); 342} 343 344using UsageFn = void (*)(const char*, ...); 345 346template <typename T> 347static void ParseUintOption(const StringPiece& option, 348 const std::string& option_name, 349 T* out, 350 UsageFn Usage, 351 bool is_long_option = true) { 352 std::string option_prefix = option_name + (is_long_option ? "=" : ""); 353 DCHECK(option.starts_with(option_prefix)) << option << " " << option_prefix; 354 const char* value_string = option.substr(option_prefix.size()).data(); 355 int64_t parsed_integer_value = 0; 356 if (!ParseInt(value_string, &parsed_integer_value)) { 357 Usage("Failed to parse %s '%s' as an integer", option_name.c_str(), value_string); 358 } 359 if (parsed_integer_value < 0) { 360 Usage("%s passed a negative value %d", option_name.c_str(), parsed_integer_value); 361 } 362 *out = dchecked_integral_cast<T>(parsed_integer_value); 363} 364 365void ParseDouble(const std::string& option, 366 char after_char, 367 double min, 368 double max, 369 double* parsed_value, 370 UsageFn Usage); 371 372#if defined(__BIONIC__) 373struct Arc4RandomGenerator { 374 typedef uint32_t result_type; 375 static constexpr uint32_t min() { return std::numeric_limits<uint32_t>::min(); } 376 static constexpr uint32_t max() { return std::numeric_limits<uint32_t>::max(); } 377 uint32_t operator() () { return arc4random(); } 378}; 379using RNG = Arc4RandomGenerator; 380#else 381using RNG = std::random_device; 382#endif 383 384template <typename T> 385T GetRandomNumber(T min, T max) { 386 CHECK_LT(min, max); 387 std::uniform_int_distribution<T> dist(min, max); 388 RNG rng; 389 return dist(rng); 390} 391 392// Return the file size in bytes or -1 if the file does not exists. 393int64_t GetFileSizeBytes(const std::string& filename); 394 395// Sleep forever and never come back. 396NO_RETURN void SleepForever(); 397 398inline void FlushInstructionCache(char* begin, char* end) { 399 // Only use __builtin___clear_cache with Clang or with GCC >= 4.3.0 400 // (__builtin___clear_cache was introduced in GCC 4.3.0). 401#if defined(__clang__) || GCC_VERSION >= 40300 402 __builtin___clear_cache(begin, end); 403#else 404 // Only warn on non-Intel platforms, as x86 and x86-64 do not need 405 // cache flush instructions, as long as the "code uses the same 406 // linear address for modifying and fetching the instruction". See 407 // "Intel(R) 64 and IA-32 Architectures Software Developer's Manual 408 // Volume 3A: System Programming Guide, Part 1", section 11.6 409 // "Self-Modifying Code". 410#if !defined(__i386__) && !defined(__x86_64__) 411 UNIMPLEMENTED(WARNING) << "cache flush"; 412#endif 413#endif 414} 415 416} // namespace art 417 418#endif // ART_RUNTIME_UTILS_H_ 419