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 #include "verification_results.h" 18 19 #include "base/logging.h" 20 #include "base/stl_util.h" 21 #include "base/mutex-inl.h" 22 #include "driver/compiler_driver.h" 23 #include "driver/compiler_options.h" 24 #include "thread.h" 25 #include "thread-inl.h" 26 #include "verified_method.h" 27 #include "verifier/method_verifier-inl.h" 28 29 namespace art { 30 31 VerificationResults::VerificationResults(const CompilerOptions* compiler_options) 32 : compiler_options_(compiler_options), 33 verified_methods_lock_("compiler verified methods lock"), 34 verified_methods_(), 35 rejected_classes_lock_("compiler rejected classes lock"), 36 rejected_classes_() { 37 UNUSED(compiler_options); 38 } 39 40 VerificationResults::~VerificationResults() { 41 Thread* self = Thread::Current(); 42 { 43 WriterMutexLock mu(self, verified_methods_lock_); 44 STLDeleteValues(&verified_methods_); 45 } 46 } 47 48 bool VerificationResults::ProcessVerifiedMethod(verifier::MethodVerifier* method_verifier) { 49 DCHECK(method_verifier != nullptr); 50 MethodReference ref = method_verifier->GetMethodReference(); 51 bool compile = IsCandidateForCompilation(ref, method_verifier->GetAccessFlags()); 52 const VerifiedMethod* verified_method = VerifiedMethod::Create(method_verifier, compile); 53 if (verified_method == nullptr) { 54 // Do not report an error to the verifier. We'll just punt this later. 55 return true; 56 } 57 58 WriterMutexLock mu(Thread::Current(), verified_methods_lock_); 59 auto it = verified_methods_.find(ref); 60 if (it != verified_methods_.end()) { 61 // TODO: Investigate why are we doing the work again for this method and try to avoid it. 62 LOG(WARNING) << "Method processed more than once: " 63 << PrettyMethod(ref.dex_method_index, *ref.dex_file); 64 if (!Runtime::Current()->UseJit()) { 65 DCHECK_EQ(it->second->GetDevirtMap().size(), verified_method->GetDevirtMap().size()); 66 DCHECK_EQ(it->second->GetSafeCastSet().size(), verified_method->GetSafeCastSet().size()); 67 } 68 DCHECK_EQ(it->second->GetDexGcMap().size(), verified_method->GetDexGcMap().size()); 69 // Delete the new verified method since there was already an existing one registered. It 70 // is unsafe to replace the existing one since the JIT may be using it to generate a 71 // native GC map. 72 delete verified_method; 73 return true; 74 } 75 verified_methods_.Put(ref, verified_method); 76 DCHECK(verified_methods_.find(ref) != verified_methods_.end()); 77 return true; 78 } 79 80 const VerifiedMethod* VerificationResults::GetVerifiedMethod(MethodReference ref) { 81 ReaderMutexLock mu(Thread::Current(), verified_methods_lock_); 82 auto it = verified_methods_.find(ref); 83 return (it != verified_methods_.end()) ? it->second : nullptr; 84 } 85 86 void VerificationResults::RemoveVerifiedMethod(MethodReference ref) { 87 WriterMutexLock mu(Thread::Current(), verified_methods_lock_); 88 auto it = verified_methods_.find(ref); 89 if (it != verified_methods_.end()) { 90 delete it->second; 91 verified_methods_.erase(it); 92 } 93 } 94 95 void VerificationResults::AddRejectedClass(ClassReference ref) { 96 { 97 WriterMutexLock mu(Thread::Current(), rejected_classes_lock_); 98 rejected_classes_.insert(ref); 99 } 100 DCHECK(IsClassRejected(ref)); 101 } 102 103 bool VerificationResults::IsClassRejected(ClassReference ref) { 104 ReaderMutexLock mu(Thread::Current(), rejected_classes_lock_); 105 return (rejected_classes_.find(ref) != rejected_classes_.end()); 106 } 107 108 bool VerificationResults::IsCandidateForCompilation(MethodReference&, 109 const uint32_t access_flags) { 110 if (!compiler_options_->IsCompilationEnabled()) { 111 return false; 112 } 113 // Don't compile class initializers unless kEverything. 114 if ((compiler_options_->GetCompilerFilter() != CompilerOptions::kEverything) && 115 ((access_flags & kAccConstructor) != 0) && ((access_flags & kAccStatic) != 0)) { 116 return false; 117 } 118 return true; 119 } 120 121 } // namespace art 122