Lines Matching full:instruction
76 void AddInstruction(HInstruction* instruction);
77 void RemoveInstruction(HInstruction* instruction);
79 // Insert `instruction` before/after an existing instruction `cursor`.
80 void InsertInstructionBefore(HInstruction* instruction, HInstruction* cursor);
81 void InsertInstructionAfter(HInstruction* instruction, HInstruction* cursor);
83 // Return true if this list contains `instruction`.
84 bool Contains(HInstruction* instruction) const;
87 // this instruction list and false otherwise. Abort if none
185 // Inline this graph in `outer_graph`, replacing the given `invoke` instruction.
310 // If not found or previously deleted, create and cache a new instruction.
319 void InsertConstant(HConstant* instruction);
362 // The current id to assign to a newly added instruction. See HInstruction.id_.
452 // removed as well as its SuspendCheck instruction. It must be run on nested
652 // like predecessors, successors, dominators, and instruction list. It does not
654 // blocks are consistent (for example ending with a control flow instruction).
661 // with a control flow instruction).
668 // with a control flow instruction).
683 void AddInstruction(HInstruction* instruction);
684 // Insert `instruction` before/after an existing instruction `cursor`.
685 void InsertInstructionBefore(HInstruction* instruction, HInstruction* cursor);
686 void InsertInstructionAfter(HInstruction* instruction, HInstruction* cursor);
687 // Replace instruction `initial` with `replacement` within this block.
691 void InsertPhiAfter(HPhi* instruction, HPhi* cursor);
692 // RemoveInstruction and RemovePhi delete a given instruction from the respective
693 // instruction list. With 'ensure_safety' set to true, it verifies that the
694 // instruction is not in use and removes it from the use lists of its inputs.
695 void RemoveInstruction(HInstruction* instruction, bool ensure_safety = true);
697 void RemoveInstructionOrPhi(HInstruction* instruction, bool ensure_safety = true);
768 // The dex program counter of the first instruction of this block.
808 M(ArrayGet, Instruction) \
809 M(ArrayLength, Instruction) \
810 M(ArraySet, Instruction) \
812 M(BoundsCheck, Instruction) \
813 M(BoundType, Instruction) \
814 M(CheckCast, Instruction) \
815 M(ClinitCheck, Instruction) \
818 M(Deoptimize, Instruction) \
820 M(DivZeroCheck, Instruction) \
823 M(Exit, Instruction) \
825 M(Goto, Instruction) \
828 M(If, Instruction) \
829 M(InstanceFieldGet, Instruction) \
830 M(InstanceFieldSet, Instruction) \
831 M(InstanceOf, Instruction) \
838 M(LoadClass, Instruction) \
839 M(LoadException, Instruction) \
840 M(LoadLocal, Instruction) \
841 M(LoadString, Instruction) \
842 M(Local, Instruction) \
844 M(MemoryBarrier, Instruction) \
845 M(MonitorOperation, Instruction) \
848 M(NewArray, Instruction) \
849 M(NewInstance, Instruction) \
852 M(NullConstant, Instruction) \
853 M(NullCheck, Instruction) \
855 M(ParallelMove, Instruction) \
856 M(ParameterValue, Instruction) \
857 M(Phi, Instruction) \
859 M(Return, Instruction) \
860 M(ReturnVoid, Instruction) \
863 M(StaticFieldGet, Instruction) \
864 M(StaticFieldSet, Instruction) \
865 M(StoreLocal, Instruction) \
867 M(SuspendCheck, Instruction) \
868 M(Temporary, Instruction) \
869 M(Throw, Instruction) \
870 M(TypeConversion, Instruction) \
876 M(Constant, Instruction) \
877 M(UnaryOperation, Instruction) \
878 M(BinaryOperation, Instruction) \
879 M(Invoke, Instruction)
1024 explicit HUserRecord(HInstruction* instruction) : instruction_(instruction), use_node_(nullptr) {}
1037 // Instruction used by the user.
1050 // Represents the side effects an instruction may have.
1158 void SetRawEnvAt(size_t index, HInstruction* instruction) {
1159 vregs_.Put(index, HUserRecord<HEnvironment*>(instruction));
1339 LOG(FATAL) << "GetDexPc() cannot be called on an instruction that"
1398 // Does this instruction strictly dominate `other_instruction`?
1399 // Returns false if this instruction and `other_instruction` are the same.
1400 // Aborts if this instruction and `other_instruction` are both phis.
1416 // Set the environment of this instruction, copying it from `environment`. While
1454 void ReplaceWith(HInstruction* instruction);
1458 // uses of this instruction by `other` are *not* updated.
1464 // Move `this` instruction before `cursor`.
1475 // Returns whether the instruction can be moved within the graph.
1517 // Returns whether the code generation of the instruction will require to have access
1540 // An instruction gets an id when it is added to the graph.
1541 // It reflects creation order. A negative id means the instruction
1548 // List of instructions that have this instruction as input.
1551 // List of environments that contain this instruction.
1554 // The environment associated with this instruction. Not null if the instruction
1565 // order of blocks where this instruction's live interval start.
1585 explicit HInputIterator(HInstruction* instruction) : instruction_(instruction), index_(0) {}
1723 // instruction that branches to the exit block.
1737 // instruction that branches to the exit block.
1752 // The exit instruction is the only instruction of the exit block.
1785 // Conditional branch. A block ending with an HIf instruction must have
1889 // Order inputs by instruction id, but favor constant on the right side.
1901 instruction id.
1946 // For code generation purposes, returns whether this instruction is just before
1947 // `instruction`, and disregard moves in between.
1948 bool IsBeforeWhenDisregardMoves(HInstruction* instruction) const;
1955 // For register allocation purposes, returns whether this instruction needs to be
1962 // Instruction to check if two inputs are equal to each other.
2100 // Instruction to check how two inputs compare to each other.
2170 // Load a given local. The local is an input of this instruction.
2186 // Store a value in a given local. This instruction has two inputs: the value
2313 // synthesized (for example with the if-eqz instruction).
2490 // Is this instruction a call to a static method?
2495 // Remove the art::HLoadClass instruction set as last input by
2497 // the initial art::HClinitCheck instruction (only relevant for
2532 // - an art::HClinitCheck instruction, set by art::HGraphBuilder; or
2533 // - an art::HLoadClass instruction, set by art::PrepareForRegisterAllocation.
3313 // Note that arrays do not change length, so the instruction does not
3367 * instruction (the actual offset is computed as index * vreg_size).
3376 // The previous instruction is the one that will be stored in the temporary location.
3415 * Instruction to load a Class object.
3488 // Whether this instruction must generate the initialization check.
3626 // Implement the move-exception DEX instruction.
3721 // Encodes the most upper class that this instruction can have. In other words
3750 // Instruction may throw a CheckCastError.
3801 // Instruction may throw a Java exception, so we need an environment.
3824 HInstruction* instruction)
3825 : source_(source), destination_(destination), type_(type), instruction_(instruction) {}
3886 // The instruction this move is assocatied with. Null when this move is
3903 HInstruction* instruction) {
3907 if (instruction != nullptr) {
3909 if (moves_.Get(i).GetInstruction() == instruction) {
3911 // of the instruction.
3912 if ((GetPrevious() == instruction)
3914 && instruction->IsPhi()
3915 && instruction->GetBlock() == GetBlock())) {
3917 << "Doing parallel moves for the same instruction.";
3919 DCHECK(false) << "Doing parallel moves for the same instruction.";
3929 moves_.Add(MoveOperands(source, destination, type, instruction));
3951 virtual void VisitInstruction(HInstruction* instruction) { UNUSED(instruction); }
3962 // Visit functions for instruction classes.
