utils.h revision be0562fb14e6754ee932b8d9c97e2a6df3a91119
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 <string> 24#include <vector> 25 26#include "base/logging.h" 27#include "globals.h" 28#include "instruction_set.h" 29#include "primitive.h" 30 31#ifdef HAVE_ANDROID_OS 32#include "cutils/properties.h" 33#endif 34 35namespace art { 36 37class DexFile; 38 39namespace mirror { 40class ArtField; 41class ArtMethod; 42class Class; 43class Object; 44class String; 45} // namespace mirror 46 47enum TimeUnit { 48 kTimeUnitNanosecond, 49 kTimeUnitMicrosecond, 50 kTimeUnitMillisecond, 51 kTimeUnitSecond, 52}; 53 54template <typename T> 55bool ParseUint(const char *in, T* out) { 56 char* end; 57 unsigned long long int result = strtoull(in, &end, 0); // NOLINT(runtime/int) 58 if (in == end || *end != '\0') { 59 return false; 60 } 61 if (std::numeric_limits<T>::max() < result) { 62 return false; 63 } 64 *out = static_cast<T>(result); 65 return true; 66} 67 68template <typename T> 69bool ParseInt(const char* in, T* out) { 70 char* end; 71 long long int result = strtoll(in, &end, 0); // NOLINT(runtime/int) 72 if (in == end || *end != '\0') { 73 return false; 74 } 75 if (result < std::numeric_limits<T>::min() || std::numeric_limits<T>::max() < result) { 76 return false; 77 } 78 *out = static_cast<T>(result); 79 return true; 80} 81 82template<typename T> 83static constexpr bool IsPowerOfTwo(T x) { 84 return (x & (x - 1)) == 0; 85} 86 87template<int n, typename T> 88static inline bool IsAligned(T x) { 89 COMPILE_ASSERT((n & (n - 1)) == 0, n_not_power_of_two); 90 return (x & (n - 1)) == 0; 91} 92 93template<int n, typename T> 94static inline bool IsAligned(T* x) { 95 return IsAligned<n>(reinterpret_cast<const uintptr_t>(x)); 96} 97 98template<typename T> 99static inline bool IsAlignedParam(T x, int n) { 100 return (x & (n - 1)) == 0; 101} 102 103#define CHECK_ALIGNED(value, alignment) \ 104 CHECK(::art::IsAligned<alignment>(value)) << reinterpret_cast<const void*>(value) 105 106#define DCHECK_ALIGNED(value, alignment) \ 107 DCHECK(::art::IsAligned<alignment>(value)) << reinterpret_cast<const void*>(value) 108 109#define DCHECK_ALIGNED_PARAM(value, alignment) \ 110 DCHECK(::art::IsAlignedParam(value, alignment)) << reinterpret_cast<const void*>(value) 111 112// Check whether an N-bit two's-complement representation can hold value. 113static inline bool IsInt(int N, word value) { 114 CHECK_LT(0, N); 115 CHECK_LT(N, kBitsPerWord); 116 word limit = static_cast<word>(1) << (N - 1); 117 return (-limit <= value) && (value < limit); 118} 119 120static inline bool IsUint(int N, word value) { 121 CHECK_LT(0, N); 122 CHECK_LT(N, kBitsPerWord); 123 word limit = static_cast<word>(1) << N; 124 return (0 <= value) && (value < limit); 125} 126 127static inline bool IsAbsoluteUint(int N, word value) { 128 CHECK_LT(0, N); 129 CHECK_LT(N, kBitsPerWord); 130 if (value < 0) value = -value; 131 return IsUint(N, value); 132} 133 134static inline uint16_t Low16Bits(uint32_t value) { 135 return static_cast<uint16_t>(value); 136} 137 138static inline uint16_t High16Bits(uint32_t value) { 139 return static_cast<uint16_t>(value >> 16); 140} 141 142static inline uint32_t Low32Bits(uint64_t value) { 143 return static_cast<uint32_t>(value); 144} 145 146static inline uint32_t High32Bits(uint64_t value) { 147 return static_cast<uint32_t>(value >> 32); 148} 149 150// A static if which determines whether to return type A or B based on the condition boolean. 151template <bool condition, typename A, typename B> 152struct TypeStaticIf { 153 typedef A type; 154}; 155 156// Specialization to handle the false case. 157template <typename A, typename B> 158struct TypeStaticIf<false, A, B> { 159 typedef B type; 160}; 161 162// Type identity. 163template <typename T> 164struct TypeIdentity { 165 typedef T type; 166}; 167 168// For rounding integers. 169template<typename T> 170static constexpr T RoundDown(T x, typename TypeIdentity<T>::type n) WARN_UNUSED; 171 172template<typename T> 173static constexpr T RoundDown(T x, typename TypeIdentity<T>::type n) { 174 return 175 DCHECK_CONSTEXPR(IsPowerOfTwo(n), , T(0)) 176 (x & -n); 177} 178 179template<typename T> 180static constexpr T RoundUp(T x, typename TypeIdentity<T>::type n) WARN_UNUSED; 181 182template<typename T> 183static constexpr T RoundUp(T x, typename TypeIdentity<T>::type n) { 184 return RoundDown(x + n - 1, n); 185} 186 187// For aligning pointers. 188template<typename T> 189static inline T* AlignDown(T* x, uintptr_t n) WARN_UNUSED; 190 191template<typename T> 192static inline T* AlignDown(T* x, uintptr_t n) { 193 return reinterpret_cast<T*>(RoundDown(reinterpret_cast<uintptr_t>(x), n)); 194} 195 196template<typename T> 197static inline T* AlignUp(T* x, uintptr_t n) WARN_UNUSED; 198 199template<typename T> 200static inline T* AlignUp(T* x, uintptr_t n) { 201 return reinterpret_cast<T*>(RoundUp(reinterpret_cast<uintptr_t>(x), n)); 202} 203 204// Implementation is from "Hacker's Delight" by Henry S. Warren, Jr., 205// figure 3-3, page 48, where the function is called clp2. 206static inline uint32_t RoundUpToPowerOfTwo(uint32_t x) { 207 x = x - 1; 208 x = x | (x >> 1); 209 x = x | (x >> 2); 210 x = x | (x >> 4); 211 x = x | (x >> 8); 212 x = x | (x >> 16); 213 return x + 1; 214} 215 216template<typename T> 217static constexpr int CLZ(T x) { 218 return (sizeof(T) == sizeof(uint32_t)) 219 ? __builtin_clz(x) 220 : __builtin_clzll(x); 221} 222 223template<typename T> 224static constexpr int CTZ(T x) { 225 return (sizeof(T) == sizeof(uint32_t)) 226 ? __builtin_ctz(x) 227 : __builtin_ctzll(x); 228} 229 230template<typename T> 231static constexpr int POPCOUNT(T x) { 232 return (sizeof(T) == sizeof(uint32_t)) 233 ? __builtin_popcount(x) 234 : __builtin_popcountll(x); 235} 236 237static inline uint32_t PointerToLowMemUInt32(const void* p) { 238 uintptr_t intp = reinterpret_cast<uintptr_t>(p); 239 DCHECK_LE(intp, 0xFFFFFFFFU); 240 return intp & 0xFFFFFFFFU; 241} 242 243static inline bool NeedsEscaping(uint16_t ch) { 244 return (ch < ' ' || ch > '~'); 245} 246 247// Interpret the bit pattern of input (type U) as type V. Requires the size 248// of V >= size of U (compile-time checked). 249template<typename U, typename V> 250static inline V bit_cast(U in) { 251 COMPILE_ASSERT(sizeof(U) <= sizeof(V), size_of_u_not_le_size_of_v); 252 union { 253 U u; 254 V v; 255 } tmp; 256 tmp.u = in; 257 return tmp.v; 258} 259 260std::string PrintableChar(uint16_t ch); 261 262// Returns an ASCII string corresponding to the given UTF-8 string. 263// Java escapes are used for non-ASCII characters. 264std::string PrintableString(const std::string& utf8); 265 266// Tests whether 's' starts with 'prefix'. 267bool StartsWith(const std::string& s, const char* prefix); 268 269// Tests whether 's' starts with 'suffix'. 270bool EndsWith(const std::string& s, const char* suffix); 271 272// Used to implement PrettyClass, PrettyField, PrettyMethod, and PrettyTypeOf, 273// one of which is probably more useful to you. 274// Returns a human-readable equivalent of 'descriptor'. So "I" would be "int", 275// "[[I" would be "int[][]", "[Ljava/lang/String;" would be 276// "java.lang.String[]", and so forth. 277std::string PrettyDescriptor(mirror::String* descriptor) 278 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 279std::string PrettyDescriptor(const std::string& descriptor); 280std::string PrettyDescriptor(Primitive::Type type); 281std::string PrettyDescriptor(mirror::Class* klass) 282 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 283 284// Returns a human-readable signature for 'f'. Something like "a.b.C.f" or 285// "int a.b.C.f" (depending on the value of 'with_type'). 286std::string PrettyField(mirror::ArtField* f, bool with_type = true) 287 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 288std::string PrettyField(uint32_t field_idx, const DexFile& dex_file, bool with_type = true); 289 290// Returns a human-readable signature for 'm'. Something like "a.b.C.m" or 291// "a.b.C.m(II)V" (depending on the value of 'with_signature'). 292std::string PrettyMethod(mirror::ArtMethod* m, bool with_signature = true) 293 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 294std::string PrettyMethod(uint32_t method_idx, const DexFile& dex_file, bool with_signature = true); 295 296// Returns a human-readable form of the name of the *class* of the given object. 297// So given an instance of java.lang.String, the output would 298// be "java.lang.String". Given an array of int, the output would be "int[]". 299// Given String.class, the output would be "java.lang.Class<java.lang.String>". 300std::string PrettyTypeOf(mirror::Object* obj) 301 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 302 303// Returns a human-readable form of the type at an index in the specified dex file. 304// Example outputs: char[], java.lang.String. 305std::string PrettyType(uint32_t type_idx, const DexFile& dex_file); 306 307// Returns a human-readable form of the name of the given class. 308// Given String.class, the output would be "java.lang.Class<java.lang.String>". 309std::string PrettyClass(mirror::Class* c) 310 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 311 312// Returns a human-readable form of the name of the given class with its class loader. 313std::string PrettyClassAndClassLoader(mirror::Class* c) 314 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 315 316// Returns a human-readable size string such as "1MB". 317std::string PrettySize(int64_t size_in_bytes); 318 319// Returns a human-readable time string which prints every nanosecond while trying to limit the 320// number of trailing zeros. Prints using the largest human readable unit up to a second. 321// e.g. "1ms", "1.000000001s", "1.001us" 322std::string PrettyDuration(uint64_t nano_duration, size_t max_fraction_digits = 3); 323 324// Format a nanosecond time to specified units. 325std::string FormatDuration(uint64_t nano_duration, TimeUnit time_unit, 326 size_t max_fraction_digits); 327 328// Get the appropriate unit for a nanosecond duration. 329TimeUnit GetAppropriateTimeUnit(uint64_t nano_duration); 330 331// Get the divisor to convert from a nanoseconds to a time unit. 332uint64_t GetNsToTimeUnitDivisor(TimeUnit time_unit); 333 334// Performs JNI name mangling as described in section 11.3 "Linking Native Methods" 335// of the JNI spec. 336std::string MangleForJni(const std::string& s); 337 338// Turn "java.lang.String" into "Ljava/lang/String;". 339std::string DotToDescriptor(const char* class_name); 340 341// Turn "Ljava/lang/String;" into "java.lang.String". 342std::string DescriptorToDot(const char* descriptor); 343 344// Turn "Ljava/lang/String;" into "java/lang/String". 345std::string DescriptorToName(const char* descriptor); 346 347// Tests for whether 's' is a valid class name in the three common forms: 348bool IsValidBinaryClassName(const char* s); // "java.lang.String" 349bool IsValidJniClassName(const char* s); // "java/lang/String" 350bool IsValidDescriptor(const char* s); // "Ljava/lang/String;" 351 352// Returns whether the given string is a valid field or method name, 353// additionally allowing names that begin with '<' and end with '>'. 354bool IsValidMemberName(const char* s); 355 356// Returns the JNI native function name for the non-overloaded method 'm'. 357std::string JniShortName(mirror::ArtMethod* m) 358 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 359// Returns the JNI native function name for the overloaded method 'm'. 360std::string JniLongName(mirror::ArtMethod* m) 361 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 362 363bool ReadFileToString(const std::string& file_name, std::string* result); 364 365// Returns the current date in ISO yyyy-mm-dd hh:mm:ss format. 366std::string GetIsoDate(); 367 368// Returns the monotonic time since some unspecified starting point in milliseconds. 369uint64_t MilliTime(); 370 371// Returns the monotonic time since some unspecified starting point in microseconds. 372uint64_t MicroTime(); 373 374// Returns the monotonic time since some unspecified starting point in nanoseconds. 375uint64_t NanoTime(); 376 377// Returns the thread-specific CPU-time clock in nanoseconds or -1 if unavailable. 378uint64_t ThreadCpuNanoTime(); 379 380// Converts the given number of nanoseconds to milliseconds. 381static constexpr inline uint64_t NsToMs(uint64_t ns) { 382 return ns / 1000 / 1000; 383} 384 385// Converts the given number of milliseconds to nanoseconds 386static constexpr inline uint64_t MsToNs(uint64_t ns) { 387 return ns * 1000 * 1000; 388} 389 390#if defined(__APPLE__) 391// No clocks to specify on OS/X, fake value to pass to routines that require a clock. 392#define CLOCK_REALTIME 0xebadf00d 393#endif 394 395// Sleep for the given number of nanoseconds, a bad way to handle contention. 396void NanoSleep(uint64_t ns); 397 398// Initialize a timespec to either an absolute or relative time. 399void InitTimeSpec(bool absolute, int clock, int64_t ms, int32_t ns, timespec* ts); 400 401// Splits a string using the given separator character into a vector of 402// strings. Empty strings will be omitted. 403void Split(const std::string& s, char separator, std::vector<std::string>& result); 404 405// Trims whitespace off both ends of the given string. 406std::string Trim(std::string s); 407 408// Joins a vector of strings into a single string, using the given separator. 409template <typename StringT> std::string Join(std::vector<StringT>& strings, char separator); 410 411// Returns the calling thread's tid. (The C libraries don't expose this.) 412pid_t GetTid(); 413 414// Returns the given thread's name. 415std::string GetThreadName(pid_t tid); 416 417// Returns details of the given thread's stack. 418void GetThreadStack(pthread_t thread, void** stack_base, size_t* stack_size); 419 420// Reads data from "/proc/self/task/${tid}/stat". 421void GetTaskStats(pid_t tid, char* state, int* utime, int* stime, int* task_cpu); 422 423// Returns the name of the scheduler group for the given thread the current process, or the empty string. 424std::string GetSchedulerGroupName(pid_t tid); 425 426// Sets the name of the current thread. The name may be truncated to an 427// implementation-defined limit. 428void SetThreadName(const char* thread_name); 429 430// Dumps the native stack for thread 'tid' to 'os'. 431void DumpNativeStack(std::ostream& os, pid_t tid, const char* prefix = "", 432 mirror::ArtMethod* current_method = nullptr) 433 NO_THREAD_SAFETY_ANALYSIS; 434 435// Dumps the kernel stack for thread 'tid' to 'os'. Note that this is only available on linux-x86. 436void DumpKernelStack(std::ostream& os, pid_t tid, const char* prefix = "", bool include_count = true); 437 438// Find $ANDROID_ROOT, /system, or abort. 439const char* GetAndroidRoot(); 440 441// Find $ANDROID_DATA, /data, or abort. 442const char* GetAndroidData(); 443 444// Returns the dalvik-cache location, or dies trying. subdir will be 445// appended to the cache location. 446std::string GetDalvikCacheOrDie(const char* subdir, bool create_if_absent = true); 447 448// Returns the absolute dalvik-cache path for a DexFile or OatFile, or 449// dies trying. The path returned will be rooted at cache_location. 450std::string GetDalvikCacheFilenameOrDie(const char* file_location, 451 const char* cache_location); 452 453// Returns the system location for an image 454std::string GetSystemImageFilename(const char* location, InstructionSet isa); 455 456// Returns an .odex file name next adjacent to the dex location. 457// For example, for "/foo/bar/baz.jar", return "/foo/bar/<isa>/baz.odex". 458// Note: does not support multidex location strings. 459std::string DexFilenameToOdexFilename(const std::string& location, InstructionSet isa); 460 461// Check whether the given magic matches a known file type. 462bool IsZipMagic(uint32_t magic); 463bool IsDexMagic(uint32_t magic); 464bool IsOatMagic(uint32_t magic); 465 466// Wrapper on fork/execv to run a command in a subprocess. 467bool Exec(std::vector<std::string>& arg_vector, std::string* error_msg); 468 469class VoidFunctor { 470 public: 471 template <typename A> 472 inline void operator() (A a) const { 473 UNUSED(a); 474 } 475 476 template <typename A, typename B> 477 inline void operator() (A a, B b) const { 478 UNUSED(a); 479 UNUSED(b); 480 } 481 482 template <typename A, typename B, typename C> 483 inline void operator() (A a, B b, C c) const { 484 UNUSED(a); 485 UNUSED(b); 486 UNUSED(c); 487 } 488}; 489 490} // namespace art 491 492#endif // ART_RUNTIME_UTILS_H_ 493