blob: 11750fd9645bbe123371290771c21fe7066b9c6e [file] [log] [blame]
David Brazdilca3c8c32016-09-06 14:04:48 +01001/*
2 * Copyright (C) 2016 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_VERIFIER_VERIFIER_DEPS_H_
18#define ART_RUNTIME_VERIFIER_VERIFIER_DEPS_H_
19
20#include <map>
21#include <set>
22#include <vector>
23
24#include "art_field.h"
25#include "art_method.h"
David Brazdil6f82fbd2016-09-14 11:55:26 +010026#include "base/array_ref.h"
David Brazdilca3c8c32016-09-06 14:04:48 +010027#include "base/mutex.h"
Nicolas Geoffrayd01f60c2016-10-28 14:45:48 +010028#include "indenter.h"
David Brazdilca3c8c32016-09-06 14:04:48 +010029#include "method_resolution_kind.h"
Nicolas Geoffray08025182016-10-25 17:20:18 +010030#include "method_verifier.h" // For MethodVerifier::FailureKind.
Mathieu Chartier3398c782016-09-30 10:27:43 -070031#include "obj_ptr.h"
David Brazdilca3c8c32016-09-06 14:04:48 +010032#include "os.h"
33
34namespace art {
35namespace verifier {
36
37// Verification dependencies collector class used by the MethodVerifier to record
38// resolution outcomes and type assignability tests of classes/methods/fields
39// not present in the set of compiled DEX files, that is classes/methods/fields
40// defined in the classpath.
41// The compilation driver initializes the class and registers all DEX files
42// which are being compiled. Classes defined in DEX files outside of this set
43// (or synthesized classes without associated DEX files) are considered being
44// in the classpath.
Nicolas Geoffray340dafa2016-11-18 16:03:10 +000045// During code-flow verification, the MethodVerifier informs VerifierDeps
46// about the outcome of every resolution and assignability test, and
47// the VerifierDeps object records them if their outcome may change with
48// changes in the classpath.
David Brazdilca3c8c32016-09-06 14:04:48 +010049class VerifierDeps {
50 public:
Nicolas Geoffray340dafa2016-11-18 16:03:10 +000051 explicit VerifierDeps(const std::vector<const DexFile*>& dex_files);
David Brazdilca3c8c32016-09-06 14:04:48 +010052
Nicolas Geoffray340dafa2016-11-18 16:03:10 +000053 VerifierDeps(const std::vector<const DexFile*>& dex_files, ArrayRef<const uint8_t> data);
54
55 // Merge `other` into this `VerifierDeps`'. `other` and `this` must be for the
56 // same set of dex files.
57 void MergeWith(const VerifierDeps& other, const std::vector<const DexFile*>& dex_files);
Nicolas Geoffraye70dd562016-10-30 21:03:35 +000058
Nicolas Geoffray08025182016-10-25 17:20:18 +010059 // Record the verification status of the class at `type_idx`.
60 static void MaybeRecordVerificationStatus(const DexFile& dex_file,
Andreas Gampea5b09a62016-11-17 15:21:22 -080061 dex::TypeIndex type_idx,
Nicolas Geoffray08025182016-10-25 17:20:18 +010062 MethodVerifier::FailureKind failure_kind)
63 REQUIRES(!Locks::verifier_deps_lock_);
64
David Brazdilca3c8c32016-09-06 14:04:48 +010065 // Record the outcome `klass` of resolving type `type_idx` from `dex_file`.
66 // If `klass` is null, the class is assumed unresolved.
67 static void MaybeRecordClassResolution(const DexFile& dex_file,
Andreas Gampea5b09a62016-11-17 15:21:22 -080068 dex::TypeIndex type_idx,
David Brazdilca3c8c32016-09-06 14:04:48 +010069 mirror::Class* klass)
70 REQUIRES_SHARED(Locks::mutator_lock_)
71 REQUIRES(!Locks::verifier_deps_lock_);
72
73 // Record the outcome `field` of resolving field `field_idx` from `dex_file`.
74 // If `field` is null, the field is assumed unresolved.
75 static void MaybeRecordFieldResolution(const DexFile& dex_file,
76 uint32_t field_idx,
77 ArtField* field)
78 REQUIRES_SHARED(Locks::mutator_lock_)
79 REQUIRES(!Locks::verifier_deps_lock_);
80
81 // Record the outcome `method` of resolving method `method_idx` from `dex_file`
82 // using `res_kind` kind of method resolution algorithm. If `method` is null,
83 // the method is assumed unresolved.
84 static void MaybeRecordMethodResolution(const DexFile& dex_file,
85 uint32_t method_idx,
86 MethodResolutionKind res_kind,
87 ArtMethod* method)
88 REQUIRES_SHARED(Locks::mutator_lock_)
89 REQUIRES(!Locks::verifier_deps_lock_);
90
91 // Record the outcome `is_assignable` of type assignability test from `source`
92 // to `destination` as defined by RegType::AssignableFrom. `dex_file` is the
93 // owner of the method for which MethodVerifier performed the assignability test.
94 static void MaybeRecordAssignability(const DexFile& dex_file,
95 mirror::Class* destination,
96 mirror::Class* source,
97 bool is_strict,
98 bool is_assignable)
99 REQUIRES_SHARED(Locks::mutator_lock_)
100 REQUIRES(!Locks::verifier_deps_lock_);
101
David Brazdil6f82fbd2016-09-14 11:55:26 +0100102 // Serialize the recorded dependencies and store the data into `buffer`.
Nicolas Geoffrayd01f60c2016-10-28 14:45:48 +0100103 // `dex_files` provides the order of the dex files in which the dependencies
104 // should be emitted.
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000105 void Encode(const std::vector<const DexFile*>& dex_files, std::vector<uint8_t>* buffer) const;
David Brazdil6f82fbd2016-09-14 11:55:26 +0100106
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000107 void Dump(VariableIndentationOutputStream* vios) const;
Nicolas Geoffrayd01f60c2016-10-28 14:45:48 +0100108
Nicolas Geoffray6bb7f1b2016-11-03 10:52:49 +0000109 // Verify the encoded dependencies of this `VerifierDeps` are still valid.
Nicolas Geoffray6bb7f1b2016-11-03 10:52:49 +0000110 bool ValidateDependencies(Handle<mirror::ClassLoader> class_loader, Thread* self) const
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000111 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray8904b6f2016-10-28 19:50:34 +0100112
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000113 const std::vector<dex::TypeIndex>& GetUnverifiedClasses(const DexFile& dex_file) const {
Nicolas Geoffray6bb7f1b2016-11-03 10:52:49 +0000114 return GetDexFileDeps(dex_file)->unverified_classes_;
115 }
116
David Brazdilca3c8c32016-09-06 14:04:48 +0100117 private:
118 static constexpr uint16_t kUnresolvedMarker = static_cast<uint16_t>(-1);
119
Andreas Gampea5b09a62016-11-17 15:21:22 -0800120 using ClassResolutionBase = std::tuple<dex::TypeIndex, uint16_t>;
David Brazdilca3c8c32016-09-06 14:04:48 +0100121 struct ClassResolution : public ClassResolutionBase {
David Brazdil6f82fbd2016-09-14 11:55:26 +0100122 ClassResolution() = default;
123 ClassResolution(const ClassResolution&) = default;
Andreas Gampea5b09a62016-11-17 15:21:22 -0800124 ClassResolution(dex::TypeIndex type_idx, uint16_t access_flags)
David Brazdilca3c8c32016-09-06 14:04:48 +0100125 : ClassResolutionBase(type_idx, access_flags) {}
David Brazdilca3c8c32016-09-06 14:04:48 +0100126
127 bool IsResolved() const { return GetAccessFlags() != kUnresolvedMarker; }
Andreas Gampea5b09a62016-11-17 15:21:22 -0800128 dex::TypeIndex GetDexTypeIndex() const { return std::get<0>(*this); }
David Brazdilca3c8c32016-09-06 14:04:48 +0100129 uint16_t GetAccessFlags() const { return std::get<1>(*this); }
130 };
131
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800132 using FieldResolutionBase = std::tuple<uint32_t, uint16_t, dex::StringIndex>;
David Brazdilca3c8c32016-09-06 14:04:48 +0100133 struct FieldResolution : public FieldResolutionBase {
David Brazdil6f82fbd2016-09-14 11:55:26 +0100134 FieldResolution() = default;
135 FieldResolution(const FieldResolution&) = default;
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800136 FieldResolution(uint32_t field_idx, uint16_t access_flags, dex::StringIndex declaring_class_idx)
David Brazdilca3c8c32016-09-06 14:04:48 +0100137 : FieldResolutionBase(field_idx, access_flags, declaring_class_idx) {}
David Brazdilca3c8c32016-09-06 14:04:48 +0100138
139 bool IsResolved() const { return GetAccessFlags() != kUnresolvedMarker; }
140 uint32_t GetDexFieldIndex() const { return std::get<0>(*this); }
141 uint16_t GetAccessFlags() const { return std::get<1>(*this); }
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800142 dex::StringIndex GetDeclaringClassIndex() const { return std::get<2>(*this); }
David Brazdilca3c8c32016-09-06 14:04:48 +0100143 };
144
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800145 using MethodResolutionBase = std::tuple<uint32_t, uint16_t, dex::StringIndex>;
David Brazdilca3c8c32016-09-06 14:04:48 +0100146 struct MethodResolution : public MethodResolutionBase {
David Brazdil6f82fbd2016-09-14 11:55:26 +0100147 MethodResolution() = default;
148 MethodResolution(const MethodResolution&) = default;
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800149 MethodResolution(uint32_t method_idx,
150 uint16_t access_flags,
151 dex::StringIndex declaring_class_idx)
David Brazdilca3c8c32016-09-06 14:04:48 +0100152 : MethodResolutionBase(method_idx, access_flags, declaring_class_idx) {}
David Brazdilca3c8c32016-09-06 14:04:48 +0100153
154 bool IsResolved() const { return GetAccessFlags() != kUnresolvedMarker; }
155 uint32_t GetDexMethodIndex() const { return std::get<0>(*this); }
156 uint16_t GetAccessFlags() const { return std::get<1>(*this); }
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800157 dex::StringIndex GetDeclaringClassIndex() const { return std::get<2>(*this); }
David Brazdilca3c8c32016-09-06 14:04:48 +0100158 };
159
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800160 using TypeAssignabilityBase = std::tuple<dex::StringIndex, dex::StringIndex>;
Nicolas Geoffray08025182016-10-25 17:20:18 +0100161 struct TypeAssignability : public TypeAssignabilityBase {
David Brazdil6f82fbd2016-09-14 11:55:26 +0100162 TypeAssignability() = default;
163 TypeAssignability(const TypeAssignability&) = default;
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800164 TypeAssignability(dex::StringIndex destination_idx, dex::StringIndex source_idx)
David Brazdilca3c8c32016-09-06 14:04:48 +0100165 : TypeAssignabilityBase(destination_idx, source_idx) {}
David Brazdilca3c8c32016-09-06 14:04:48 +0100166
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800167 dex::StringIndex GetDestination() const { return std::get<0>(*this); }
168 dex::StringIndex GetSource() const { return std::get<1>(*this); }
David Brazdilca3c8c32016-09-06 14:04:48 +0100169 };
170
171 // Data structure representing dependencies collected during verification of
172 // methods inside one DexFile.
173 struct DexFileDeps {
174 // Vector of strings which are not present in the corresponding DEX file.
175 // These are referred to with ids starting with `NumStringIds()` of that DexFile.
176 std::vector<std::string> strings_;
177
178 // Set of class pairs recording the outcome of assignability test from one
179 // of the two types to the other.
180 std::set<TypeAssignability> assignable_types_;
181 std::set<TypeAssignability> unassignable_types_;
182
183 // Sets of recorded class/field/method resolutions.
184 std::set<ClassResolution> classes_;
185 std::set<FieldResolution> fields_;
186 std::set<MethodResolution> direct_methods_;
187 std::set<MethodResolution> virtual_methods_;
188 std::set<MethodResolution> interface_methods_;
David Brazdil6f82fbd2016-09-14 11:55:26 +0100189
Nicolas Geoffray08025182016-10-25 17:20:18 +0100190 // List of classes that were not fully verified in that dex file.
Andreas Gampea5b09a62016-11-17 15:21:22 -0800191 std::vector<dex::TypeIndex> unverified_classes_;
Nicolas Geoffray08025182016-10-25 17:20:18 +0100192
David Brazdil6f82fbd2016-09-14 11:55:26 +0100193 bool Equals(const DexFileDeps& rhs) const;
David Brazdilca3c8c32016-09-06 14:04:48 +0100194 };
195
196 // Finds the DexFileDep instance associated with `dex_file`, or nullptr if
197 // `dex_file` is not reported as being compiled.
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000198 DexFileDeps* GetDexFileDeps(const DexFile& dex_file);
David Brazdilca3c8c32016-09-06 14:04:48 +0100199
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000200 const DexFileDeps* GetDexFileDeps(const DexFile& dex_file) const;
Nicolas Geoffrayd01f60c2016-10-28 14:45:48 +0100201
David Brazdilca3c8c32016-09-06 14:04:48 +0100202 // Returns true if `klass` is null or not defined in any of dex files which
203 // were reported as being compiled.
Nicolas Geoffrayd01f60c2016-10-28 14:45:48 +0100204 bool IsInClassPath(ObjPtr<mirror::Class> klass) const
David Brazdilca3c8c32016-09-06 14:04:48 +0100205 REQUIRES_SHARED(Locks::mutator_lock_);
206
Nicolas Geoffray0e2fe0f2016-12-21 16:54:52 +0000207 // Finds the class in the classpath that makes `source` inherit` from `destination`.
208 // Returns null if a class defined in the compiled DEX files, and assignable to
209 // `source`, direclty inherits from `destination`.
210 mirror::Class* FindOneClassPathBoundaryForInterface(mirror::Class* destination,
211 mirror::Class* source) const
212 REQUIRES_SHARED(Locks::mutator_lock_);
213
David Brazdilca3c8c32016-09-06 14:04:48 +0100214 // Returns the index of `str`. If it is defined in `dex_file_`, this is the dex
215 // string ID. If not, an ID is assigned to the string and cached in `strings_`
216 // of the corresponding DexFileDeps structure (either provided or inferred from
217 // `dex_file`).
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800218 dex::StringIndex GetIdFromString(const DexFile& dex_file, const std::string& str)
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000219 REQUIRES(!Locks::verifier_deps_lock_);
David Brazdilca3c8c32016-09-06 14:04:48 +0100220
221 // Returns the string represented by `id`.
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800222 std::string GetStringFromId(const DexFile& dex_file, dex::StringIndex string_id) const;
David Brazdilca3c8c32016-09-06 14:04:48 +0100223
224 // Returns the bytecode access flags of `element` (bottom 16 bits), or
225 // `kUnresolvedMarker` if `element` is null.
226 template <typename T>
Nicolas Geoffrayd01f60c2016-10-28 14:45:48 +0100227 static uint16_t GetAccessFlags(T* element)
David Brazdilca3c8c32016-09-06 14:04:48 +0100228 REQUIRES_SHARED(Locks::mutator_lock_);
229
230 // Returns a string ID of the descriptor of the declaring class of `element`,
231 // or `kUnresolvedMarker` if `element` is null.
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800232 dex::StringIndex GetMethodDeclaringClassStringId(const DexFile& dex_file,
233 uint32_t dex_method_idx,
234 ArtMethod* method)
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000235 REQUIRES_SHARED(Locks::mutator_lock_);
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800236 dex::StringIndex GetFieldDeclaringClassStringId(const DexFile& dex_file,
237 uint32_t dex_field_idx,
238 ArtField* field)
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000239 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier32b50302016-11-17 13:08:35 -0800240
241 // Returns a string ID of the descriptor of the class.
Andreas Gampe8a0128a2016-11-28 07:38:35 -0800242 dex::StringIndex GetClassDescriptorStringId(const DexFile& dex_file, ObjPtr<mirror::Class> klass)
David Brazdilca3c8c32016-09-06 14:04:48 +0100243 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000244 REQUIRES(!Locks::verifier_deps_lock_);
David Brazdilca3c8c32016-09-06 14:04:48 +0100245
246 void AddClassResolution(const DexFile& dex_file,
Andreas Gampea5b09a62016-11-17 15:21:22 -0800247 dex::TypeIndex type_idx,
David Brazdilca3c8c32016-09-06 14:04:48 +0100248 mirror::Class* klass)
249 REQUIRES_SHARED(Locks::mutator_lock_)
250 REQUIRES(!Locks::verifier_deps_lock_);
251
252 void AddFieldResolution(const DexFile& dex_file,
253 uint32_t field_idx,
254 ArtField* field)
255 REQUIRES_SHARED(Locks::mutator_lock_)
256 REQUIRES(!Locks::verifier_deps_lock_);
257
258 void AddMethodResolution(const DexFile& dex_file,
259 uint32_t method_idx,
260 MethodResolutionKind res_kind,
261 ArtMethod* method)
262 REQUIRES_SHARED(Locks::mutator_lock_)
263 REQUIRES(!Locks::verifier_deps_lock_);
264
265 void AddAssignability(const DexFile& dex_file,
266 mirror::Class* destination,
267 mirror::Class* source,
268 bool is_strict,
269 bool is_assignable)
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000270 REQUIRES_SHARED(Locks::mutator_lock_);
David Brazdilca3c8c32016-09-06 14:04:48 +0100271
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000272 bool Equals(const VerifierDeps& rhs) const;
David Brazdil6f82fbd2016-09-14 11:55:26 +0100273
Nicolas Geoffray8904b6f2016-10-28 19:50:34 +0100274 // Verify `dex_file` according to the `deps`, that is going over each
275 // `DexFileDeps` field, and checking that the recorded information still
276 // holds.
277 bool VerifyDexFile(Handle<mirror::ClassLoader> class_loader,
278 const DexFile& dex_file,
279 const DexFileDeps& deps,
280 Thread* self) const
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000281 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray8904b6f2016-10-28 19:50:34 +0100282
283 bool VerifyAssignability(Handle<mirror::ClassLoader> class_loader,
284 const DexFile& dex_file,
285 const std::set<TypeAssignability>& assignables,
286 bool expected_assignability,
287 Thread* self) const
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000288 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray8904b6f2016-10-28 19:50:34 +0100289
290 // Verify that the set of resolved classes at the point of creation
291 // of this `VerifierDeps` is still the same.
292 bool VerifyClasses(Handle<mirror::ClassLoader> class_loader,
293 const DexFile& dex_file,
294 const std::set<ClassResolution>& classes,
295 Thread* self) const
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000296 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray8904b6f2016-10-28 19:50:34 +0100297
298 // Verify that the set of resolved fields at the point of creation
299 // of this `VerifierDeps` is still the same, and each field resolves to the
300 // same field holder and access flags.
301 bool VerifyFields(Handle<mirror::ClassLoader> class_loader,
302 const DexFile& dex_file,
303 const std::set<FieldResolution>& classes,
304 Thread* self) const
305 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000306 REQUIRES(!Locks::verifier_deps_lock_);
Nicolas Geoffray8904b6f2016-10-28 19:50:34 +0100307
308 // Verify that the set of resolved methods at the point of creation
309 // of this `VerifierDeps` is still the same, and each method resolves to the
310 // same method holder, access flags, and invocation kind.
311 bool VerifyMethods(Handle<mirror::ClassLoader> class_loader,
312 const DexFile& dex_file,
313 const std::set<MethodResolution>& methods,
314 MethodResolutionKind kind,
315 Thread* self) const
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000316 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray8904b6f2016-10-28 19:50:34 +0100317
David Brazdilca3c8c32016-09-06 14:04:48 +0100318 // Map from DexFiles into dependencies collected from verification of their methods.
Nicolas Geoffray340dafa2016-11-18 16:03:10 +0000319 std::map<const DexFile*, std::unique_ptr<DexFileDeps>> dex_deps_;
David Brazdilca3c8c32016-09-06 14:04:48 +0100320
321 friend class VerifierDepsTest;
322 ART_FRIEND_TEST(VerifierDepsTest, StringToId);
David Brazdil6f82fbd2016-09-14 11:55:26 +0100323 ART_FRIEND_TEST(VerifierDepsTest, EncodeDecode);
Nicolas Geoffrayd01f60c2016-10-28 14:45:48 +0100324 ART_FRIEND_TEST(VerifierDepsTest, EncodeDecodeMulti);
Nicolas Geoffray8904b6f2016-10-28 19:50:34 +0100325 ART_FRIEND_TEST(VerifierDepsTest, VerifyDeps);
Nicolas Geoffray6bb7f1b2016-11-03 10:52:49 +0000326 ART_FRIEND_TEST(VerifierDepsTest, CompilerDriver);
David Brazdilca3c8c32016-09-06 14:04:48 +0100327};
328
329} // namespace verifier
330} // namespace art
331
332#endif // ART_RUNTIME_VERIFIER_VERIFIER_DEPS_H_