Lines Matching full:instruction
55 * A live range contains the start and end of a range where an instruction or a temporary
172 explicit SafepointPosition(HInstruction* instruction)
173 : instruction_(instruction),
204 * An interval is a list of disjoint live ranges where an instruction is live.
205 * Each instruction that has uses gets an interval.
211 HInstruction* instruction = nullptr) {
212 return new (allocator) LiveInterval(allocator, type, instruction);
215 static LiveInterval* MakeSlowPathInterval(ArenaAllocator* allocator, HInstruction* instruction) {
217 allocator, Primitive::kPrimVoid, instruction, false, kNoRegister, false, true);
234 void AddTempUse(HInstruction* instruction, size_t temp_index) {
238 size_t position = instruction->GetLifetimePosition();
240 instruction, /* environment */ nullptr, temp_index, position, first_use_);
244 void AddUse(HInstruction* instruction,
248 // Set the use within the instruction.
250 size_t position = instruction->GetLifetimePosition() + 1;
251 LocationSummary* locations = instruction->GetLocations();
255 // requires to have inputs die at the instruction, so that input moves use the
256 // location of the input just before that instruction (and not potential moves due
258 position = instruction->GetLifetimePosition();
264 if (!is_environment && instruction->IsInLoop()) {
265 AddBackEdgeUses(*instruction->GetBlock());
268 DCHECK(position == instruction->GetLifetimePosition()
269 || position == instruction->GetLifetimePosition() + 1);
272 && (first_use_->GetUser() == instruction)
274 // The user uses the instruction multiple times, and one use dies before the other.
283 instruction, environment, input_index, position, cursor->GetNext());
293 instruction, environment, input_index, position, first_env_use_);
296 instruction, environment, input_index, position, first_use_);
300 // If this environment use does not keep the instruction live, it does not
301 // affect the live range of that instruction.
305 size_t start_block_position = instruction->GetBlock()->GetLifetimeStart();
329 void AddPhiUse(HInstruction* instruction, size_t input_index, HBasicBlock* block) {
330 DCHECK(instruction->IsPhi());
335 instruction, /* environment */ nullptr, input_index, block->GetLifetimeEnd(), first_use_);
394 // Instruction without uses.
840 void AddSafepoint(HInstruction* instruction) {
841 SafepointPosition* safepoint = new (allocator_) SafepointPosition(instruction);
919 // This interval is the first interval of the instruction. If the output
920 // of the instruction requires a register, we return the position of that instruction
1035 // The instruction type this interval corresponds to.
1066 // The instruction represented by this interval.
1080 * (a) Non-environment uses of an instruction always make
1081 * the instruction live.
1082 * (b) Environment uses of an instruction whose type is
1083 * object (that is, non-primitive), make the instruction live.
1087 * of an instruction that has a primitive type make the instruction live.
1128 HInstruction* instruction = GetInstructionFromPosition(index);
1129 if (instruction == nullptr) {
1131 instruction = GetInstructionFromPosition(index + 1);
1133 return instruction->GetBlock();
1141 // A temporary shares the same lifetime start as the instruction that requires it.
1171 // Give an SSA number to each instruction that defines a value used by another instruction,
1172 // and setup the lifetime information of each instruction and block.
1193 // Returns whether `instruction` in an HEnvironment held by `env_holder`
1196 HInstruction* instruction) {
1197 if (instruction == nullptr) return false;
1201 if (instruction->GetBlock()->GetGraph()->IsDebuggable()) return true;
1202 return instruction->GetType() == Primitive::kPrimNot;
