Lines Matching full:instruction
112 HInstruction* instruction = inst_it.Current();
113 DCHECK_LE(current_liveness, instruction->GetLifetimePosition());
114 current_liveness = instruction->GetLifetimePosition();
119 HInstruction* instruction = inst_it.Current();
120 DCHECK_LE(current_liveness, instruction->GetLifetimePosition()) << instruction->DebugName();
121 current_liveness = instruction->GetLifetimePosition();
201 void RegisterAllocator::ProcessInstruction(HInstruction* instruction) {
202 LocationSummary* locations = instruction->GetLocations();
203 size_t position = instruction->GetLifetimePosition();
219 interval->AddTempUse(instruction, i);
228 interval->AddTempUse(instruction, i);
246 bool core_register = (instruction->GetType() != Primitive::kPrimDouble)
247 && (instruction->GetType() != Primitive::kPrimFloat);
254 DCHECK(instruction->IsSuspendCheckEntry());
255 instruction->GetBlock()->RemoveInstruction(instruction);
258 safepoints_.Add(instruction);
268 LiveInterval* interval = LiveInterval::MakeSlowPathInterval(allocator_, instruction);
293 for (size_t i = 0; i < instruction->InputCount(); ++i) {
303 LiveInterval* current = instruction->GetLiveInterval();
325 // The safepoint is for this instruction, so the location of the instruction
328 DCHECK_EQ(safepoint, instruction);
380 if (current->HasSpillSlot() || instruction->IsConstant()) {
393 instruction may have been added, and those can be
431 HInstruction* instruction = liveness_.GetInstructionFromSsaIndex(i);
432 if (ShouldProcess(processing_core_registers_, instruction->GetLiveInterval())) {
433 intervals.Add(instruction->GetLiveInterval());
671 // Note that the same instruction may occur multiple times in the input list,
710 // An interval that starts an instruction (that is, it is not split), may
993 // If we're allocating a register for `current` because the instruction at
1003 // If the first use of that instruction is after the last use of the found
1121 * Non-linear control flow will force moves at every branch instruction to the new location.
1204 // An instruction gets a spill slot for its entire lifetime. If the parent
1298 HInstruction* instruction,
1304 move->AddMove(source.ToLow(), destination.ToLow(), Primitive::kPrimInt, instruction);
1307 move->AddMove(source, destination, type, instruction);
1343 HInstruction* instruction,
1356 // Move must happen before the first instruction of the block.
1359 // ask for the first instruction of the block: `GetInstructionFromPosition` does
1365 // Since this is a different lifetime position, we need to go to the next instruction.
1381 // Move must happen after the instruction.
1392 // Move must happen before the instruction.
1399 // move instruction that precedes `instruction`.
1411 AddMove(move, source, destination, instruction, instruction->GetType());
1415 HInstruction* instruction,
1441 AddMove(move, source, destination, instruction, instruction->GetType());
1445 HInstruction* instruction,
1461 AddMove(move, source, destination, instruction, instruction->GetType());
1464 void RegisterAllocator::InsertMoveAfter(HInstruction* instruction,
1470 if (instruction->IsPhi()) {
1471 InsertParallelMoveAtEntryOf(instruction->GetBlock(), instruction, source, destination);
1475 size_t position = instruction->GetLifetimePosition() + 1;
1476 HParallelMove* move = instruction->GetNext()->AsParallelMove();
1477 // This is a parallel move for moving the output of an instruction. We need
1483 instruction->GetBlock()->InsertInstructionBefore(move, instruction->GetNext());
1485 AddMove(move, source, destination, instruction, instruction->GetType());
1669 HInstruction* instruction = liveness_.GetInstructionFromSsaIndex(i);
1670 LiveInterval* current = instruction->GetLiveInterval();
1671 LocationSummary* locations = instruction->GetLocations();
1673 if (instruction->IsParameterValue()) {
1739 HInstruction* instruction = liveness_.GetInstructionFromSsaIndex(i);
1740 ConnectSiblings(instruction->GetLiveInterval());
