Lines Matching full:eflags
2430 if (MO.isRegMask() && MO.clobbersPhysReg(X86::EFLAGS))
2434 if (MO.getReg() == X86::EFLAGS) {
2442 // This instruction defines EFLAGS, no need to look any further.
2450 // It is safe to clobber EFLAGS at the end of a block of no successor has it
2454 if (S->isLiveIn(X86::EFLAGS))
2463 // EFLAGS iff EFLAGS is not live-in.
2465 return !MBB.isLiveIn(X86::EFLAGS);
2475 // A register mask may clobber EFLAGS
2476 // live EFLAGS def.
2477 if (MO.isRegMask() && MO.clobbersPhysReg(X86::EFLAGS))
2479 if (MO.isReg() && MO.getReg() == X86::EFLAGS) {
2486 // This instruction kills EFLAGS and doesn't redefine it, so
2502 if (MO.isReg() && MO.isDef() && MO.getReg() == X86::EFLAGS) {
2509 // The instruction clobbers EFLAGS. Re-materialize as MOV32ri to avoid side
2533 /// True if MI has a condition code def, e.g. EFLAGS, that is not marked dead.
2538 MO.getReg() == X86::EFLAGS && !MO.isDead()) {
4154 if (I->modifiesRegister(X86::EFLAGS, TRI)) {
4159 if (I->readsRegister(X86::EFLAGS, TRI))
4168 if (Succ->isLiveIn(X86::EFLAGS))
4490 bool FromEFLAGS = SrcReg == X86::EFLAGS;
4491 bool ToEFLAGS = DestReg == X86::EFLAGS;
4507 // Moving EFLAGS to / from another register requires a push and a pop.
4522 // The flags need to be saved, but saving EFLAGS with PUSHF/POPF is
4526 // - Save/restore the bottom 8 EFLAGS bits (CF, PF, AF, ZF, SF) to/from AH
4534 // actually live inside EFLAGS. Were we able to do a single SETcc instead of
5105 // EFLAGS. If MI is not in the same BB as CmpInstr, do not optimize.
5111 // instruction we can eliminate the compare iff the use sets EFLAGS in the
5123 assert(J->definesRegister(X86::EFLAGS) && "Must be an EFLAGS def!");
5125 // This is not a def of SrcReg, but still a def of EFLAGS. Keep going
5162 if (Instr.modifiesRegister(X86::EFLAGS, TRI) ||
5163 Instr.readsRegister(X86::EFLAGS, TRI)) {
5164 // This instruction modifies or uses EFLAGS.
5167 // They are safe to move up, if the definition to EFLAGS is dead and
5168 // earlier instructions do not read or write EFLAGS.
5170 Instr.registerDefIsDead(X86::EFLAGS, TRI)) {
5187 // Scan forward from the instruction after CmpInstr for uses of EFLAGS.
5188 // It is safe to remove CmpInstr if EFLAGS is redefined or killed.
5189 // If we are done with the basic block, we need to check whether EFLAGS is
5196 bool ModifyEFLAGS = Instr.modifiesRegister(X86::EFLAGS, TRI);
5197 bool UseEFLAGS = Instr.readsRegister(X86::EFLAGS, TRI);
5198 // We should check the usage if this instruction uses and updates EFLAGS.
5200 // It is safe to remove CmpInstr if EFLAGS is updated again.
5207 // EFLAGS is used by this instruction.
5274 if (ModifyEFLAGS || Instr.killsRegister(X86::EFLAGS, TRI)) {
5275 // It is safe to remove CmpInstr if EFLAGS is updated again or killed.
5281 // If EFLAGS is not killed nor re-defined, we should check whether it is
5286 if (Successor->isLiveIn(X86::EFLAGS))
5294 // Look backwards until we find a def that doesn't use the current EFLAGS.
5301 if (!Instr->readsRegister(X86::EFLAGS, TRI) &&
5302 Instr->modifiesRegister(X86::EFLAGS, TRI)) {
5313 // Make sure Sub instruction defines EFLAGS and mark the def live.
5317 if (MO.isReg() && MO.isDef() && MO.getReg() == X86::EFLAGS) {
5322 EFLAGS operand");
7196 // the EFLAGS register. That operand must be both defined here and never
7197 // used; ie, it must be dead. If the EFLAGS operand is live, then we can
7203 Inst.getOperand(3).getReg() == X86::EFLAGS &&
7298 // Integer instructions define an implicit EFLAGS source register operand as
7311 assert(OldOp1.isReg() && OldOp1.getReg() == X86::EFLAGS && OldOp1.isDead() &&
7312 "Must have dead EFLAGS operand in reassociable instruction");
7313 assert(OldOp2.isReg() && OldOp2.getReg() == X86::EFLAGS && OldOp2.isDead() &&
7314 "Must have dead EFLAGS operand in reassociable instruction");
7319 assert(NewOp1.isReg() && NewOp1.getReg() == X86::EFLAGS &&
7321 assert(NewOp2.isReg() && NewOp2.getReg() == X86::EFLAGS &&
7324 // Mark the new EFLAGS operands as dead to be helpful to subsequent iterations
7325 // of this pass or other passes. The EFLAGS operands must be dead in these new
7326 // instructions because the EFLAGS operands in the original instructions must
