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 38 class BacktraceMap; 39 40 namespace art { 41 42 class ArtField; 43 class ArtMethod; 44 class DexFile; 45 46 namespace mirror { 47 class Class; 48 class Object; 49 class String; 50 } // namespace mirror 51 52 template <typename T> 53 bool 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 66 template <typename T> 67 bool 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. 81 static 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. 87 static 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 92 static 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 98 static inline bool NeedsEscaping(uint16_t ch) { 99 return (ch < ' ' || ch > '~'); 100 } 101 102 template <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 108 template <typename T> T AbsOrMin(T value) { 109 return (value == std::numeric_limits<T>::min()) 110 ? value 111 : std::abs(value); 112 } 113 114 template <typename T> 115 inline typename std::make_unsigned<T>::type MakeUnsigned(T x) { 116 return static_cast<typename std::make_unsigned<T>::type>(x); 117 } 118 119 std::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. 123 std::string PrintableString(const char* utf8); 124 125 // Tests whether 's' starts with 'prefix'. 126 bool StartsWith(const std::string& s, const char* prefix); 127 128 // Tests whether 's' ends with 'suffix'. 129 bool 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. 136 std::string PrettyDescriptor(mirror::String* descriptor) 137 SHARED_REQUIRES(Locks::mutator_lock_); 138 std::string PrettyDescriptor(const char* descriptor); 139 std::string PrettyDescriptor(mirror::Class* klass) 140 SHARED_REQUIRES(Locks::mutator_lock_); 141 std::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'). 145 std::string PrettyField(ArtField* f, bool with_type = true) 146 SHARED_REQUIRES(Locks::mutator_lock_); 147 std::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'). 151 std::string PrettyMethod(ArtMethod* m, bool with_signature = true) 152 SHARED_REQUIRES(Locks::mutator_lock_); 153 std::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>". 159 std::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. 164 std::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>". 168 std::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. 172 std::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). 177 std::string PrettyJavaAccessFlags(uint32_t access_flags); 178 179 // Returns a human-readable size string such as "1MB". 180 std::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. 184 std::string MangleForJni(const std::string& s); 185 186 // Turn "java.lang.String" into "Ljava/lang/String;". 187 std::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(). 191 std::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(). 195 std::string DescriptorToName(const char* descriptor); 196 197 // Tests for whether 's' is a valid class name in the three common forms: 198 bool IsValidBinaryClassName(const char* s); // "java.lang.String" 199 bool IsValidJniClassName(const char* s); // "java/lang/String" 200 bool 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 '>'. 204 bool IsValidMemberName(const char* s); 205 206 // Returns the JNI native function name for the non-overloaded method 'm'. 207 std::string JniShortName(ArtMethod* m) 208 SHARED_REQUIRES(Locks::mutator_lock_); 209 // Returns the JNI native function name for the overloaded method 'm'. 210 std::string JniLongName(ArtMethod* m) 211 SHARED_REQUIRES(Locks::mutator_lock_); 212 213 bool ReadFileToString(const std::string& file_name, std::string* result); 214 bool 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. 218 void Split(const std::string& s, char separator, std::vector<std::string>* result); 219 220 // Trims whitespace off both ends of the given string. 221 std::string Trim(const std::string& s); 222 223 // Joins a vector of strings into a single string, using the given separator. 224 template <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.) 227 pid_t GetTid(); 228 229 // Returns the given thread's name. 230 std::string GetThreadName(pid_t tid); 231 232 // Returns details of the given thread's stack. 233 void 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". 236 void 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. 239 std::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. 243 void SetThreadName(const char* thread_name); 244 245 // Dumps the native stack for thread 'tid' to 'os'. 246 void 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. 255 void 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. 261 const char* GetAndroidRoot(); 262 263 // Find $ANDROID_DATA, /data, or abort. 264 const char* GetAndroidData(); 265 // Find $ANDROID_DATA, /data, or return null. 266 const 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). 270 std::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. 273 std::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. 278 void 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. 283 bool 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. 287 std::string GetDalvikCacheFilenameOrDie(const char* file_location, 288 const char* cache_location); 289 290 // Returns the system location for an image 291 std::string GetSystemImageFilename(const char* location, InstructionSet isa); 292 293 // Wrapper on fork/execv to run a command in a subprocess. 294 // Both of these spawn child processes using the environment as it was set when the single instance 295 // of the runtime (Runtime::Current()) was started. If no instance of the runtime was started, it 296 // will use the current environment settings. 297 bool Exec(std::vector<std::string>& arg_vector, std::string* error_msg); 298 int ExecAndReturnCode(std::vector<std::string>& arg_vector, std::string* error_msg); 299 300 // Returns true if the file exists. 301 bool FileExists(const std::string& filename); 302 bool FileExistsAndNotEmpty(const std::string& filename); 303 304 class VoidFunctor { 305 public: 306 template <typename A> 307 inline void operator() (A a ATTRIBUTE_UNUSED) const { 308 } 309 310 template <typename A, typename B> 311 inline void operator() (A a ATTRIBUTE_UNUSED, B b ATTRIBUTE_UNUSED) const { 312 } 313 314 template <typename A, typename B, typename C> 315 inline void operator() (A a ATTRIBUTE_UNUSED, B b ATTRIBUTE_UNUSED, C c ATTRIBUTE_UNUSED) const { 316 } 317 }; 318 319 template <typename Vector> 320 void Push32(Vector* buf, int32_t data) { 321 static_assert(std::is_same<typename Vector::value_type, uint8_t>::value, "Invalid value type"); 322 buf->push_back(data & 0xff); 323 buf->push_back((data >> 8) & 0xff); 324 buf->push_back((data >> 16) & 0xff); 325 buf->push_back((data >> 24) & 0xff); 326 } 327 328 inline bool TestBitmap(size_t idx, const uint8_t* bitmap) { 329 return ((bitmap[idx / kBitsPerByte] >> (idx % kBitsPerByte)) & 0x01) != 0; 330 } 331 332 static inline constexpr bool ValidPointerSize(size_t pointer_size) { 333 return pointer_size == 4 || pointer_size == 8; 334 } 335 336 void DumpMethodCFG(ArtMethod* method, std::ostream& os) SHARED_REQUIRES(Locks::mutator_lock_); 337 void DumpMethodCFG(const DexFile* dex_file, uint32_t dex_method_idx, std::ostream& os); 338 339 static inline const void* EntryPointToCodePointer(const void* entry_point) { 340 uintptr_t code = reinterpret_cast<uintptr_t>(entry_point); 341 // TODO: Make this Thumb2 specific. It is benign on other architectures as code is always at 342 // least 2 byte aligned. 343 code &= ~0x1; 344 return reinterpret_cast<const void*>(code); 345 } 346 347 using UsageFn = void (*)(const char*, ...); 348 349 template <typename T> 350 static void ParseUintOption(const StringPiece& option, 351 const std::string& option_name, 352 T* out, 353 UsageFn Usage, 354 bool is_long_option = true) { 355 std::string option_prefix = option_name + (is_long_option ? "=" : ""); 356 DCHECK(option.starts_with(option_prefix)) << option << " " << option_prefix; 357 const char* value_string = option.substr(option_prefix.size()).data(); 358 int64_t parsed_integer_value = 0; 359 if (!ParseInt(value_string, &parsed_integer_value)) { 360 Usage("Failed to parse %s '%s' as an integer", option_name.c_str(), value_string); 361 } 362 if (parsed_integer_value < 0) { 363 Usage("%s passed a negative value %d", option_name.c_str(), parsed_integer_value); 364 } 365 *out = dchecked_integral_cast<T>(parsed_integer_value); 366 } 367 368 void ParseDouble(const std::string& option, 369 char after_char, 370 double min, 371 double max, 372 double* parsed_value, 373 UsageFn Usage); 374 375 #if defined(__BIONIC__) 376 struct Arc4RandomGenerator { 377 typedef uint32_t result_type; 378 static constexpr uint32_t min() { return std::numeric_limits<uint32_t>::min(); } 379 static constexpr uint32_t max() { return std::numeric_limits<uint32_t>::max(); } 380 uint32_t operator() () { return arc4random(); } 381 }; 382 using RNG = Arc4RandomGenerator; 383 #else 384 using RNG = std::random_device; 385 #endif 386 387 template <typename T> 388 T GetRandomNumber(T min, T max) { 389 CHECK_LT(min, max); 390 std::uniform_int_distribution<T> dist(min, max); 391 RNG rng; 392 return dist(rng); 393 } 394 395 // Return the file size in bytes or -1 if the file does not exists. 396 int64_t GetFileSizeBytes(const std::string& filename); 397 398 // Sleep forever and never come back. 399 NO_RETURN void SleepForever(); 400 401 inline void FlushInstructionCache(char* begin, char* end) { 402 // Only use __builtin___clear_cache with Clang or with GCC >= 4.3.0 403 // (__builtin___clear_cache was introduced in GCC 4.3.0). 404 #if defined(__clang__) || GCC_VERSION >= 40300 405 __builtin___clear_cache(begin, end); 406 #else 407 // Only warn on non-Intel platforms, as x86 and x86-64 do not need 408 // cache flush instructions, as long as the "code uses the same 409 // linear address for modifying and fetching the instruction". See 410 // "Intel(R) 64 and IA-32 Architectures Software Developer's Manual 411 // Volume 3A: System Programming Guide, Part 1", section 11.6 412 // "Self-Modifying Code". 413 #if !defined(__i386__) && !defined(__x86_64__) 414 UNIMPLEMENTED(WARNING) << "cache flush"; 415 #endif 416 #endif 417 } 418 419 } // namespace art 420 421 #endif // ART_RUNTIME_UTILS_H_ 422
