1 /* 2 * Copyright (C) 2017 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_OAT_AOT_CLASS_LINKER_H_ 18 #define ART_RUNTIME_OAT_AOT_CLASS_LINKER_H_ 19 20 #include <forward_list> 21 22 #include "base/macros.h" 23 #include "sdk_checker.h" 24 #include "class_linker.h" 25 26 namespace art HIDDEN { 27 28 class Transaction; 29 30 namespace gc { 31 class Heap; 32 } // namespace gc 33 34 // TODO: move to dex2oat/. 35 // AotClassLinker is only used for AOT compiler, which includes some logic for class initialization 36 // which will only be used in pre-compilation. 37 class AotClassLinker : public ClassLinker { 38 public: 39 explicit AotClassLinker(InternTable *intern_table); 40 ~AotClassLinker(); 41 42 EXPORT static void SetAppImageDexFiles(const std::vector<const DexFile*>* app_image_dex_files); 43 44 EXPORT static bool CanReferenceInBootImageExtensionOrAppImage( 45 ObjPtr<mirror::Class> klass, gc::Heap* heap) REQUIRES_SHARED(Locks::mutator_lock_); 46 47 EXPORT void SetSdkChecker(std::unique_ptr<SdkChecker>&& sdk_checker_); 48 const SdkChecker* GetSdkChecker() const; 49 50 // Verifies if the method is accessible according to the SdkChecker (if installed). 51 bool DenyAccessBasedOnPublicSdk(ArtMethod* art_method) const override 52 REQUIRES_SHARED(Locks::mutator_lock_); 53 // Verifies if the field is accessible according to the SdkChecker (if installed). 54 bool DenyAccessBasedOnPublicSdk(ArtField* art_field) const override 55 REQUIRES_SHARED(Locks::mutator_lock_); 56 // Verifies if the descriptor is accessible according to the SdkChecker (if installed). 57 bool DenyAccessBasedOnPublicSdk(std::string_view type_descriptor) const override; 58 // Enable or disable public sdk checks. 59 void SetEnablePublicSdkChecks(bool enabled) override; 60 61 // Transaction support. 62 EXPORT bool IsActiveTransaction() const; 63 // EnterTransactionMode may suspend. 64 EXPORT void EnterTransactionMode(bool strict, mirror::Class* root) 65 REQUIRES_SHARED(Locks::mutator_lock_); 66 EXPORT void ExitTransactionMode(); 67 EXPORT void RollbackAllTransactions() REQUIRES_SHARED(Locks::mutator_lock_); 68 // Transaction rollback and exit transaction are always done together, it's convenience to 69 // do them in one function. 70 void RollbackAndExitTransactionMode() REQUIRES_SHARED(Locks::mutator_lock_); 71 const Transaction* GetTransaction() const; 72 Transaction* GetTransaction(); 73 bool IsActiveStrictTransactionMode() const; 74 75 // Transaction constraint checks for AOT compilation. 76 bool TransactionWriteConstraint(Thread* self, ObjPtr<mirror::Object> obj) override 77 REQUIRES_SHARED(Locks::mutator_lock_); 78 bool TransactionWriteValueConstraint(Thread* self, ObjPtr<mirror::Object> value) override 79 REQUIRES_SHARED(Locks::mutator_lock_); 80 // Note: The read constraint check is non-virtual because it's not needed by `UnstartedRuntime`. 81 bool TransactionReadConstraint(Thread* self, ObjPtr<mirror::Object> obj) 82 REQUIRES_SHARED(Locks::mutator_lock_); 83 bool TransactionAllocationConstraint(Thread* self, ObjPtr<mirror::Class> klass) override 84 REQUIRES_SHARED(Locks::mutator_lock_); 85 86 // Transaction bookkeeping for AOT compilation. 87 void RecordWriteFieldBoolean(mirror::Object* obj, 88 MemberOffset field_offset, 89 uint8_t value, 90 bool is_volatile) override; 91 void RecordWriteFieldByte(mirror::Object* obj, 92 MemberOffset field_offset, 93 int8_t value, 94 bool is_volatile) override; 95 void RecordWriteFieldChar(mirror::Object* obj, 96 MemberOffset field_offset, 97 uint16_t value, 98 bool is_volatile) override; 99 void RecordWriteFieldShort(mirror::Object* obj, 100 MemberOffset field_offset, 101 int16_t value, 102 bool is_volatile) override; 103 void RecordWriteField32(mirror::Object* obj, 104 MemberOffset field_offset, 105 uint32_t value, 106 bool is_volatile) override; 107 void RecordWriteField64(mirror::Object* obj, 108 MemberOffset field_offset, 109 uint64_t value, 110 bool is_volatile) override; 111 void RecordWriteFieldReference(mirror::Object* obj, 112 MemberOffset field_offset, 113 ObjPtr<mirror::Object> value, 114 bool is_volatile) override 115 REQUIRES_SHARED(Locks::mutator_lock_); 116 void RecordWriteArray(mirror::Array* array, size_t index, uint64_t value) override 117 REQUIRES_SHARED(Locks::mutator_lock_); 118 void RecordStrongStringInsertion(ObjPtr<mirror::String> s) override 119 REQUIRES(Locks::intern_table_lock_); 120 void RecordWeakStringInsertion(ObjPtr<mirror::String> s) override 121 REQUIRES(Locks::intern_table_lock_); 122 void RecordStrongStringRemoval(ObjPtr<mirror::String> s) override 123 REQUIRES(Locks::intern_table_lock_); 124 void RecordWeakStringRemoval(ObjPtr<mirror::String> s) override 125 REQUIRES(Locks::intern_table_lock_); 126 void RecordResolveString(ObjPtr<mirror::DexCache> dex_cache, dex::StringIndex string_idx) override 127 REQUIRES_SHARED(Locks::mutator_lock_); 128 void RecordResolveMethodType(ObjPtr<mirror::DexCache> dex_cache, dex::ProtoIndex proto_idx) 129 override REQUIRES_SHARED(Locks::mutator_lock_); 130 131 // Aborting transactions for AOT compilation. 132 void ThrowTransactionAbortError(Thread* self) override 133 REQUIRES_SHARED(Locks::mutator_lock_); 134 void AbortTransactionF(Thread* self, const char* fmt, ...) override 135 __attribute__((__format__(__printf__, 3, 4))) 136 REQUIRES_SHARED(Locks::mutator_lock_); 137 void AbortTransactionV(Thread* self, const char* fmt, va_list args) override 138 REQUIRES_SHARED(Locks::mutator_lock_); 139 bool IsTransactionAborted() const override; 140 141 void VisitTransactionRoots(RootVisitor* visitor) override 142 REQUIRES_SHARED(Locks::mutator_lock_); 143 144 protected: 145 // Overridden version of PerformClassVerification allows skipping verification if the class was 146 // previously verified but unloaded. 147 verifier::FailureKind PerformClassVerification(Thread* self, 148 verifier::VerifierDeps* verifier_deps, 149 Handle<mirror::Class> klass, 150 verifier::HardFailLogMode log_level, 151 std::string* error_msg) 152 override 153 REQUIRES_SHARED(Locks::mutator_lock_); 154 155 // Override AllocClass because aot compiler will need to perform a transaction check to determine 156 // can we allocate class from heap. 157 bool CanAllocClass() 158 override 159 REQUIRES_SHARED(Locks::mutator_lock_) 160 REQUIRES(!Roles::uninterruptible_); 161 162 bool InitializeClass(Thread *self, 163 Handle<mirror::Class> klass, 164 bool can_run_clinit, 165 bool can_init_parents) 166 override 167 REQUIRES_SHARED(Locks::mutator_lock_) 168 REQUIRES(!Locks::dex_lock_); 169 170 private: 171 std::unique_ptr<SdkChecker> sdk_checker_; 172 173 // Transactions used for pre-initializing classes at compilation time. 174 // Support nested transactions, maintain a list containing all transactions. Transactions are 175 // handled under a stack discipline. Because GC needs to go over all transactions, we choose list 176 // as substantial data structure instead of stack. 177 std::forward_list<Transaction> preinitialization_transactions_; 178 }; 179 180 } // namespace art 181 182 #endif // ART_RUNTIME_OAT_AOT_CLASS_LINKER_H_ 183