/art/runtime/ |
H A D | method_info.h | 35 explicit MethodInfo(const uint8_t* ptr) { argument 36 if (ptr != nullptr) { 37 num_method_indices_ = DecodeUnsignedLeb128(&ptr); 38 region_ = MemoryRegion(const_cast<uint8_t*>(ptr), 44 MethodInfo(uint8_t* ptr, size_t num_method_indices) : num_method_indices_(num_method_indices) { argument 45 DCHECK(ptr != nullptr); 46 ptr = EncodeUnsignedLeb128(ptr, num_method_indices_); 47 region_ = MemoryRegion(ptr, num_method_indices_ * sizeof(MethodIndexType)); 52 uint8_t* ptr local [all...] |
H A D | linear_alloc.cc | 26 void* LinearAlloc::Realloc(Thread* self, void* ptr, size_t old_size, size_t new_size) { argument 28 return allocator_.Realloc(ptr, old_size, new_size); 51 bool LinearAlloc::Contains(void* ptr) const { 53 return allocator_.Contains(ptr); 56 bool LinearAlloc::ContainsUnsafe(void* ptr) const { 57 return allocator_.Contains(ptr);
|
H A D | obj_ptr.h | 60 ALWAYS_INLINE ObjPtr(Type* ptr) 62 : reference_(Encode(static_cast<MirrorType*>(ptr))) { 84 ALWAYS_INLINE ObjPtr& operator=(MirrorType* ptr) REQUIRES_SHARED(Locks::mutator_lock_) { 85 Assign(ptr); 89 ALWAYS_INLINE void Assign(MirrorType* ptr) REQUIRES_SHARED(Locks::mutator_lock_) { 90 reference_ = Encode(ptr); 111 ALWAYS_INLINE bool operator==(const ObjPtr& ptr) const REQUIRES_SHARED(Locks::mutator_lock_) { 112 return Ptr() == ptr.Ptr(); 116 ALWAYS_INLINE bool operator==(const PointerType* ptr) const 118 return Ptr() == ptr; 209 MakeObjPtr(MirrorType* ptr) argument 214 MakeObjPtr(ObjPtr<MirrorType> ptr) argument [all...] |
H A D | linear_alloc.h | 35 void* Realloc(Thread* self, void* ptr, size_t old_size, size_t new_size) REQUIRES(!lock_); 49 bool Contains(void* ptr) const REQUIRES(!lock_); 53 bool ContainsUnsafe(void* ptr) const NO_THREAD_SAFETY_ANALYSIS;
|
H A D | imtable.h | 46 uint8_t* ptr = AddressOfElement(index, pointer_size); local 48 uint32_t value = *reinterpret_cast<uint32_t*>(ptr); 51 uint64_t value = *reinterpret_cast<uint64_t*>(ptr); 58 uint8_t* ptr = AddressOfElement(index, pointer_size); local 62 *reinterpret_cast<uint32_t*>(ptr) = static_cast<uint32_t>(value); 64 *reinterpret_cast<uint64_t*>(ptr) = reinterpret_cast<uint64_t>(method);
|
H A D | obj_ptr-inl.h | 43 inline uintptr_t ObjPtr<MirrorType>::Encode(MirrorType* ptr) { argument 44 uintptr_t ref = reinterpret_cast<uintptr_t>(ptr); 58 inline std::ostream& operator<<(std::ostream& os, ObjPtr<MirrorType> ptr) { argument 60 return os << ptr.PtrUnchecked();
|
H A D | oat.cc | 425 const char* ptr = reinterpret_cast<const char*>(&key_value_store_); local 426 const char* end = ptr + key_value_store_size_; 428 while (ptr < end) { 430 const char* str_end = ParseString(ptr, end); 432 if (strcmp(key, ptr) == 0) { 439 ptr = ParseString(str_end + 1, end) + 1; 451 const char* ptr = reinterpret_cast<const char*>(&key_value_store_); local 452 const char* end = ptr + key_value_store_size_; 455 while (ptr < end && counter >= 0) { 457 const char* str_end = ParseString(ptr, en [all...] |
H A D | type_lookup_table.h | 130 const uint8_t* ptr = dex_data_begin_ + str_offset; local 133 DecodeUnsignedLeb128(&ptr); 135 str, reinterpret_cast<const char*>(ptr)) == 0;
|
H A D | mem_map.cc | 149 bool MemMap::ContainedWithinExistingMap(uint8_t* ptr, size_t size, std::string* error_msg) { argument 150 uintptr_t begin = reinterpret_cast<uintptr_t>(ptr); 274 static inline void* TryMemMapLow4GB(void* ptr, argument 280 void* actual = mmap(ptr, page_aligned_byte_count, prot, flags, fd, offset); 913 for (uintptr_t ptr = next_mem_pos_; ptr < 4 * GB; ptr += kPageSize) { 915 // Find the first map which is address > ptr. 916 auto it = gMaps->upper_bound(reinterpret_cast<void*>(ptr)); 921 ptr [all...] |
/art/libartbase/base/ |
H A D | leb128.h | 34 const uint8_t* ptr = *data; local 35 int result = *(ptr++); 37 int cur = *(ptr++); 40 cur = *(ptr++); 43 cur = *(ptr++); 48 cur = *(ptr++); 54 *data = ptr; 65 const uint8_t* ptr = *data; local 66 if (ptr >= end) { 69 int result = *(ptr 117 const uint8_t* ptr = *data; local 152 const uint8_t* ptr = *data; local 210 IsLeb128Terminator(const uint8_t* ptr) argument 221 T* ptr = end_ptr; local [all...] |
H A D | scoped_flock.h | 78 void operator()(LockedFile* ptr) { argument 79 ptr->ReleaseLock(); 80 UNUSED(ptr->Close()); 82 delete ptr;
|
H A D | hash_set.h | 215 HashSet(const uint8_t* ptr, bool make_copy_of_data, size_t* read_count) noexcept { 218 offset = ReadFromBytes(ptr, offset, &temp); 220 offset = ReadFromBytes(ptr, offset, &temp); 223 offset = ReadFromBytes(ptr, offset, &temp); 225 offset = ReadFromBytes(ptr, offset, &min_load_factor_); 226 offset = ReadFromBytes(ptr, offset, &max_load_factor_); 229 data_ = const_cast<T*>(reinterpret_cast<const T*>(ptr + offset)); 236 offset = ReadFromBytes(ptr, offset, &data_[i]); 245 size_t WriteToMemory(uint8_t* ptr) const { 247 offset = WriteToBytes(ptr, offse 654 WriteToBytes(uint8_t* ptr, size_t offset, Elem n) argument 663 ReadFromBytes(const uint8_t* ptr, size_t offset, Elem* out) argument [all...] |
/art/compiler/jit/ |
H A D | jit_logger.h | 97 void WriteLog(const void* ptr, size_t code_size, ArtMethod* method) 99 WritePerfMapLog(ptr, code_size, method); 100 WriteJitDumpLog(ptr, code_size, method); 111 void WritePerfMapLog(const void* ptr, size_t code_size, ArtMethod* method) 117 void WriteJitDumpLog(const void* ptr, size_t code_size, ArtMethod* method)
|
/art/test/ti-agent/ |
H A D | scoped_local_ref.h | 38 void reset(T ptr = nullptr) { 39 if (ptr != mLocalRef) { 43 mLocalRef = ptr;
|
H A D | jvmti_helper.h | 57 void operator()(unsigned char* ptr) const { 59 jvmtiError ret = env_->Deallocate(ptr);
|
/art/runtime/mirror/ |
H A D | object_reference-inl.h | 28 void ObjectReference<kPoisonReferences, MirrorType>::Assign(ObjPtr<MirrorType> ptr) { argument 29 Assign(ptr.Ptr());
|
/art/runtime/base/ |
H A D | scoped_arena_allocator.h | 65 static ArenaFreeTag& ArenaTagForAllocation(void* ptr) { argument 67 return *(reinterpret_cast<ArenaFreeTag*>(ptr) - 1); 101 uint8_t* ptr = top_ptr_; variable 102 if (UNLIKELY(static_cast<size_t>(top_end_ - ptr) < rounded_bytes)) { 103 ptr = AllocateFromNextArena(rounded_bytes); 106 top_ptr_ = ptr + rounded_bytes; 108 ptr += kAlignment; 109 ArenaTagForAllocation(ptr) = ArenaFreeTag::kUsed; variable 111 return ptr; 170 static void operator delete(void* ptr ATTRIBUTE_UNUSE [all...] |
H A D | scoped_arena_allocator.cc | 97 uint8_t* ptr = top_ptr_; local 98 if (UNLIKELY(static_cast<size_t>(top_end_ - ptr) < rounded_bytes)) { 99 ptr = AllocateFromNextArena(rounded_bytes); 100 CHECK(ptr != nullptr) << "Failed to allocate memory"; 101 MEMORY_TOOL_MAKE_NOACCESS(ptr, top_end_ - ptr); 104 top_ptr_ = ptr + rounded_bytes; 105 MEMORY_TOOL_MAKE_UNDEFINED(ptr, bytes); 106 return ptr;
|
H A D | arena_allocator.h | 178 void MakeDefined(void* ptr, size_t size) { argument 180 DoMakeDefined(ptr, size); 183 void MakeUndefined(void* ptr, size_t size) { argument 185 DoMakeUndefined(ptr, size); 188 void MakeInaccessible(void* ptr, size_t size) { argument 190 DoMakeInaccessible(ptr, size); 195 void DoMakeDefined(void* ptr, size_t size); 196 void DoMakeUndefined(void* ptr, size_t size); 197 void DoMakeInaccessible(void* ptr, size_t size); 228 // Return true if ptr i [all...] |
H A D | arena_object.h | 47 ALWAYS_INLINE void* operator new(size_t, void* ptr) noexcept { return ptr; }
|
H A D | scoped_arena_containers.h | 230 ALWAYS_INLINE void ProtectMemory(T* ptr, size_t size) const { argument 234 memset(ptr, kMagicFill, size); 235 MEMORY_TOOL_MAKE_NOACCESS(ptr, size); 237 CHECK(ArenaStack::ArenaTagForAllocation(reinterpret_cast<void*>(ptr)) == ArenaFreeTag::kUsed) 238 << "Freeing invalid object " << ptr; 239 ArenaStack::ArenaTagForAllocation(reinterpret_cast<void*>(ptr)) = ArenaFreeTag::kFree; 241 memset(ptr, kMagicFill, size); 246 void operator()(T* ptr) const { 247 if (ptr != nullptr) { 248 ptr [all...] |
/art/compiler/utils/ |
H A D | swap_space.cc | 75 if (munmap(chunk.ptr, chunk.size) != 0) { 77 << static_cast<const void*>(chunk.ptr) << " size=" << chunk.size; 126 // The free_by_start_ map contains disjoint intervals ordered by the `ptr`. 128 it->free_by_start_entry->ptr += size; 131 // The free_by_size_ map is ordered by the `size` and then `free_by_start_entry->ptr`. 132 // Adjusting the `ptr` above does not change that ordering but decreasing `size` can 149 return old_chunk.ptr; 155 SpaceChunk remainder = { new_chunk.ptr + size, new_chunk.size - size }; 158 return new_chunk.ptr; 169 uint8_t* ptr local 190 Free(void* ptr, size_t size) argument [all...] |
/art/runtime/arch/arm/ |
H A D | fault_handler_arm.cc | 76 uint8_t* ptr = reinterpret_cast<uint8_t*>(sc->arm_pc); local 77 VLOG(signals) << "pc: " << std::hex << static_cast<void*>(ptr); 79 if (ptr == nullptr) { 85 uint32_t instr_size = GetInstructionSize(ptr); 103 uint8_t* ptr = reinterpret_cast<uint8_t*>(sc->arm_pc); local 104 uint32_t instr_size = GetInstructionSize(ptr);
|
/art/libdexfile/dex/ |
H A D | utf_test.cc | 61 const char* ptr = start; local 65 pair = GetUtf16FromUtf8(&ptr); 68 EXPECT_ARRAY_POSITION(1, ptr, start); 71 pair = GetUtf16FromUtf8(&ptr); 74 EXPECT_ARRAY_POSITION(3, ptr, start); 77 pair = GetUtf16FromUtf8(&ptr); 80 EXPECT_ARRAY_POSITION(6, ptr, start); 83 pair = GetUtf16FromUtf8(&ptr); 86 EXPECT_ARRAY_POSITION(10, ptr, start); 89 pair = GetUtf16FromUtf8(&ptr); 97 const char* ptr = start; local [all...] |
/art/runtime/gc/space/ |
H A D | memory_tool_malloc_space.h | 45 size_t Free(Thread* self, mirror::Object* ptr) OVERRIDE 51 void RegisterRecentFree(mirror::Object* ptr ATTRIBUTE_UNUSED) OVERRIDE {}
|