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