1 /*
2 * Copyright (C) 2014 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 "verified_method.h"
18
19 #include <algorithm>
20 #include <memory>
21
22 #include "base/logging.h"
23 #include "dex_file.h"
24 #include "dex_instruction-inl.h"
25 #include "runtime.h"
26 #include "verifier/method_verifier-inl.h"
27 #include "verifier/reg_type-inl.h"
28 #include "verifier/register_line-inl.h"
29 #include "verifier/verifier_deps.h"
30
31 namespace art {
32
VerifiedMethod(uint32_t encountered_error_types,bool has_runtime_throw)33 VerifiedMethod::VerifiedMethod(uint32_t encountered_error_types, bool has_runtime_throw)
34 : encountered_error_types_(encountered_error_types),
35 has_runtime_throw_(has_runtime_throw) {
36 }
37
Create(verifier::MethodVerifier * method_verifier)38 const VerifiedMethod* VerifiedMethod::Create(verifier::MethodVerifier* method_verifier) {
39 DCHECK(Runtime::Current()->IsAotCompiler());
40 std::unique_ptr<VerifiedMethod> verified_method(
41 new VerifiedMethod(method_verifier->GetEncounteredFailureTypes(),
42 method_verifier->HasInstructionThatWillThrow()));
43
44 if (method_verifier->HasCheckCasts()) {
45 verified_method->GenerateSafeCastSet(method_verifier);
46 }
47
48 return verified_method.release();
49 }
50
IsSafeCast(uint32_t pc) const51 bool VerifiedMethod::IsSafeCast(uint32_t pc) const {
52 if (safe_cast_set_ == nullptr) {
53 return false;
54 }
55 return std::binary_search(safe_cast_set_->begin(), safe_cast_set_->end(), pc);
56 }
57
GenerateSafeCastSet(verifier::MethodVerifier * method_verifier)58 void VerifiedMethod::GenerateSafeCastSet(verifier::MethodVerifier* method_verifier) {
59 /*
60 * Walks over the method code and adds any cast instructions in which
61 * the type cast is implicit to a set, which is used in the code generation
62 * to elide these casts.
63 */
64 if (method_verifier->HasFailures()) {
65 return;
66 }
67 const DexFile::CodeItem* code_item = method_verifier->CodeItem();
68 const Instruction* inst = Instruction::At(code_item->insns_);
69 const Instruction* end = Instruction::At(code_item->insns_ +
70 code_item->insns_size_in_code_units_);
71
72 for (; inst < end; inst = inst->Next()) {
73 Instruction::Code code = inst->Opcode();
74 if (code == Instruction::CHECK_CAST) {
75 uint32_t dex_pc = inst->GetDexPc(code_item->insns_);
76 if (!method_verifier->GetInstructionFlags(dex_pc).IsVisited()) {
77 // Do not attempt to quicken this instruction, it's unreachable anyway.
78 continue;
79 }
80 const verifier::RegisterLine* line = method_verifier->GetRegLine(dex_pc);
81 const verifier::RegType& reg_type(line->GetRegisterType(method_verifier,
82 inst->VRegA_21c()));
83 const verifier::RegType& cast_type =
84 method_verifier->ResolveCheckedClass(dex::TypeIndex(inst->VRegB_21c()));
85 // Pass null for the method verifier to not record the VerifierDeps dependency
86 // if the types are not assignable.
87 if (cast_type.IsStrictlyAssignableFrom(reg_type, /* method_verifier */ nullptr)) {
88 // The types are assignable, we record that dependency in the VerifierDeps so
89 // that if this changes after OTA, we will re-verify again.
90 // We check if reg_type has a class, as the verifier may have inferred it's
91 // 'null'.
92 if (reg_type.HasClass()) {
93 DCHECK(cast_type.HasClass());
94 verifier::VerifierDeps::MaybeRecordAssignability(method_verifier->GetDexFile(),
95 cast_type.GetClass(),
96 reg_type.GetClass(),
97 /* strict */ true,
98 /* assignable */ true);
99 }
100 if (safe_cast_set_ == nullptr) {
101 safe_cast_set_.reset(new SafeCastSet());
102 }
103 // Verify ordering for push_back() to the sorted vector.
104 DCHECK(safe_cast_set_->empty() || safe_cast_set_->back() < dex_pc);
105 safe_cast_set_->push_back(dex_pc);
106 }
107 }
108 }
109 DCHECK(safe_cast_set_ == nullptr || !safe_cast_set_->empty());
110 }
111
112 } // namespace art
113