Lines Matching full:instruction
1 //===-- TwoAddressInstructionPass.cpp - Two-Address instruction pass ------===//
10 // This file implements the TwoAddress instruction pass which is used
26 // address instruction is removed.
170 "Two-Address instruction pass", false, false)
173 "Two-Address instruction pass", false, false)
179 /// sink3AddrInstruction - A two-address instruction has been converted to a
180 /// three-address instruction to avoid clobbering a register. Try to sink it
181 /// past the instruction that would kill the above mentioned register to reduce
187 // instruction? After this transformation is done, we no longer need
188 // the instruction to be in three-address form.
190 // Check if it's safe to move this instruction.
218 // Find the instruction that kills SavedReg.
245 // If we find the instruction that kills SavedReg, and it is in an
246 // appropriate location, we can try to sink the current instruction
252 // If any of the definitions are used by another instruction between the
256 // instruction is before or after another instruction. Then we can use
304 // Move instruction to its destination.
355 /// last instruction in the MBB that defines the specified register and the
356 /// two-address instruction which is being processed. It also returns the last
378 /// isCopyToReg - Return true if the specified MI is a copy instruction or
379 /// a extract_subreg instruction. It also returns the source and destination
401 // given instruction, is killed by the given instruction.
409 // If there is no interval available, we assume that this instruction is
428 /// instruction, is killed by the given instruction. This looks through
492 /// use, return the use instruction if it's a copy or a two-address use.
547 /// the two-address instruction that's being processed.
555 // Determine if it's profitable to commute this two address instruction. In
556 // general, we want no uses between this instruction and the definition of
565 // instruction if the first one is coalesced. So it would be profitable to
608 // instruction, then bail.
614 // instruction, then go ahead and make this transformation.
632 // instruction pass should be integrated with register allocation pass where
645 /// commuteInstruction - Commute a two-address instruction and update the basic
663 "instruction unless it was requested.");
676 /// given 2-address instruction to a 3-address one.
684 // Turn ADD into a 3-address instruction to avoid a copy.
692 /// convertInstTo3Addr - Convert the specified two-address instruction into a
714 // FIXME: Temporary workaround. If the new instruction doesn't
716 // then one instruction.
734 /// is a copy or a two-address instruction.
780 /// processCopy - If the specified instruction is not yet processed, process it
781 /// if it's a copy. For a copy instruction, we find the physical registers the
788 /// If 'add' is a two-address instruction, v1024, v1026 are both potentially
816 /// rescheduleMIBelowKill - If there is one more local instruction that reads
817 /// 'Reg' and it kills 'Reg, consider moving the instruction below the kill
818 /// instruction in order to eliminate the need for the copy.
930 // FIXME: This may be too conservative. It's ok if the instruction
988 /// instruction too close to the defs of its register dependencies.
1007 /// rescheduleKillAboveMI - If there is one more local instruction that reads
1008 /// 'Reg' and it kills 'Reg, consider moving the kill instruction above the
1009 /// current two-address instruction in order to eliminate the need for the
1158 /// tryInstructionTransform - For the case where an instruction has a single
1164 /// shouldOnlyCommute flag is true, only instruction commutation is attempted.
1178 "cannot make instruction into two-address form");
1229 // This instruction is potentially convertible to a true
1230 // three-address instruction. Check if it is profitable.
1235 return true; // Done with this instruction.
1247 // If this is an instruction with a load folded into it, try unfolding
1292 // Transform the instruction, now that it no longer has a load.
1389 assert(SrcReg && SrcMO.isUse() && "two address instruction invalid");
1433 // Grab RegB from the instruction because it may have changed if the
1434 // instruction was commuted.
1448 "cannot make instruction into two-address form");
1451 // First, verify that we don't have a use of "a" in the instruction
1562 // regB is still used in this instruction, but a kill flag was
1616 // expanded instruction.
1624 // First scan through all the tied register uses in this instruction
1635 // If the instruction has a single pair of tied operands, try some
1686 MF->verify(this, "After two-address instruction pass");
1691 /// Eliminate a REG_SEQUENCE instruction as part of the de-ssa process.
1693 /// The instruction is turned into a sequence of sub-register copies:
1709 DEBUG(dbgs() << "Illegal REG_SEQUENCE instruction:" << *MI);
