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