1 /* 2 * Copyright (C) 2013 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_NOOP_COMPILER_CALLBACKS_H_ 18 #define ART_RUNTIME_NOOP_COMPILER_CALLBACKS_H_ 19 20 #include "base/macros.h" 21 #include "class_linker.h" 22 #include "compiler_callbacks.h" 23 24 namespace art HIDDEN { 25 26 // Used for tests and some tools that pretend to be a compiler (say, oatdump). 27 class NoopCompilerCallbacks final : public CompilerCallbacks { 28 public: NoopCompilerCallbacks()29 NoopCompilerCallbacks() : CompilerCallbacks(CompilerCallbacks::CallbackMode::kCompileApp) {} ~NoopCompilerCallbacks()30 ~NoopCompilerCallbacks() {} 31 CreateAotClassLinker(InternTable * intern_table)32 ClassLinker* CreateAotClassLinker(InternTable* intern_table) override { 33 return new PermissiveClassLinker(intern_table); 34 } 35 AddUncompilableMethod(MethodReference ref)36 void AddUncompilableMethod([[maybe_unused]] MethodReference ref) override {} AddUncompilableClass(ClassReference ref)37 void AddUncompilableClass([[maybe_unused]] ClassReference ref) override {} ClassRejected(ClassReference ref)38 void ClassRejected([[maybe_unused]] ClassReference ref) override {} 39 GetVerifierDeps()40 verifier::VerifierDeps* GetVerifierDeps() const override { return nullptr; } 41 42 private: 43 // When we supply compiler callbacks, we need an appropriate `ClassLinker` that can 44 // handle `SdkChecker`-related calls that are unimplemented in the base `ClassLinker`. 45 class PermissiveClassLinker : public ClassLinker { 46 public: PermissiveClassLinker(InternTable * intern_table)47 explicit PermissiveClassLinker(InternTable* intern_table) 48 : ClassLinker(intern_table, /*fast_class_not_found_exceptions=*/ false) {} 49 DenyAccessBasedOnPublicSdk(ArtMethod * art_method)50 bool DenyAccessBasedOnPublicSdk([[maybe_unused]] ArtMethod* art_method) const override 51 REQUIRES_SHARED(Locks::mutator_lock_) { 52 return false; 53 } DenyAccessBasedOnPublicSdk(ArtField * art_field)54 bool DenyAccessBasedOnPublicSdk([[maybe_unused]] ArtField* art_field) const override 55 REQUIRES_SHARED(Locks::mutator_lock_) { 56 return false; 57 } DenyAccessBasedOnPublicSdk(std::string_view type_descriptor)58 bool DenyAccessBasedOnPublicSdk( 59 [[maybe_unused]] std::string_view type_descriptor) const override { 60 return false; 61 } SetEnablePublicSdkChecks(bool enabled)62 void SetEnablePublicSdkChecks([[maybe_unused]] bool enabled) override {} 63 64 // Transaction-related virtual functions should not be called on `PermissiveClassLinker`. 65 TransactionWriteConstraint(Thread * self,ObjPtr<mirror::Object> obj)66 bool TransactionWriteConstraint([[maybe_unused]] Thread* self, 67 [[maybe_unused]] ObjPtr<mirror::Object> obj) override 68 REQUIRES_SHARED(Locks::mutator_lock_) { 69 LOG(FATAL) << "UNREACHABLE"; 70 UNREACHABLE(); 71 } 72 TransactionWriteValueConstraint(Thread * self,ObjPtr<mirror::Object> value)73 bool TransactionWriteValueConstraint([[maybe_unused]] Thread* self, 74 [[maybe_unused]] ObjPtr<mirror::Object> value) override 75 REQUIRES_SHARED(Locks::mutator_lock_) { 76 LOG(FATAL) << "UNREACHABLE"; 77 UNREACHABLE(); 78 } 79 TransactionAllocationConstraint(Thread * self,ObjPtr<mirror::Class> klass)80 bool TransactionAllocationConstraint([[maybe_unused]] Thread* self, 81 [[maybe_unused]] ObjPtr<mirror::Class> klass) override 82 REQUIRES_SHARED(Locks::mutator_lock_) { 83 LOG(FATAL) << "UNREACHABLE"; 84 UNREACHABLE(); 85 } 86 RecordWriteFieldBoolean(mirror::Object * obj,MemberOffset field_offset,uint8_t value,bool is_volatile)87 void RecordWriteFieldBoolean([[maybe_unused]] mirror::Object* obj, 88 [[maybe_unused]] MemberOffset field_offset, 89 [[maybe_unused]] uint8_t value, 90 [[maybe_unused]] bool is_volatile) override { 91 LOG(FATAL) << "UNREACHABLE"; 92 UNREACHABLE(); 93 } 94 RecordWriteFieldByte(mirror::Object * obj,MemberOffset field_offset,int8_t value,bool is_volatile)95 void RecordWriteFieldByte([[maybe_unused]] mirror::Object* obj, 96 [[maybe_unused]] MemberOffset field_offset, 97 [[maybe_unused]] int8_t value, 98 [[maybe_unused]] bool is_volatile) override { 99 LOG(FATAL) << "UNREACHABLE"; 100 UNREACHABLE(); 101 } 102 RecordWriteFieldChar(mirror::Object * obj,MemberOffset field_offset,uint16_t value,bool is_volatile)103 void RecordWriteFieldChar([[maybe_unused]] mirror::Object* obj, 104 [[maybe_unused]] MemberOffset field_offset, 105 [[maybe_unused]] uint16_t value, 106 [[maybe_unused]] bool is_volatile) override { 107 LOG(FATAL) << "UNREACHABLE"; 108 UNREACHABLE(); 109 } 110 RecordWriteFieldShort(mirror::Object * obj,MemberOffset field_offset,int16_t value,bool is_volatile)111 void RecordWriteFieldShort([[maybe_unused]] mirror::Object* obj, 112 [[maybe_unused]] MemberOffset field_offset, 113 [[maybe_unused]] int16_t value, 114 [[maybe_unused]] bool is_volatile) override { 115 LOG(FATAL) << "UNREACHABLE"; 116 UNREACHABLE(); 117 } 118 RecordWriteField32(mirror::Object * obj,MemberOffset field_offset,uint32_t value,bool is_volatile)119 void RecordWriteField32([[maybe_unused]] mirror::Object* obj, 120 [[maybe_unused]] MemberOffset field_offset, 121 [[maybe_unused]] uint32_t value, 122 [[maybe_unused]] bool is_volatile) override { 123 LOG(FATAL) << "UNREACHABLE"; 124 UNREACHABLE(); 125 } 126 RecordWriteField64(mirror::Object * obj,MemberOffset field_offset,uint64_t value,bool is_volatile)127 void RecordWriteField64([[maybe_unused]] mirror::Object* obj, 128 [[maybe_unused]] MemberOffset field_offset, 129 [[maybe_unused]] uint64_t value, 130 [[maybe_unused]] bool is_volatile) override { 131 LOG(FATAL) << "UNREACHABLE"; 132 UNREACHABLE(); 133 } 134 RecordWriteFieldReference(mirror::Object * obj,MemberOffset field_offset,ObjPtr<mirror::Object> value,bool is_volatile)135 void RecordWriteFieldReference([[maybe_unused]] mirror::Object* obj, 136 [[maybe_unused]] MemberOffset field_offset, 137 [[maybe_unused]] ObjPtr<mirror::Object> value, 138 [[maybe_unused]] bool is_volatile) override 139 REQUIRES_SHARED(Locks::mutator_lock_) { 140 LOG(FATAL) << "UNREACHABLE"; 141 UNREACHABLE(); 142 } 143 RecordWriteArray(mirror::Array * array,size_t index,uint64_t value)144 void RecordWriteArray([[maybe_unused]] mirror::Array* array, 145 [[maybe_unused]] size_t index, 146 [[maybe_unused]] uint64_t value) override 147 REQUIRES_SHARED(Locks::mutator_lock_) { 148 LOG(FATAL) << "UNREACHABLE"; 149 UNREACHABLE(); 150 } 151 RecordStrongStringInsertion(ObjPtr<mirror::String> s)152 void RecordStrongStringInsertion([[maybe_unused]] ObjPtr<mirror::String> s) override 153 REQUIRES(Locks::intern_table_lock_) { 154 LOG(FATAL) << "UNREACHABLE"; 155 UNREACHABLE(); 156 } 157 RecordWeakStringInsertion(ObjPtr<mirror::String> s)158 void RecordWeakStringInsertion([[maybe_unused]] ObjPtr<mirror::String> s) override 159 REQUIRES(Locks::intern_table_lock_) { 160 LOG(FATAL) << "UNREACHABLE"; 161 UNREACHABLE(); 162 } 163 RecordStrongStringRemoval(ObjPtr<mirror::String> s)164 void RecordStrongStringRemoval([[maybe_unused]] ObjPtr<mirror::String> s) override 165 REQUIRES(Locks::intern_table_lock_) { 166 LOG(FATAL) << "UNREACHABLE"; 167 UNREACHABLE(); 168 } 169 RecordWeakStringRemoval(ObjPtr<mirror::String> s)170 void RecordWeakStringRemoval([[maybe_unused]] ObjPtr<mirror::String> s) override 171 REQUIRES(Locks::intern_table_lock_) { 172 LOG(FATAL) << "UNREACHABLE"; 173 UNREACHABLE(); 174 } 175 RecordResolveString(ObjPtr<mirror::DexCache> dex_cache,dex::StringIndex string_idx)176 void RecordResolveString([[maybe_unused]] ObjPtr<mirror::DexCache> dex_cache, 177 [[maybe_unused]] dex::StringIndex string_idx) override 178 REQUIRES_SHARED(Locks::mutator_lock_) { 179 LOG(FATAL) << "UNREACHABLE"; 180 UNREACHABLE(); 181 } 182 RecordResolveMethodType(ObjPtr<mirror::DexCache> dex_cache,dex::ProtoIndex proto_idx)183 void RecordResolveMethodType([[maybe_unused]] ObjPtr<mirror::DexCache> dex_cache, 184 [[maybe_unused]] dex::ProtoIndex proto_idx) override 185 REQUIRES_SHARED(Locks::mutator_lock_) { 186 LOG(FATAL) << "UNREACHABLE"; 187 UNREACHABLE(); 188 } 189 ThrowTransactionAbortError(Thread * self)190 void ThrowTransactionAbortError([[maybe_unused]] Thread* self) override 191 REQUIRES_SHARED(Locks::mutator_lock_) { 192 LOG(FATAL) << "UNREACHABLE"; 193 UNREACHABLE(); 194 } 195 AbortTransactionF(Thread * self,const char * fmt,...)196 void AbortTransactionF([[maybe_unused]] Thread* self, 197 [[maybe_unused]] const char* fmt, ...) override 198 __attribute__((__format__(__printf__, 3, 4))) 199 REQUIRES_SHARED(Locks::mutator_lock_) { 200 LOG(FATAL) << "UNREACHABLE"; 201 UNREACHABLE(); 202 } 203 AbortTransactionV(Thread * self,const char * fmt,va_list args)204 void AbortTransactionV([[maybe_unused]] Thread* self, 205 [[maybe_unused]] const char* fmt, 206 [[maybe_unused]] va_list args) override 207 REQUIRES_SHARED(Locks::mutator_lock_) { 208 LOG(FATAL) << "UNREACHABLE"; 209 UNREACHABLE(); 210 } 211 IsTransactionAborted()212 bool IsTransactionAborted() const override { 213 LOG(FATAL) << "UNREACHABLE"; 214 UNREACHABLE(); 215 } 216 VisitTransactionRoots(RootVisitor * visitor)217 void VisitTransactionRoots([[maybe_unused]] RootVisitor* visitor) override { 218 // Nothing to do for `PermissiveClassLinker`, only `AotClassLinker` handles transactions. 219 } 220 GetTransactionalInterpreter()221 const void* GetTransactionalInterpreter() override { 222 LOG(FATAL) << "UNREACHABLE"; 223 UNREACHABLE(); 224 } 225 }; 226 227 DISALLOW_COPY_AND_ASSIGN(NoopCompilerCallbacks); 228 }; 229 230 } // namespace art 231 232 #endif // ART_RUNTIME_NOOP_COMPILER_CALLBACKS_H_ 233