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