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