• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2011 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_METHOD_VERIFIER_H_
18 #define ART_RUNTIME_VERIFIER_METHOD_VERIFIER_H_
19 
20 #include <set>
21 #include <vector>
22 
23 #include "base/casts.h"
24 #include "base/macros.h"
25 #include "base/stl_util.h"
26 #include "class_reference.h"
27 #include "dex_file.h"
28 #include "dex_instruction.h"
29 #include "instruction_flags.h"
30 #include "method_reference.h"
31 #include "mirror/object.h"
32 #include "reg_type.h"
33 #include "reg_type_cache-inl.h"
34 #include "register_line.h"
35 #include "safe_map.h"
36 #include "UniquePtr.h"
37 
38 namespace art {
39 
40 struct ReferenceMap2Visitor;
41 
42 namespace verifier {
43 
44 class MethodVerifier;
45 class DexPcToReferenceMap;
46 
47 /*
48  * "Direct" and "virtual" methods are stored independently. The type of call used to invoke the
49  * method determines which list we search, and whether we travel up into superclasses.
50  *
51  * (<clinit>, <init>, and methods declared "private" or "static" are stored in the "direct" list.
52  * All others are stored in the "virtual" list.)
53  */
54 enum MethodType {
55   METHOD_UNKNOWN  = 0,
56   METHOD_DIRECT,      // <init>, private
57   METHOD_STATIC,      // static
58   METHOD_VIRTUAL,     // virtual, super
59   METHOD_INTERFACE    // interface
60 };
61 std::ostream& operator<<(std::ostream& os, const MethodType& rhs);
62 
63 /*
64  * An enumeration of problems that can turn up during verification.
65  * Both VERIFY_ERROR_BAD_CLASS_SOFT and VERIFY_ERROR_BAD_CLASS_HARD denote failures that cause
66  * the entire class to be rejected. However, VERIFY_ERROR_BAD_CLASS_SOFT denotes a soft failure
67  * that can potentially be corrected, and the verifier will try again at runtime.
68  * VERIFY_ERROR_BAD_CLASS_HARD denotes a hard failure that can't be corrected, and will cause
69  * the class to remain uncompiled. Other errors denote verification errors that cause bytecode
70  * to be rewritten to fail at runtime.
71  */
72 enum VerifyError {
73   VERIFY_ERROR_BAD_CLASS_HARD,  // VerifyError; hard error that skips compilation.
74   VERIFY_ERROR_BAD_CLASS_SOFT,  // VerifyError; soft error that verifies again at runtime.
75 
76   VERIFY_ERROR_NO_CLASS,        // NoClassDefFoundError.
77   VERIFY_ERROR_NO_FIELD,        // NoSuchFieldError.
78   VERIFY_ERROR_NO_METHOD,       // NoSuchMethodError.
79   VERIFY_ERROR_ACCESS_CLASS,    // IllegalAccessError.
80   VERIFY_ERROR_ACCESS_FIELD,    // IllegalAccessError.
81   VERIFY_ERROR_ACCESS_METHOD,   // IllegalAccessError.
82   VERIFY_ERROR_CLASS_CHANGE,    // IncompatibleClassChangeError.
83   VERIFY_ERROR_INSTANTIATION,   // InstantiationError.
84 };
85 std::ostream& operator<<(std::ostream& os, const VerifyError& rhs);
86 
87 /*
88  * Identifies the type of reference in the instruction that generated the verify error
89  * (e.g. VERIFY_ERROR_ACCESS_CLASS could come from a method, field, or class reference).
90  *
91  * This must fit in two bits.
92  */
93 enum VerifyErrorRefType {
94   VERIFY_ERROR_REF_CLASS  = 0,
95   VERIFY_ERROR_REF_FIELD  = 1,
96   VERIFY_ERROR_REF_METHOD = 2,
97 };
98 const int kVerifyErrorRefTypeShift = 6;
99 
100 // We don't need to store the register data for many instructions, because we either only need
101 // it at branch points (for verification) or GC points and branches (for verification +
102 // type-precise register analysis).
103 enum RegisterTrackingMode {
104   kTrackRegsBranches,
105   kTrackCompilerInterestPoints,
106   kTrackRegsAll,
107 };
108 
109 // A mapping from a dex pc to the register line statuses as they are immediately prior to the
110 // execution of that instruction.
111 class PcToRegisterLineTable {
112  public:
PcToRegisterLineTable()113   PcToRegisterLineTable() {}
~PcToRegisterLineTable()114   ~PcToRegisterLineTable() {
115     STLDeleteValues(&pc_to_register_line_);
116   }
117 
118   // Initialize the RegisterTable. Every instruction address can have a different set of information
119   // about what's in which register, but for verification purposes we only need to store it at
120   // branch target addresses (because we merge into that).
121   void Init(RegisterTrackingMode mode, InstructionFlags* flags, uint32_t insns_size,
122             uint16_t registers_size, MethodVerifier* verifier);
123 
GetLine(size_t idx)124   RegisterLine* GetLine(size_t idx) {
125     auto result = pc_to_register_line_.find(idx);
126     if (result == pc_to_register_line_.end()) {
127       return NULL;
128     } else {
129       return result->second;
130     }
131   }
132 
133  private:
134   typedef SafeMap<int32_t, RegisterLine*> Table;
135   Table pc_to_register_line_;
136 };
137 
138 // The verifier
139 class MethodVerifier {
140  public:
141   enum FailureKind {
142     kNoFailure,
143     kSoftFailure,
144     kHardFailure,
145   };
146 
147   /* Verify a class. Returns "kNoFailure" on success. */
148   static FailureKind VerifyClass(const mirror::Class* klass, bool allow_soft_failures,
149                                  std::string* error)
150       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
151   static FailureKind VerifyClass(const DexFile* dex_file, mirror::DexCache* dex_cache,
152                                  mirror::ClassLoader* class_loader,
153                                  const DexFile::ClassDef* class_def,
154                                  bool allow_soft_failures, std::string* error)
155       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
156 
157   static void VerifyMethodAndDump(std::ostream& os, uint32_t method_idx, const DexFile* dex_file,
158                                   mirror::DexCache* dex_cache, mirror::ClassLoader* class_loader,
159                                   const DexFile::ClassDef* class_def,
160                                   const DexFile::CodeItem* code_item,
161                                   mirror::ArtMethod* method, uint32_t method_access_flags)
162       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
163 
164   uint8_t EncodePcToReferenceMapData() const;
165 
DexFileVersion()166   uint32_t DexFileVersion() const {
167     return dex_file_->GetVersion();
168   }
169 
GetRegTypeCache()170   RegTypeCache* GetRegTypeCache() {
171     return &reg_types_;
172   }
173 
174   // Log a verification failure.
175   std::ostream& Fail(VerifyError error);
176 
177   // Log for verification information.
LogVerifyInfo()178   std::ostream& LogVerifyInfo() {
179     return info_messages_ << "VFY: " << PrettyMethod(dex_method_idx_, *dex_file_)
180                           << '[' << reinterpret_cast<void*>(work_insn_idx_) << "] : ";
181   }
182 
183   // Dump the failures encountered by the verifier.
184   std::ostream& DumpFailures(std::ostream& os);
185 
186   // Dump the state of the verifier, namely each instruction, what flags are set on it, register
187   // information
188   void Dump(std::ostream& os) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
189 
190   static const std::vector<uint8_t>* GetDexGcMap(MethodReference ref)
191       LOCKS_EXCLUDED(dex_gc_maps_lock_);
192 
193   static const MethodReference* GetDevirtMap(const MethodReference& ref, uint32_t dex_pc)
194       LOCKS_EXCLUDED(devirt_maps_lock_);
195 
196   // Returns true if the cast can statically be verified to be redundant
197   // by using the check-cast elision peephole optimization in the verifier
198   static bool IsSafeCast(MethodReference ref, uint32_t pc) LOCKS_EXCLUDED(safecast_map_lock_);
199 
200   // Fills 'monitor_enter_dex_pcs' with the dex pcs of the monitor-enter instructions corresponding
201   // to the locks held at 'dex_pc' in method 'm'.
202   static void FindLocksAtDexPc(mirror::ArtMethod* m, uint32_t dex_pc,
203                                std::vector<uint32_t>& monitor_enter_dex_pcs)
204       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
205 
206   // Returns the accessed field corresponding to the quick instruction's field
207   // offset at 'dex_pc' in method 'm'.
208   static mirror::ArtField* FindAccessedFieldAtDexPc(mirror::ArtMethod* m, uint32_t dex_pc)
209       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
210 
211   // Returns the invoked method corresponding to the quick instruction's vtable
212   // index at 'dex_pc' in method 'm'.
213   static mirror::ArtMethod* FindInvokedMethodAtDexPc(mirror::ArtMethod* m, uint32_t dex_pc)
214       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
215 
216   static void Init() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
217   static void Shutdown();
218 
219   static bool IsClassRejected(ClassReference ref)
220       LOCKS_EXCLUDED(rejected_classes_lock_);
221 
CanLoadClasses()222   bool CanLoadClasses() const {
223     return can_load_classes_;
224   }
225 
226   MethodVerifier(const DexFile* dex_file, mirror::DexCache* dex_cache,
227                  mirror::ClassLoader* class_loader, const DexFile::ClassDef* class_def,
228                  const DexFile::CodeItem* code_item,
229                  uint32_t method_idx, mirror::ArtMethod* method,
230                  uint32_t access_flags, bool can_load_classes, bool allow_soft_failures)
231           SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
232 
~MethodVerifier()233   ~MethodVerifier() {
234     STLDeleteElements(&failure_messages_);
235   }
236 
237   // Run verification on the method. Returns true if verification completes and false if the input
238   // has an irrecoverable corruption.
239   bool Verify() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
240 
241   // Describe VRegs at the given dex pc.
242   std::vector<int32_t> DescribeVRegs(uint32_t dex_pc);
243 
244   static bool IsCandidateForCompilation(MethodReference& method_ref,
245                                         const uint32_t access_flags);
246 
247  private:
248   // Adds the given string to the beginning of the last failure message.
249   void PrependToLastFailMessage(std::string);
250 
251   // Adds the given string to the end of the last failure message.
252   void AppendToLastFailMessage(std::string);
253 
254   /*
255    * Perform verification on a single method.
256    *
257    * We do this in three passes:
258    *  (1) Walk through all code units, determining instruction locations,
259    *      widths, and other characteristics.
260    *  (2) Walk through all code units, performing static checks on
261    *      operands.
262    *  (3) Iterate through the method, checking type safety and looking
263    *      for code flow problems.
264    */
265   static FailureKind VerifyMethod(uint32_t method_idx, const DexFile* dex_file,
266                                   mirror::DexCache* dex_cache,
267                                   mirror::ClassLoader* class_loader,
268                                   const DexFile::ClassDef* class_def_idx,
269                                   const DexFile::CodeItem* code_item,
270                                   mirror::ArtMethod* method, uint32_t method_access_flags,
271                                   bool allow_soft_failures)
272           SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
273 
274   void FindLocksAtDexPc() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
275 
276   mirror::ArtField* FindAccessedFieldAtDexPc(uint32_t dex_pc)
277       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
278 
279   mirror::ArtMethod* FindInvokedMethodAtDexPc(uint32_t dex_pc)
280       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
281 
282   /*
283    * Compute the width of the instruction at each address in the instruction stream, and store it in
284    * insn_flags_. Addresses that are in the middle of an instruction, or that are part of switch
285    * table data, are not touched (so the caller should probably initialize "insn_flags" to zero).
286    *
287    * The "new_instance_count_" and "monitor_enter_count_" fields in vdata are also set.
288    *
289    * Performs some static checks, notably:
290    * - opcode of first instruction begins at index 0
291    * - only documented instructions may appear
292    * - each instruction follows the last
293    * - last byte of last instruction is at (code_length-1)
294    *
295    * Logs an error and returns "false" on failure.
296    */
297   bool ComputeWidthsAndCountOps();
298 
299   /*
300    * Set the "in try" flags for all instructions protected by "try" statements. Also sets the
301    * "branch target" flags for exception handlers.
302    *
303    * Call this after widths have been set in "insn_flags".
304    *
305    * Returns "false" if something in the exception table looks fishy, but we're expecting the
306    * exception table to be somewhat sane.
307    */
308   bool ScanTryCatchBlocks() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
309 
310   /*
311    * Perform static verification on all instructions in a method.
312    *
313    * Walks through instructions in a method calling VerifyInstruction on each.
314    */
315   bool VerifyInstructions();
316 
317   /*
318    * Perform static verification on an instruction.
319    *
320    * As a side effect, this sets the "branch target" flags in InsnFlags.
321    *
322    * "(CF)" items are handled during code-flow analysis.
323    *
324    * v3 4.10.1
325    * - target of each jump and branch instruction must be valid
326    * - targets of switch statements must be valid
327    * - operands referencing constant pool entries must be valid
328    * - (CF) operands of getfield, putfield, getstatic, putstatic must be valid
329    * - (CF) operands of method invocation instructions must be valid
330    * - (CF) only invoke-direct can call a method starting with '<'
331    * - (CF) <clinit> must never be called explicitly
332    * - operands of instanceof, checkcast, new (and variants) must be valid
333    * - new-array[-type] limited to 255 dimensions
334    * - can't use "new" on an array class
335    * - (?) limit dimensions in multi-array creation
336    * - local variable load/store register values must be in valid range
337    *
338    * v3 4.11.1.2
339    * - branches must be within the bounds of the code array
340    * - targets of all control-flow instructions are the start of an instruction
341    * - register accesses fall within range of allocated registers
342    * - (N/A) access to constant pool must be of appropriate type
343    * - code does not end in the middle of an instruction
344    * - execution cannot fall off the end of the code
345    * - (earlier) for each exception handler, the "try" area must begin and
346    *   end at the start of an instruction (end can be at the end of the code)
347    * - (earlier) for each exception handler, the handler must start at a valid
348    *   instruction
349    */
350   bool VerifyInstruction(const Instruction* inst, uint32_t code_offset);
351 
352   /* Ensure that the register index is valid for this code item. */
353   bool CheckRegisterIndex(uint32_t idx);
354 
355   /* Ensure that the wide register index is valid for this code item. */
356   bool CheckWideRegisterIndex(uint32_t idx);
357 
358   // Perform static checks on a field get or set instruction. All we do here is ensure that the
359   // field index is in the valid range.
360   bool CheckFieldIndex(uint32_t idx);
361 
362   // Perform static checks on a method invocation instruction. All we do here is ensure that the
363   // method index is in the valid range.
364   bool CheckMethodIndex(uint32_t idx);
365 
366   // Perform static checks on a "new-instance" instruction. Specifically, make sure the class
367   // reference isn't for an array class.
368   bool CheckNewInstance(uint32_t idx);
369 
370   /* Ensure that the string index is in the valid range. */
371   bool CheckStringIndex(uint32_t idx);
372 
373   // Perform static checks on an instruction that takes a class constant. Ensure that the class
374   // index is in the valid range.
375   bool CheckTypeIndex(uint32_t idx);
376 
377   // Perform static checks on a "new-array" instruction. Specifically, make sure they aren't
378   // creating an array of arrays that causes the number of dimensions to exceed 255.
379   bool CheckNewArray(uint32_t idx);
380 
381   // Verify an array data table. "cur_offset" is the offset of the fill-array-data instruction.
382   bool CheckArrayData(uint32_t cur_offset);
383 
384   // Verify that the target of a branch instruction is valid. We don't expect code to jump directly
385   // into an exception handler, but it's valid to do so as long as the target isn't a
386   // "move-exception" instruction. We verify that in a later stage.
387   // The dex format forbids certain instructions from branching to themselves.
388   // Updates "insn_flags_", setting the "branch target" flag.
389   bool CheckBranchTarget(uint32_t cur_offset);
390 
391   // Verify a switch table. "cur_offset" is the offset of the switch instruction.
392   // Updates "insn_flags_", setting the "branch target" flag.
393   bool CheckSwitchTargets(uint32_t cur_offset);
394 
395   // Check the register indices used in a "vararg" instruction, such as invoke-virtual or
396   // filled-new-array.
397   // - vA holds word count (0-5), args[] have values.
398   // There are some tests we don't do here, e.g. we don't try to verify that invoking a method that
399   // takes a double is done with consecutive registers. This requires parsing the target method
400   // signature, which we will be doing later on during the code flow analysis.
401   bool CheckVarArgRegs(uint32_t vA, uint32_t arg[]);
402 
403   // Check the register indices used in a "vararg/range" instruction, such as invoke-virtual/range
404   // or filled-new-array/range.
405   // - vA holds word count, vC holds index of first reg.
406   bool CheckVarArgRangeRegs(uint32_t vA, uint32_t vC);
407 
408   // Extract the relative offset from a branch instruction.
409   // Returns "false" on failure (e.g. this isn't a branch instruction).
410   bool GetBranchOffset(uint32_t cur_offset, int32_t* pOffset, bool* pConditional,
411                        bool* selfOkay);
412 
413   /* Perform detailed code-flow analysis on a single method. */
414   bool VerifyCodeFlow() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
415 
416   // Set the register types for the first instruction in the method based on the method signature.
417   // This has the side-effect of validating the signature.
418   bool SetTypesFromSignature() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
419 
420   /*
421    * Perform code flow on a method.
422    *
423    * The basic strategy is as outlined in v3 4.11.1.2: set the "changed" bit on the first
424    * instruction, process it (setting additional "changed" bits), and repeat until there are no
425    * more.
426    *
427    * v3 4.11.1.1
428    * - (N/A) operand stack is always the same size
429    * - operand stack [registers] contain the correct types of values
430    * - local variables [registers] contain the correct types of values
431    * - methods are invoked with the appropriate arguments
432    * - fields are assigned using values of appropriate types
433    * - opcodes have the correct type values in operand registers
434    * - there is never an uninitialized class instance in a local variable in code protected by an
435    *   exception handler (operand stack is okay, because the operand stack is discarded when an
436    *   exception is thrown) [can't know what's a local var w/o the debug info -- should fall out of
437    *   register typing]
438    *
439    * v3 4.11.1.2
440    * - execution cannot fall off the end of the code
441    *
442    * (We also do many of the items described in the "static checks" sections, because it's easier to
443    * do them here.)
444    *
445    * We need an array of RegType values, one per register, for every instruction. If the method uses
446    * monitor-enter, we need extra data for every register, and a stack for every "interesting"
447    * instruction. In theory this could become quite large -- up to several megabytes for a monster
448    * function.
449    *
450    * NOTE:
451    * The spec forbids backward branches when there's an uninitialized reference in a register. The
452    * idea is to prevent something like this:
453    *   loop:
454    *     move r1, r0
455    *     new-instance r0, MyClass
456    *     ...
457    *     if-eq rN, loop  // once
458    *   initialize r0
459    *
460    * This leaves us with two different instances, both allocated by the same instruction, but only
461    * one is initialized. The scheme outlined in v3 4.11.1.4 wouldn't catch this, so they work around
462    * it by preventing backward branches. We achieve identical results without restricting code
463    * reordering by specifying that you can't execute the new-instance instruction if a register
464    * contains an uninitialized instance created by that same instruction.
465    */
466   bool CodeFlowVerifyMethod() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
467 
468   /*
469    * Perform verification for a single instruction.
470    *
471    * This requires fully decoding the instruction to determine the effect it has on registers.
472    *
473    * Finds zero or more following instructions and sets the "changed" flag if execution at that
474    * point needs to be (re-)evaluated. Register changes are merged into "reg_types_" at the target
475    * addresses. Does not set or clear any other flags in "insn_flags_".
476    */
477   bool CodeFlowVerifyInstruction(uint32_t* start_guess)
478       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
479 
480   // Perform verification of a new array instruction
481   void VerifyNewArray(const Instruction* inst, bool is_filled, bool is_range)
482       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
483 
484   // Helper to perform verification on puts of primitive type.
485   void VerifyPrimitivePut(const RegType& target_type, const RegType& insn_type,
486                           const uint32_t vregA) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
487 
488   // Perform verification of an aget instruction. The destination register's type will be set to
489   // be that of component type of the array unless the array type is unknown, in which case a
490   // bottom type inferred from the type of instruction is used. is_primitive is false for an
491   // aget-object.
492   void VerifyAGet(const Instruction* inst, const RegType& insn_type,
493                   bool is_primitive) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
494 
495   // Perform verification of an aput instruction.
496   void VerifyAPut(const Instruction* inst, const RegType& insn_type,
497                   bool is_primitive) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
498 
499   // Lookup instance field and fail for resolution violations
500   mirror::ArtField* GetInstanceField(const RegType& obj_type, int field_idx)
501       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
502 
503   // Lookup static field and fail for resolution violations
504   mirror::ArtField* GetStaticField(int field_idx) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
505 
506   // Perform verification of an iget or sget instruction.
507   void VerifyISGet(const Instruction* inst, const RegType& insn_type,
508                    bool is_primitive, bool is_static)
509       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
510 
511   // Perform verification of an iput or sput instruction.
512   void VerifyISPut(const Instruction* inst, const RegType& insn_type,
513                    bool is_primitive, bool is_static)
514       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
515 
516   // Returns the access field of a quick field access (iget/iput-quick) or NULL
517   // if it cannot be found.
518   mirror::ArtField* GetQuickFieldAccess(const Instruction* inst, RegisterLine* reg_line)
519       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
520 
521   // Perform verification of an iget-quick instruction.
522   void VerifyIGetQuick(const Instruction* inst, const RegType& insn_type,
523                        bool is_primitive)
524       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
525 
526   // Perform verification of an iput-quick instruction.
527   void VerifyIPutQuick(const Instruction* inst, const RegType& insn_type,
528                        bool is_primitive)
529       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
530 
531   // Resolves a class based on an index and performs access checks to ensure the referrer can
532   // access the resolved class.
533   const RegType& ResolveClassAndCheckAccess(uint32_t class_idx)
534       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
535 
536   /*
537    * For the "move-exception" instruction at "work_insn_idx_", which must be at an exception handler
538    * address, determine the Join of all exceptions that can land here. Fails if no matching
539    * exception handler can be found or if the Join of exception types fails.
540    */
541   const RegType& GetCaughtExceptionType()
542       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
543 
544   /*
545    * Resolves a method based on an index and performs access checks to ensure
546    * the referrer can access the resolved method.
547    * Does not throw exceptions.
548    */
549   mirror::ArtMethod* ResolveMethodAndCheckAccess(uint32_t method_idx, MethodType method_type)
550       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
551 
552   /*
553    * Verify the arguments to a method. We're executing in "method", making
554    * a call to the method reference in vB.
555    *
556    * If this is a "direct" invoke, we allow calls to <init>. For calls to
557    * <init>, the first argument may be an uninitialized reference. Otherwise,
558    * calls to anything starting with '<' will be rejected, as will any
559    * uninitialized reference arguments.
560    *
561    * For non-static method calls, this will verify that the method call is
562    * appropriate for the "this" argument.
563    *
564    * The method reference is in vBBBB. The "is_range" parameter determines
565    * whether we use 0-4 "args" values or a range of registers defined by
566    * vAA and vCCCC.
567    *
568    * Widening conversions on integers and references are allowed, but
569    * narrowing conversions are not.
570    *
571    * Returns the resolved method on success, NULL on failure (with *failure
572    * set appropriately).
573    */
574   mirror::ArtMethod* VerifyInvocationArgs(const Instruction* inst,
575                                           MethodType method_type,
576                                           bool is_range, bool is_super)
577       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
578 
579   mirror::ArtMethod* GetQuickInvokedMethod(const Instruction* inst,
580                                            RegisterLine* reg_line,
581                                            bool is_range)
582       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
583 
584   mirror::ArtMethod* VerifyInvokeVirtualQuickArgs(const Instruction* inst, bool is_range)
585   SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
586 
587   /*
588    * Verify that the target instruction is not "move-exception". It's important that the only way
589    * to execute a move-exception is as the first instruction of an exception handler.
590    * Returns "true" if all is well, "false" if the target instruction is move-exception.
591    */
592   bool CheckNotMoveException(const uint16_t* insns, int insn_idx);
593 
594   /*
595   * Control can transfer to "next_insn". Merge the registers from merge_line into the table at
596   * next_insn, and set the changed flag on the target address if any of the registers were changed.
597   * Returns "false" if an error is encountered.
598   */
599   bool UpdateRegisters(uint32_t next_insn, const RegisterLine* merge_line)
600       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
601 
602   // Is the method being verified a constructor?
IsConstructor()603   bool IsConstructor() const {
604     return (method_access_flags_ & kAccConstructor) != 0;
605   }
606 
607   // Is the method verified static?
IsStatic()608   bool IsStatic() const {
609     return (method_access_flags_ & kAccStatic) != 0;
610   }
611 
612   // Return the register type for the method.
613   const RegType& GetMethodReturnType() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
614 
615   // Get a type representing the declaring class of the method.
616   const RegType& GetDeclaringClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
617 
618   /*
619    * Generate the GC map for a method that has just been verified (i.e. we're doing this as part of
620    * verification). For type-precise determination we have all the data we need, so we just need to
621    * encode it in some clever fashion.
622    * Returns a pointer to a newly-allocated RegisterMap, or NULL on failure.
623    */
624   const std::vector<uint8_t>* GenerateGcMap();
625 
626   // Verify that the GC map associated with method_ is well formed
627   void VerifyGcMap(const std::vector<uint8_t>& data);
628 
629   // Compute sizes for GC map data
630   void ComputeGcMapSizes(size_t* gc_points, size_t* ref_bitmap_bits, size_t* log2_max_gc_pc);
631 
632   InstructionFlags* CurrentInsnFlags();
633 
634   // All the GC maps that the verifier has created
635   typedef SafeMap<const MethodReference, const std::vector<uint8_t>*,
636       MethodReferenceComparator> DexGcMapTable;
637   static ReaderWriterMutex* dex_gc_maps_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
638   static DexGcMapTable* dex_gc_maps_ GUARDED_BY(dex_gc_maps_lock_);
639   static void SetDexGcMap(MethodReference ref, const std::vector<uint8_t>& dex_gc_map)
640       LOCKS_EXCLUDED(dex_gc_maps_lock_);
641 
642 
643   // Cast elision types.
644   typedef std::set<uint32_t> MethodSafeCastSet;
645   typedef SafeMap<const MethodReference, const MethodSafeCastSet*,
646       MethodReferenceComparator> SafeCastMap;
647   MethodVerifier::MethodSafeCastSet* GenerateSafeCastSet()
648       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
649   static void SetSafeCastMap(MethodReference ref, const MethodSafeCastSet* mscs);
650       LOCKS_EXCLUDED(safecast_map_lock_);
651   static ReaderWriterMutex* safecast_map_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
652   static SafeCastMap* safecast_map_ GUARDED_BY(safecast_map_lock_);
653 
654   // Devirtualization map.
655   typedef SafeMap<const uint32_t, MethodReference> PcToConcreteMethodMap;
656   typedef SafeMap<const MethodReference, const PcToConcreteMethodMap*,
657       MethodReferenceComparator> DevirtualizationMapTable;
658   MethodVerifier::PcToConcreteMethodMap* GenerateDevirtMap()
659       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
660 
661   static ReaderWriterMutex* devirt_maps_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
662   static DevirtualizationMapTable* devirt_maps_ GUARDED_BY(devirt_maps_lock_);
663   static void SetDevirtMap(MethodReference ref,
664                            const PcToConcreteMethodMap* pc_method_map)
665         LOCKS_EXCLUDED(devirt_maps_lock_);
666   typedef std::set<ClassReference> RejectedClassesTable;
667   static ReaderWriterMutex* rejected_classes_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
668   static RejectedClassesTable* rejected_classes_ GUARDED_BY(rejected_classes_lock_);
669 
670   static void AddRejectedClass(ClassReference ref)
671       LOCKS_EXCLUDED(rejected_classes_lock_);
672 
673   RegTypeCache reg_types_;
674 
675   PcToRegisterLineTable reg_table_;
676 
677   // Storage for the register status we're currently working on.
678   UniquePtr<RegisterLine> work_line_;
679 
680   // The address of the instruction we're currently working on, note that this is in 2 byte
681   // quantities
682   uint32_t work_insn_idx_;
683 
684   // Storage for the register status we're saving for later.
685   UniquePtr<RegisterLine> saved_line_;
686 
687   const uint32_t dex_method_idx_;  // The method we're working on.
688   // Its object representation if known.
689   mirror::ArtMethod* mirror_method_ GUARDED_BY(Locks::mutator_lock_);
690   const uint32_t method_access_flags_;  // Method's access flags.
691   const DexFile* const dex_file_;  // The dex file containing the method.
692   // The dex_cache for the declaring class of the method.
693   mirror::DexCache* dex_cache_ GUARDED_BY(Locks::mutator_lock_);
694   // The class loader for the declaring class of the method.
695   mirror::ClassLoader* class_loader_ GUARDED_BY(Locks::mutator_lock_);
696   const DexFile::ClassDef* const class_def_;  // The class def of the declaring class of the method.
697   const DexFile::CodeItem* const code_item_;  // The code item containing the code for the method.
698   const RegType* declaring_class_;  // Lazily computed reg type of the method's declaring class.
699   // Instruction widths and flags, one entry per code unit.
700   UniquePtr<InstructionFlags[]> insn_flags_;
701   // The dex PC of a FindLocksAtDexPc request, -1 otherwise.
702   uint32_t interesting_dex_pc_;
703   // The container into which FindLocksAtDexPc should write the registers containing held locks,
704   // NULL if we're not doing FindLocksAtDexPc.
705   std::vector<uint32_t>* monitor_enter_dex_pcs_;
706 
707   // The types of any error that occurs.
708   std::vector<VerifyError> failures_;
709   // Error messages associated with failures.
710   std::vector<std::ostringstream*> failure_messages_;
711   // Is there a pending hard failure?
712   bool have_pending_hard_failure_;
713   // Is there a pending runtime throw failure? A runtime throw failure is when an instruction
714   // would fail at runtime throwing an exception. Such an instruction causes the following code
715   // to be unreachable. This is set by Fail and used to ensure we don't process unreachable
716   // instructions that would hard fail the verification.
717   bool have_pending_runtime_throw_failure_;
718 
719   // Info message log use primarily for verifier diagnostics.
720   std::ostringstream info_messages_;
721 
722   // The number of occurrences of specific opcodes.
723   size_t new_instance_count_;
724   size_t monitor_enter_count_;
725 
726   const bool can_load_classes_;
727 
728   // Converts soft failures to hard failures when false. Only false when the compiler isn't
729   // running and the verifier is called from the class linker.
730   const bool allow_soft_failures_;
731 
732   // Indicates if the method being verified contains at least one check-cast instruction.
733   bool has_check_casts_;
734 
735   // Indicates if the method being verified contains at least one invoke-virtual/range
736   // or invoke-interface/range.
737   bool has_virtual_or_interface_invokes_;
738 };
739 std::ostream& operator<<(std::ostream& os, const MethodVerifier::FailureKind& rhs);
740 
741 }  // namespace verifier
742 }  // namespace art
743 
744 #endif  // ART_RUNTIME_VERIFIER_METHOD_VERIFIER_H_
745