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