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 
     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