1 /* 2 * Copyright (C) 2016 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_IMTABLE_H_ 18 #define ART_RUNTIME_IMTABLE_H_ 19 20 #ifndef IMT_SIZE 21 #error IMT_SIZE not defined 22 #endif 23 24 #include "base/enums.h" 25 #include "base/macros.h" 26 #include "base/mutex.h" 27 28 namespace art { 29 30 class ArtMethod; 31 class DexFile; 32 33 class ImTable { 34 public: 35 // Interface method table size. Increasing this value reduces the chance of two interface methods 36 // colliding in the interface method table but increases the size of classes that implement 37 // (non-marker) interfaces. 38 static constexpr size_t kSize = IMT_SIZE; 39 AddressOfElement(size_t index,PointerSize pointer_size)40 uint8_t* AddressOfElement(size_t index, PointerSize pointer_size) { 41 return reinterpret_cast<uint8_t*>(this) + OffsetOfElement(index, pointer_size); 42 } 43 Get(size_t index,PointerSize pointer_size)44 ArtMethod* Get(size_t index, PointerSize pointer_size) { 45 DCHECK_LT(index, kSize); 46 uint8_t* ptr = AddressOfElement(index, pointer_size); 47 if (pointer_size == PointerSize::k32) { 48 uint32_t value = *reinterpret_cast<uint32_t*>(ptr); 49 return reinterpret_cast<ArtMethod*>(value); 50 } else { 51 uint64_t value = *reinterpret_cast<uint64_t*>(ptr); 52 return reinterpret_cast<ArtMethod*>(value); 53 } 54 } 55 Set(size_t index,ArtMethod * method,PointerSize pointer_size)56 void Set(size_t index, ArtMethod* method, PointerSize pointer_size) { 57 DCHECK_LT(index, kSize); 58 uint8_t* ptr = AddressOfElement(index, pointer_size); 59 if (pointer_size == PointerSize::k32) { 60 uintptr_t value = reinterpret_cast<uintptr_t>(method); 61 DCHECK_EQ(static_cast<uint32_t>(value), value); // Check that we dont lose any non 0 bits. 62 *reinterpret_cast<uint32_t*>(ptr) = static_cast<uint32_t>(value); 63 } else { 64 *reinterpret_cast<uint64_t*>(ptr) = reinterpret_cast<uint64_t>(method); 65 } 66 } 67 OffsetOfElement(size_t index,PointerSize pointer_size)68 static size_t OffsetOfElement(size_t index, PointerSize pointer_size) { 69 return index * static_cast<size_t>(pointer_size); 70 } 71 Populate(ArtMethod ** data,PointerSize pointer_size)72 void Populate(ArtMethod** data, PointerSize pointer_size) { 73 for (size_t i = 0; i < kSize; ++i) { 74 Set(i, data[i], pointer_size); 75 } 76 } 77 SizeInBytes(PointerSize pointer_size)78 constexpr static size_t SizeInBytes(PointerSize pointer_size) { 79 return kSize * static_cast<size_t>(pointer_size); 80 } 81 82 // Converts a method to the base hash components used in GetImtIndex. 83 ALWAYS_INLINE static inline void GetImtHashComponents(ArtMethod* method, 84 uint32_t* class_hash, 85 uint32_t* name_hash, 86 uint32_t* signature_hash) 87 REQUIRES_SHARED(Locks::mutator_lock_); 88 89 // The (complete) hashing scheme to map an ArtMethod to a slot in the Interface Method Table 90 // (IMT). 91 ALWAYS_INLINE static inline uint32_t GetImtIndex(ArtMethod* method) 92 REQUIRES_SHARED(Locks::mutator_lock_); 93 }; 94 95 } // namespace art 96 97 #endif // ART_RUNTIME_IMTABLE_H_ 98 99