Lines Matching full:instruction
88 * Identifies the type of reference in the instruction that generated the verify error
110 // execution of that instruction.
118 // Initialize the RegisterTable. Every instruction address can have a different set of information
186 // Dump the state of the verifier, namely each instruction, what flags are set on it, register
206 // Returns the accessed field corresponding to the quick instruction's field
211 // Returns the invoked method corresponding to the quick instruction's vtable
258 * (1) Walk through all code units, determining instruction locations,
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
290 * - opcode of first instruction begins at index 0
292 * - each instruction follows the last
293 * - last byte of last instruction is at (code_length-1)
318 * Perform static verification on an instruction.
325 * - target of each jump and branch instruction must be valid
340 * - targets of all control-flow instructions are the start of an instruction
343 * - code does not end in the middle of an instruction
346 * end at the start of an instruction (end can be at the end of the code)
348 * instruction
350 bool VerifyInstruction(const Instruction* inst, uint32_t code_offset);
358 // Perform static checks on a field get or set instruction. All we do here is ensure that the
362 // Perform static checks on a method invocation instruction. All we do here is ensure that the
366 // Perform static checks on a "new-instance" instruction. Specifically, make sure the class
373 // Perform static checks on an instruction that takes a class constant. Ensure that the class
377 // Perform static checks on a "new-array" instruction. Specifically, make sure they aren't
381 // Verify an array data table. "cur_offset" is the offset of the fill-array-data instruction.
384 // Verify that the target of a branch instruction is valid. We don't expect code to jump directly
386 // "move-exception" instruction. We verify that in a later stage.
391 // Verify a switch table. "cur_offset" is the offset of the switch instruction.
395 // Check the register indices used in a "vararg" instruction, such as invoke-virtual or
403 // Check the register indices used in a "vararg/range" instruction, such as invoke-virtual/range
408 // Extract the relative offset from a branch instruction.
409 // Returns "false" on failure (e.g. this isn't a branch instruction).
416 // Set the register types for the first instruction in the method based on the method signature.
424 * instruction, process it (setting additional "changed" bits), and repeat until there are no
445 * We need an array of RegType values, one per register, for every instruction. If the method uses
447 * instruction. In theory this could become quite large -- up to several megabytes for a monster
460 * This leaves us with two different instances, both allocated by the same instruction, but only
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.
469 * Perform verification for a single instruction.
471 * This requires fully decoding the instruction to determine the effect it has on registers.
480 // Perform verification of a new array instruction
481 void VerifyNewArray(const Instruction* inst, bool is_filled, bool is_range)
488 // Perform verification of an aget instruction. The destination register's type will be set to
490 // bottom type inferred from the type of instruction is used. is_primitive is false for an
492 void VerifyAGet(const Instruction* inst, const RegType& insn_type,
495 // Perform verification of an aput instruction.
496 void VerifyAPut(const Instruction* inst, const RegType& insn_type,
506 // Perform verification of an iget or sget instruction.
507 void VerifyISGet(const Instruction* inst, const RegType& insn_type,
511 // Perform verification of an iput or sput instruction.
512 void VerifyISPut(const Instruction* inst, const RegType& insn_type,
518 mirror::ArtField* GetQuickFieldAccess(const Instruction* inst, RegisterLine* reg_line)
521 // Perform verification of an iget-quick instruction.
522 void VerifyIGetQuick(const Instruction* inst, const RegType& insn_type,
526 // Perform verification of an iput-quick instruction.
527 void VerifyIPutQuick(const Instruction* inst, const RegType& insn_type,
537 * For the "move-exception" instruction at "work_insn_idx_", which must be at an exception handler
574 mirror::ArtMethod* VerifyInvocationArgs(const Instruction* inst,
579 mirror::ArtMethod* GetQuickInvokedMethod(const Instruction* inst,
584 mirror::ArtMethod* VerifyInvokeVirtualQuickArgs(const Instruction* inst, bool is_range)
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.
680 // The address of the instruction we're currently working on, note that this is in 2 byte
699 // Instruction widths and flags, one entry per code unit.
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
732 // Indicates if the method being verified contains at least one check-cast instruction.
