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