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