Home | History | Annotate | Download | only in runtime 
      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 bool Exec(std::vector<std::string>& arg_vector, std::string* error_msg);
    295 int ExecAndReturnCode(std::vector<std::string>& arg_vector, std::string* error_msg);
    296 
    297 // Returns true if the file exists.
    298 bool FileExists(const std::string& filename);
    299 bool FileExistsAndNotEmpty(const std::string& filename);
    300 
    301 class 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 
    316 template <typename Vector>
    317 void 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 
    325 inline bool TestBitmap(size_t idx, const uint8_t* bitmap) {
    326   return ((bitmap[idx / kBitsPerByte] >> (idx % kBitsPerByte)) & 0x01) != 0;
    327 }
    328 
    329 static inline constexpr bool ValidPointerSize(size_t pointer_size) {
    330   return pointer_size == 4 || pointer_size == 8;
    331 }
    332 
    333 void DumpMethodCFG(ArtMethod* method, std::ostream& os) SHARED_REQUIRES(Locks::mutator_lock_);
    334 void DumpMethodCFG(const DexFile* dex_file, uint32_t dex_method_idx, std::ostream& os);
    335 
    336 static 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 
    344 using UsageFn = void (*)(const char*, ...);
    345 
    346 template <typename T>
    347 static 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 
    365 void 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__)
    373 struct 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 };
    379 using RNG = Arc4RandomGenerator;
    380 #else
    381 using RNG = std::random_device;
    382 #endif
    383 
    384 template <typename T>
    385 T 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.
    393 int64_t GetFileSizeBytes(const std::string& filename);
    394 
    395 // Sleep forever and never come back.
    396 NO_RETURN void SleepForever();
    397 
    398 inline 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