Index: llvm/include/llvm/CodeGen/MachineBasicBlock.h =================================================================== --- llvm/include/llvm/CodeGen/MachineBasicBlock.h +++ llvm/include/llvm/CodeGen/MachineBasicBlock.h @@ -457,6 +457,13 @@ /// Replace successor OLD with NEW and update probability info. void replaceSuccessor(MachineBasicBlock *Old, MachineBasicBlock *New); + /// Copy a successor (and any probability info) from original block to this + /// block's. Uses an iterator into the original blocks successors. + /// + /// This is useful when doing a partial clone of successors. Afterward, the + /// probabilities may need to be normalized. + void copySuccessor(MachineBasicBlock *Orig, succ_iterator I); + /// Transfers all the successors from MBB to this machine basic block (i.e., /// copies all the successors FromMBB and remove all the successors from /// FromMBB). Index: llvm/lib/CodeGen/MachineBasicBlock.cpp =================================================================== --- llvm/lib/CodeGen/MachineBasicBlock.cpp +++ llvm/lib/CodeGen/MachineBasicBlock.cpp @@ -720,6 +720,14 @@ removeSuccessor(OldI); } +void MachineBasicBlock::copySuccessor(MachineBasicBlock *Orig, + succ_iterator I) { + if (Orig->Probs.empty()) + addSuccessor(*I, Orig->getSuccProbability(I)); + else + addSuccessorWithoutProb(*I); +} + void MachineBasicBlock::addPredecessor(MachineBasicBlock *Pred) { Predecessors.push_back(Pred); } Index: llvm/lib/Target/X86/CMakeLists.txt =================================================================== --- llvm/lib/Target/X86/CMakeLists.txt +++ llvm/lib/Target/X86/CMakeLists.txt @@ -33,6 +33,7 @@ X86FixupLEAs.cpp X86AvoidStoreForwardingBlocks.cpp X86FixupSetCC.cpp + X86FlagsCopyLowering.cpp X86FloatingPoint.cpp X86FrameLowering.cpp X86InstructionSelector.cpp Index: llvm/lib/Target/X86/X86.h =================================================================== --- llvm/lib/Target/X86/X86.h +++ llvm/lib/Target/X86/X86.h @@ -73,6 +73,9 @@ /// Return a pass that avoids creating store forward block issues in the hardware. FunctionPass *createX86AvoidStoreForwardingBlocks(); +/// Return a pass that lowers EFLAGS copy pseudo instructions. +FunctionPass *createX86FlagsCopyLoweringPass(); + /// Return a pass that expands WinAlloca pseudo-instructions. FunctionPass *createX86WinAllocaExpander(); Index: llvm/lib/Target/X86/X86FlagsCopyLowering.cpp =================================================================== --- /dev/null +++ llvm/lib/Target/X86/X86FlagsCopyLowering.cpp @@ -0,0 +1,719 @@ +//====- X86FlagsCopyLowering.cpp - Lowers COPY nodes of EFLAGS ------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// \file +/// +/// Lowers COPY nodes of EFLAGS by directly extracting and preserving individual +/// flag bits. +/// +/// We have to do this by carefully analyzing and rewriting the usage of the +/// copied EFLAGS register because there is no general way to rematerialize the +/// entire EFLAGS register safely and efficiently. Using `popf` both forces +/// dynamic stack adjustment and can create correctness issues due to IF, TF, +/// and other non-status flags being overwritten. Using sequences involving +/// SAHF don't work on all x86 processors and are often quite slow compared to +/// directly testing a single status preserved in its own GPR. +/// +//===----------------------------------------------------------------------===// + +#include "X86.h" +#include "X86InstrBuilder.h" +#include "X86InstrInfo.h" +#include "X86Subtarget.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/ScopeExit.h" +#include "llvm/ADT/SmallPtrSet.h" +#include "llvm/ADT/SmallSet.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/ADT/SparseBitVector.h" +#include "llvm/ADT/Statistic.h" +#include "llvm/CodeGen/MachineBasicBlock.h" +#include "llvm/CodeGen/MachineConstantPool.h" +#include "llvm/CodeGen/MachineFunction.h" +#include "llvm/CodeGen/MachineFunctionPass.h" +#include "llvm/CodeGen/MachineInstr.h" +#include "llvm/CodeGen/MachineInstrBuilder.h" +#include "llvm/CodeGen/MachineModuleInfo.h" +#include "llvm/CodeGen/MachineOperand.h" +#include "llvm/CodeGen/MachineRegisterInfo.h" +#include "llvm/CodeGen/MachineSSAUpdater.h" +#include "llvm/CodeGen/TargetInstrInfo.h" +#include "llvm/CodeGen/TargetRegisterInfo.h" +#include "llvm/CodeGen/TargetSchedule.h" +#include "llvm/CodeGen/TargetSubtargetInfo.h" +#include "llvm/IR/DebugLoc.h" +#include "llvm/MC/MCSchedule.h" +#include "llvm/Pass.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/raw_ostream.h" +#include +#include +#include +#include + +using namespace llvm; + +#define PASS_KEY "x86-flags-copy-lowering" +#define DEBUG_TYPE PASS_KEY + +STATISTIC(NumCopiesEliminated, "Number of copies of EFLAGS eliminated"); +STATISTIC(NumSetCCsInserted, "Number of setCC instructions inserted"); +STATISTIC(NumTestsInserted, "Number of test instructions inserted"); +STATISTIC(NumAddsInserted, "Number of adds instructions inserted"); + +namespace llvm { + +void initializeX86FlagsCopyLoweringPassPass(PassRegistry &); + +} // end namespace llvm + +namespace { + +// Convenient array type for storing registers associated with each condition. +using CondRegArray = std::array; + +class X86FlagsCopyLoweringPass : public MachineFunctionPass { +public: + X86FlagsCopyLoweringPass() : MachineFunctionPass(ID) { + initializeX86FlagsCopyLoweringPassPass(*PassRegistry::getPassRegistry()); + } + + StringRef getPassName() const override { return "X86 EFLAGS copy lowering"; } + bool runOnMachineFunction(MachineFunction &MF) override; + void getAnalysisUsage(AnalysisUsage &AU) const override; + + /// Pass identification, replacement for typeid. + static char ID; + +private: + MachineRegisterInfo *MRI; + const X86InstrInfo *TII; + const TargetRegisterInfo *TRI; + const TargetRegisterClass *PromoteRC; + + CondRegArray collectCondsInRegs(MachineBasicBlock &MBB, MachineInstr &CopyDefI); + + unsigned promoteCondToReg(MachineBasicBlock &MBB, + MachineBasicBlock::iterator TestPos, + DebugLoc TestLoc, X86::CondCode Cond); + std::pair + getCondOrInverseInReg(MachineBasicBlock &TestMBB, + MachineBasicBlock::iterator TestPos, DebugLoc TestLoc, + X86::CondCode Cond, CondRegArray &CondRegs); + void insertTest(MachineBasicBlock &MBB, MachineBasicBlock::iterator Pos, + DebugLoc Loc, unsigned Reg); + + void rewriteArithmetic(MachineBasicBlock &TestMBB, + MachineBasicBlock::iterator TestPos, DebugLoc TestLoc, + MachineInstr &MI, MachineOperand &FlagUse, + CondRegArray &CondRegs); + void rewriteCMov(MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos, + DebugLoc TestLoc, MachineInstr &CMovI, + MachineOperand &FlagUse, CondRegArray &CondRegs); + void rewriteCondJmp(MachineBasicBlock &TestMBB, + MachineBasicBlock::iterator TestPos, DebugLoc TestLoc, + MachineInstr &JmpI, CondRegArray &CondRegs); + void rewriteCopy(MachineInstr &MI, MachineOperand &FlagUse, MachineInstr &CopyDefI); + void rewriteSetCC(MachineBasicBlock &TestMBB, + MachineBasicBlock::iterator TestPos, DebugLoc TestLoc, + MachineInstr &SetCCI, MachineOperand &FlagUse, + CondRegArray &CondRegs); + +}; + +} // end anonymous namespace + +INITIALIZE_PASS_BEGIN(X86FlagsCopyLoweringPass, DEBUG_TYPE, + "X86 EFLAGS copy lowering", false, false) +INITIALIZE_PASS_END(X86FlagsCopyLoweringPass, DEBUG_TYPE, + "X86 EFLAGS copy lowering", false, false) + +FunctionPass *llvm::createX86FlagsCopyLoweringPass() { + return new X86FlagsCopyLoweringPass(); +} + +char X86FlagsCopyLoweringPass::ID = 0; + +void X86FlagsCopyLoweringPass::getAnalysisUsage(AnalysisUsage &AU) const { + MachineFunctionPass::getAnalysisUsage(AU); +} + +namespace { +/// An enumeration of the arithmetic instruction mnemonics which have +/// interesting flag semantics. +/// +/// We can map instruction opcodes into these mnemonics to make it easy to +/// dispatch with specific functionality. +enum class FlagArithMnemonic { + ADC, + ADCX, + ADOX, + RCL, + RCR, + SBB, +}; +} // namespace + +static FlagArithMnemonic getMnemonicFromOpcode(unsigned Opcode) { + switch (Opcode) { + default: + report_fatal_error("No support for lowering a copy into EFLAGS when used " + "by this instruction!"); + +#define LLVM_EXPAND_INSTR_SIZES(MNEMONIC, SUFFIX) \ + case X86::MNEMONIC##8##SUFFIX: \ + case X86::MNEMONIC##16##SUFFIX: \ + case X86::MNEMONIC##32##SUFFIX: \ + case X86::MNEMONIC##64##SUFFIX: + +#define LLVM_EXPAND_ADC_SBB_INSTR(MNEMONIC) \ + LLVM_EXPAND_INSTR_SIZES(MNEMONIC, rr) \ + LLVM_EXPAND_INSTR_SIZES(MNEMONIC, rr_REV) \ + LLVM_EXPAND_INSTR_SIZES(MNEMONIC, rm) \ + LLVM_EXPAND_INSTR_SIZES(MNEMONIC, mr) \ + case X86::MNEMONIC##8ri: \ + case X86::MNEMONIC##16ri8: \ + case X86::MNEMONIC##32ri8: \ + case X86::MNEMONIC##64ri8: \ + case X86::MNEMONIC##16ri: \ + case X86::MNEMONIC##32ri: \ + case X86::MNEMONIC##64ri32: \ + case X86::MNEMONIC##8mi: \ + case X86::MNEMONIC##16mi8: \ + case X86::MNEMONIC##32mi8: \ + case X86::MNEMONIC##64mi8: \ + case X86::MNEMONIC##16mi: \ + case X86::MNEMONIC##32mi: \ + case X86::MNEMONIC##64mi32: \ + case X86::MNEMONIC##8i8: \ + case X86::MNEMONIC##16i16: \ + case X86::MNEMONIC##32i32: \ + case X86::MNEMONIC##64i32: + + LLVM_EXPAND_ADC_SBB_INSTR(ADC) + return FlagArithMnemonic::ADC; + + LLVM_EXPAND_ADC_SBB_INSTR(SBB) + return FlagArithMnemonic::SBB; + +#undef LLVM_EXPAND_ADC_SBB_INSTR + + LLVM_EXPAND_INSTR_SIZES(RCL, rCL) + LLVM_EXPAND_INSTR_SIZES(RCL, r1) + LLVM_EXPAND_INSTR_SIZES(RCL, ri) + return FlagArithMnemonic::RCL; + + LLVM_EXPAND_INSTR_SIZES(RCR, rCL) + LLVM_EXPAND_INSTR_SIZES(RCR, r1) + LLVM_EXPAND_INSTR_SIZES(RCR, ri) + return FlagArithMnemonic::RCR; + +#undef LLVM_EXPAND_INSTR_SIZES + + case X86::ADCX32rr: + case X86::ADCX64rr: + case X86::ADCX32rm: + case X86::ADCX64rm: + return FlagArithMnemonic::ADCX; + + case X86::ADOX32rr: + case X86::ADOX64rr: + case X86::ADOX32rm: + case X86::ADOX64rm: + return FlagArithMnemonic::ADOX; + } +} + +static MachineBasicBlock &splitBlock(MachineBasicBlock &MBB, + MachineInstr &SplitI, + const X86InstrInfo &TII) { + MachineFunction &MF = *MBB.getParent(); + + assert(SplitI.getParent() == &MBB && + "Split instruction must be in the split block!"); + assert(SplitI.isBranch() && + "Only designed to split a tail of branch instructions!"); + assert(X86::getCondFromBranchOpc(SplitI.getOpcode()) != X86::COND_INVALID && + "Must split on an actual jCC instruction!"); + + // Dig out the previous instruction to the split point. + MachineInstr &PrevI = *std::prev(SplitI.getIterator()); + assert(PrevI.isBranch() && "Must split after a branch!"); + assert(X86::getCondFromBranchOpc(PrevI.getOpcode()) != X86::COND_INVALID && + "Must split after an actual jCC instruction!"); + assert(!std::prev(PrevI.getIterator())->isTerminator() && + "Must only have this one terminator prior to the split!"); + + // Grab the one successor edge that will stay in `MBB`. + MachineBasicBlock &UnsplitSucc = *PrevI.getOperand(0).getMBB(); + + // Analyze the original block to see if we are actually splitting an edge + // into two edges. This can happen when we have multiple conditional jumps to + // the same successor. + bool IsEdgeSplit = + std::any_of(SplitI.getIterator(), MBB.instr_end(), + [&](MachineInstr &MI) { + assert(MI.isTerminator() && + "Should only have spliced terminators!"); + return llvm::any_of( + MI.operands(), [&](MachineOperand &MOp) { + return MOp.isMBB() && MOp.getMBB() == &UnsplitSucc; + }); + }) || + MBB.getFallThrough() == &UnsplitSucc; + + MachineBasicBlock &NewMBB = *MF.CreateMachineBasicBlock(); + + // Insert the new block immediately after the current one. Any existing + // fallthrough will be sunk into this new block anyways. + MF.insert(std::next(MachineFunction::iterator(&MBB)), &NewMBB); + + // Splice the tail of instructions into the new block. + NewMBB.splice(NewMBB.end(), &MBB, SplitI.getIterator(), MBB.end()); + + // Copy the necessary succesors (and their probability info) into the new + // block. + for (auto SI = MBB.succ_begin(), SE = MBB.succ_end(); SI != SE; ++SI) + if (IsEdgeSplit || *SI != &UnsplitSucc) + NewMBB.copySuccessor(&MBB, SI); + // Normalize the probabilities if we didn't end up splitting the edge. + if (!IsEdgeSplit) + NewMBB.normalizeSuccProbs(); + + // Now replace all of the moved successors in the original block with the new + // block. This will merge their probabilities. + for (MachineBasicBlock *Succ : NewMBB.successors()) + if (Succ != &UnsplitSucc) + MBB.replaceSuccessor(Succ, &NewMBB); + + // We should always end up replacing at least one successor. + assert(MBB.isSuccessor(&NewMBB) && + "Failed to make the new block a successor!"); + + // Now update all the PHIs. + for (MachineBasicBlock *Succ : NewMBB.successors()) { + for (MachineInstr &MI : *Succ) { + if (!MI.isPHI()) + break; + + for (int OpIdx = 1, NumOps = MI.getNumOperands(); OpIdx < NumOps; + OpIdx += 2) { + MachineOperand &OpV = MI.getOperand(OpIdx); + MachineOperand &OpMBB = MI.getOperand(OpIdx + 1); + assert(OpMBB.isMBB() && "Block operand to a PHI is not a block!"); + if (OpMBB.getMBB() != &MBB) + continue; + + // Replace the operand for unsplit successors + if (!IsEdgeSplit || Succ != &UnsplitSucc) { + OpMBB.setMBB(&NewMBB); + + // We have to continue scanning as there may be multiple entries in + // the PHI. + continue; + } + + // When we have split the edge append a new successor. + MI.addOperand(MF, OpV); + MI.addOperand(MF, MachineOperand::CreateMBB(&NewMBB)); + break; + } + } + } + + return NewMBB; +} + +bool X86FlagsCopyLoweringPass::runOnMachineFunction(MachineFunction &MF) { + DEBUG(dbgs() << "********** " << getPassName() << " : " << MF.getName() + << " **********\n"); + + auto &Subtarget = MF.getSubtarget(); + MRI = &MF.getRegInfo(); + TII = Subtarget.getInstrInfo(); + TRI = Subtarget.getRegisterInfo(); + PromoteRC = &X86::GR8RegClass; + + if (MF.begin() == MF.end()) + // Nothing to do for a degenerate empty function... + return false; + + SmallVector Copies; + for (MachineBasicBlock &MBB : MF) + for (MachineInstr &MI : MBB) + if (MI.getOpcode() == TargetOpcode::COPY && + MI.getOperand(0).getReg() == X86::EFLAGS) + Copies.push_back(&MI); + + for (MachineInstr *CopyI : Copies) { + MachineBasicBlock &MBB = *CopyI->getParent(); + + MachineOperand &VOp = CopyI->getOperand(1); + assert(VOp.isReg() && + "The input to the copy for EFLAGS should always be a register!"); + MachineInstr &CopyDefI = *MRI->getVRegDef(VOp.getReg()); + if (CopyDefI.getOpcode() != TargetOpcode::COPY) { + // FIXME: The big likely candidate here are PHI nodes. We could in theory + // handle PHI nodes, but it gets really, really hard. Insanely hard. Hard + // enough that it is probably better to change every other part of LLVM + // to avoid creating them. The issue is that once we have PHIs we won't + // know which original EFLAGS value we need to capture with our setCCs + // below. The end result will be computing a complete set of setCCs that + // we *might* want, computing them in every place where we copy *out* of + // EFLAGS and then doing SSA formation on all of them to insert necessary + // PHI nodes and consume those here. Then hoping that somehow we DCE the + // unnecessary ones. This DCE seems very unlikely to be successful and so + // we will almost certainly end up with a glut of dead setCC + // instructions. Until we have a motivating test case and fail to avoid + // it by changing other parts of LLVM's lowering, we refuse to handle + // this complex case here. + DEBUG(dbgs() << "ERROR: Encountered unexpected def of an eflags copy: "; CopyDefI.dump()); + report_fatal_error("Cannot lower EFLAGS copy unless it is defined in turn by a copy!"); + } + + auto Cleanup = make_scope_exit([&] { + // All uses of the EFLAGS copy are now rewritten, kill the copy into + // eflags and if dead the copy from. + CopyI->eraseFromParent(); + if (MRI->use_empty(CopyDefI.getOperand(0).getReg())) + CopyDefI.eraseFromParent(); + ++NumCopiesEliminated; + }); + + MachineOperand &DOp = CopyI->getOperand(0); + assert(DOp.isDef() && "Expected register def!"); + assert(DOp.getReg() == X86::EFLAGS && "Unexpected copy def register!"); + if (DOp.isDead()) + continue; + + MachineBasicBlock &TestMBB = *CopyDefI.getParent(); + auto TestPos = CopyDefI.getIterator(); + DebugLoc TestLoc = CopyDefI.getDebugLoc(); + + DEBUG(dbgs() << "Rewriting copy: "; CopyI->dump()); + + // Scan for usage of newly set EFLAGS so we can rewrite them. We just buffer + // jumps because their usage is very constrained. + bool FlagsKilled = false; + SmallVector JmpIs; + + // Gather the condition flags that have already been preserved in + // registers. We do this from scratch each time as we expect there to be + // very few of them and we expect to not revisit the same copy definition + // many times. If either of those change sufficiently we could build a map + // of these up front instead. + CondRegArray CondRegs = collectCondsInRegs(TestMBB, CopyDefI); + + for (auto MII = std::next(CopyI->getIterator()), MIE = MBB.instr_end(); + MII != MIE;) { + MachineInstr &MI = *MII++; + MachineOperand *FlagUse = MI.findRegisterUseOperand(X86::EFLAGS); + if (!FlagUse) { + if (MI.findRegisterDefOperand(X86::EFLAGS)) { + // If EFLAGS are defined, it's as-if they were killed. We can stop + // scanning here. + // + // NB!!! Many instructions only modify some flags. LLVM currently + // models this as clobbering all flags, but if that ever changes this + // will need to be carefully updated to handle that more complex + // logic. + FlagsKilled = true; + break; + } + continue; + } + + DEBUG(dbgs() << " Rewriting use: "; MI.dump()); + + // Check the kill flag before we rewrite as that may change it. + if (FlagUse->isKill()) + FlagsKilled = true; + + // Once we encounter a branch, the rest of the instructions must also be + // branches. We can't rewrite in place here, so we handle them below. + // + // FIXME: handle conditional tail calls + if (X86::getCondFromBranchOpc(MI.getOpcode()) != X86::COND_INVALID) { + auto JmpIt = MI.getIterator(); + do { + JmpIs.push_back(&*JmpIt); + ++JmpIt; + } while (JmpIt != MBB.instr_end() && + X86::getCondFromBranchOpc(JmpIt->getOpcode()) != + X86::COND_INVALID); + break; + } + + // Otherwise we can just rewrite in-place. + if (X86::getCondFromCMovOpc(MI.getOpcode()) != X86::COND_INVALID) { + rewriteCMov(TestMBB, TestPos, TestLoc, MI, *FlagUse, CondRegs); + } else if (X86::getCondFromSETOpc(MI.getOpcode()) != X86::COND_INVALID) { + rewriteSetCC(TestMBB, TestPos, TestLoc, MI, *FlagUse, CondRegs); + } else if (MI.getOpcode() == TargetOpcode::COPY) { + rewriteCopy(MI, *FlagUse, CopyDefI); + } else { + // We assume that arithmetic instructions that use flags also def them. + assert(MI.findRegisterDefOperand(X86::EFLAGS) && + "Expected a def of EFLAGS for this instruction!"); + + // NB!!! Several arithmetic instructions only *partially* update + // flags. Theoretically, we could generate MI code sequences that + // would rely on this fact and observe different flags independently. + // But currently LLVM models all of these instructions as clobbering + // all the flags in an undef way. We rely on that to simplify the + // logic. + FlagsKilled = true; + + rewriteArithmetic(TestMBB, TestPos, TestLoc, MI, *FlagUse, CondRegs); + break; + } + + // If this was the last use of the flags, we're done. + if (FlagsKilled) + break; + } + + // If we didn't find a kill (or equivalent) check that the flags don't + // live-out of the basic block. Currently we don't support lowering copies + // of flags that live out in this fashion. + if (!FlagsKilled && + llvm::any_of(MBB.successors(), [](MachineBasicBlock *SuccMBB) { + return SuccMBB->isLiveIn(X86::EFLAGS); + })) { + DEBUG({ + dbgs() << "ERROR: Found a copied EFLAGS live-out from basic block:\n" + << "----\n"; + MBB.dump(); + dbgs() << "----\n" + << "ERROR: Cannot lower this EFLAGS copy !\n"; + }); + report_fatal_error( + "Cannot lower EFLAGS copy that lives out of a basic block!"); + } + + // Now rewrite the jumps that use the flags. These we handle specially + // because if there are multiple jumps we'll have to do surgery on the CFG. + for (MachineInstr *JmpI : JmpIs) { + // Past the first jump we need to split the blocks apart. + if (JmpI != JmpIs.front()) + splitBlock(*JmpI->getParent(), *JmpI, *TII); + + rewriteCondJmp(TestMBB, TestPos, TestLoc, *JmpI, CondRegs); + } + + // FIXME: Mark the last use of EFLAGS before the copy's def as a kill if + // the copy's def operand is itself a kill. + } + +#ifndef NDEBUG + for (MachineBasicBlock &MBB : MF) + for (MachineInstr &MI : MBB) + if (MI.getOpcode() == TargetOpcode::COPY && + (MI.getOperand(0).getReg() == X86::EFLAGS || + MI.getOperand(1).getReg() == X86::EFLAGS)) { + DEBUG(dbgs() << "ERROR: Found a COPY involving EFLAGS: "; MI.dump()); + llvm_unreachable("Unlowered EFLAGS copy!"); + } +#endif + + return true; +} + +/// Collect any conditions that have already been set in registers so that we +/// can re-use them rather than adding duplicates. +CondRegArray +X86FlagsCopyLoweringPass::collectCondsInRegs(MachineBasicBlock &MBB, + MachineInstr &CopyDefI) { + CondRegArray CondRegs = {}; + + // Scan backwards across the range of instructions with live EFLAGS. + for (MachineInstr &MI : llvm::reverse( + llvm::make_range(MBB.instr_begin(), CopyDefI.getIterator()))) { + X86::CondCode Cond = X86::getCondFromSETOpc(MI.getOpcode()); + if (Cond != X86::COND_INVALID && MI.getOperand(0).isReg()) + CondRegs[Cond] = MI.getOperand(0).getReg(); + + // If we hit an instruction that defines EFLAGS we can stop scanning. + if (MI.findRegisterDefOperand(X86::EFLAGS)) + break; + } + return CondRegs; +} + +unsigned X86FlagsCopyLoweringPass::promoteCondToReg( + MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos, + DebugLoc TestLoc, X86::CondCode Cond) { + unsigned Reg = MRI->createVirtualRegister(PromoteRC); + auto SetI = BuildMI(TestMBB, TestPos, TestLoc, + TII->get(X86::getSETFromCond(Cond)), Reg); + DEBUG(dbgs() << " save cond: "; SetI->dump()); + ++NumSetCCsInserted; + return Reg; +} + +std::pair X86FlagsCopyLoweringPass::getCondOrInverseInReg( + MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos, + DebugLoc TestLoc, X86::CondCode Cond, CondRegArray &CondRegs) { + unsigned &CondReg = CondRegs[Cond]; + unsigned &InvCondReg = CondRegs[X86::GetOppositeBranchCondition(Cond)]; + if (!CondReg && !InvCondReg) + CondReg = promoteCondToReg(TestMBB, TestPos, TestLoc, Cond); + + if (CondReg) + return {CondReg, false}; + else + return {InvCondReg, true}; +} + +void X86FlagsCopyLoweringPass::insertTest(MachineBasicBlock &MBB, + MachineBasicBlock::iterator Pos, + DebugLoc Loc, unsigned Reg) { + // We emit test instructions as register/immediate test against -1. This + // allows register allocation to fold a memory operand if needed (that will + // happen often due to the places this code is emitted). But hopefully will + // also allow us to select a shorter encoding of `testb %reg, %reg` when that + // would be equivalent. + auto TestI = + BuildMI(MBB, Pos, Loc, TII->get(X86::TEST8ri)).addReg(Reg).addImm(-1); + (void)TestI; + DEBUG(dbgs() << " test cond: "; TestI->dump()); + ++NumTestsInserted; +} + +void X86FlagsCopyLoweringPass::rewriteArithmetic( + MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos, + DebugLoc TestLoc, MachineInstr &MI, MachineOperand &FlagUse, + CondRegArray &CondRegs) { + // Arithmetic is either reading CF or OF. Figure out which condition we need + // to preserve in a register. + X86::CondCode Cond; + + // The addend to use to reset CF or OF when added to the flag value. + int Addend; + + switch (getMnemonicFromOpcode(MI.getOpcode())) { + case FlagArithMnemonic::ADC: + case FlagArithMnemonic::ADCX: + case FlagArithMnemonic::RCL: + case FlagArithMnemonic::RCR: + case FlagArithMnemonic::SBB: + Cond = X86::COND_B; // CF == 1 + Addend = 127; + break; + + case FlagArithMnemonic::ADOX: + Cond = X86::COND_O; // OF == 1 + Addend = 255; + break; + } + + // Now get a register that contains the value of the flag input to the + // arithmetic. We require exactly this flag to simplify the arithmetic + // required to materialize it back into the flag. + unsigned &CondReg = CondRegs[Cond]; + if (!CondReg) + CondReg = promoteCondToReg(TestMBB, TestPos, TestLoc, Cond); + + MachineBasicBlock &MBB = *MI.getParent(); + + // Insert an instruction that will set the flag back to the desired value. + unsigned TmpReg = MRI->createVirtualRegister(PromoteRC); + auto AddI = + BuildMI(MBB, MI.getIterator(), MI.getDebugLoc(), TII->get(X86::ADD8ri)) + .addDef(TmpReg, RegState::Dead) + .addReg(CondReg) + .addImm(Addend); + (void)AddI; + DEBUG(dbgs() << " add cond: "; AddI->dump()); + ++NumAddsInserted; + FlagUse.setIsKill(true); +} + +void X86FlagsCopyLoweringPass::rewriteCMov(MachineBasicBlock &TestMBB, + MachineBasicBlock::iterator TestPos, + DebugLoc TestLoc, + MachineInstr &CMovI, + MachineOperand &FlagUse, + CondRegArray &CondRegs) { + // First get the register containing this specific condition. + X86::CondCode Cond = X86::getCondFromCMovOpc(CMovI.getOpcode()); + unsigned CondReg; + bool Inverted; + std::tie(CondReg, Inverted) = + getCondOrInverseInReg(TestMBB, TestPos, TestLoc, Cond, CondRegs); + + MachineBasicBlock &MBB = *CMovI.getParent(); + + // Insert a direct test of the saved register. + insertTest(MBB, CMovI.getIterator(), CMovI.getDebugLoc(), CondReg); + + // Rewrite the CMov to use the !ZF flag from the test (but match register + // size and memory operand), and then kill its use of the flags afterward. + auto &CMovRC = *MRI->getRegClass(CMovI.getOperand(0).getReg()); + CMovI.setDesc(TII->get(X86::getCMovFromCond( + Inverted ? X86::COND_E : X86::COND_NE, TRI->getRegSizeInBits(CMovRC) / 8, + !CMovI.memoperands_empty()))); + FlagUse.setIsKill(true); + DEBUG(dbgs() << " fixed cmov: "; CMovI.dump()); +} + +void X86FlagsCopyLoweringPass::rewriteCondJmp( + MachineBasicBlock &TestMBB, MachineBasicBlock::iterator TestPos, + DebugLoc TestLoc, MachineInstr &JmpI, + CondRegArray &CondRegs) { + // First get the register containing this specific condition. + X86::CondCode Cond = X86::getCondFromBranchOpc(JmpI.getOpcode()); + unsigned CondReg; + bool Inverted; + std::tie(CondReg, Inverted) = + getCondOrInverseInReg(TestMBB, TestPos, TestLoc, Cond, CondRegs); + + MachineBasicBlock &JmpMBB = *JmpI.getParent(); + + // Insert a direct test of the saved register. + insertTest(JmpMBB, JmpI.getIterator(), JmpI.getDebugLoc(), CondReg); + + // Rewrite the jump to use the !ZF flag from the test, and kill its use of + // flags afterward. + JmpI.setDesc(TII->get(X86::GetCondBranchFromCond(Inverted ? X86::COND_E : X86::COND_NE))); + const int ImplicitEFLAGSOpIdx = 1; + JmpI.getOperand(ImplicitEFLAGSOpIdx).setIsKill(true); + DEBUG(dbgs() << " fixed jCC: "; JmpI.dump()); +} + +void X86FlagsCopyLoweringPass::rewriteCopy(MachineInstr &MI, + MachineOperand &FlagUse, + MachineInstr &CopyDefI) { + // Just replace this copy with the the original copy def. + MRI->replaceRegWith(MI.getOperand(0).getReg(), + CopyDefI.getOperand(0).getReg()); + MI.eraseFromParent(); +} + +void X86FlagsCopyLoweringPass::rewriteSetCC(MachineBasicBlock &TestMBB, + MachineBasicBlock::iterator TestPos, + DebugLoc TestLoc, + MachineInstr &SetCCI, + MachineOperand &FlagUse, + CondRegArray &CondRegs) { + X86::CondCode Cond = X86::getCondFromSETOpc(SetCCI.getOpcode()); + // Note that we can't usefully rewrite this to the inverse without complex + // analysis of the users of the setCC. Largely we rely on duplicates which + // could have been avoided already being avoided here. + unsigned &CondReg = CondRegs[Cond]; + if (!CondReg) + CondReg = promoteCondToReg(TestMBB, TestPos, TestLoc, Cond); + + // Rewriting this is trivial: we just replace the register and remove the + // setcc. + MRI->replaceRegWith(SetCCI.getOperand(0).getReg(), CondReg); + SetCCI.eraseFromParent(); +} Index: llvm/lib/Target/X86/X86TargetMachine.cpp =================================================================== --- llvm/lib/Target/X86/X86TargetMachine.cpp +++ llvm/lib/Target/X86/X86TargetMachine.cpp @@ -63,6 +63,7 @@ void initializeX86ExecutionDomainFixPass(PassRegistry &); void initializeX86DomainReassignmentPass(PassRegistry &); void initializeX86AvoidSFBPassPass(PassRegistry &); +void initializeX86FlagsCopyLoweringPassPass(PassRegistry &); } // end namespace llvm @@ -82,6 +83,7 @@ initializeX86ExecutionDomainFixPass(PR); initializeX86DomainReassignmentPass(PR); initializeX86AvoidSFBPassPass(PR); + initializeX86FlagsCopyLoweringPassPass(PR); } static std::unique_ptr createTLOF(const Triple &TT) { @@ -454,6 +456,7 @@ addPass(createX86AvoidStoreForwardingBlocks()); } + addPass(createX86FlagsCopyLoweringPass()); addPass(createX86WinAllocaExpander()); } void X86PassConfig::addMachineSSAOptimization() { Index: llvm/test/CodeGen/X86/O0-pipeline.ll =================================================================== --- llvm/test/CodeGen/X86/O0-pipeline.ll +++ llvm/test/CodeGen/X86/O0-pipeline.ll @@ -37,6 +37,7 @@ ; CHECK-NEXT: X86 PIC Global Base Reg Initialization ; CHECK-NEXT: Expand ISel Pseudo-instructions ; CHECK-NEXT: Local Stack Slot Allocation +; CHECK-NEXT: X86 EFLAGS copy lowering ; CHECK-NEXT: X86 WinAlloca Expander ; CHECK-NEXT: Eliminate PHI nodes for register allocation ; CHECK-NEXT: Two-Address instruction pass Index: llvm/test/CodeGen/X86/O3-pipeline.ll =================================================================== --- llvm/test/CodeGen/X86/O3-pipeline.ll +++ llvm/test/CodeGen/X86/O3-pipeline.ll @@ -90,6 +90,7 @@ ; CHECK-NEXT: X86 LEA Optimize ; CHECK-NEXT: X86 Optimize Call Frame ; CHECK-NEXT: X86 Avoid Store Forwarding Block +; CHECK-NEXT: X86 EFLAGS copy lowering ; CHECK-NEXT: X86 WinAlloca Expander ; CHECK-NEXT: Detect Dead Lanes ; CHECK-NEXT: Process Implicit Definitions Index: llvm/test/CodeGen/X86/cmpxchg-clobber-flags.ll =================================================================== --- llvm/test/CodeGen/X86/cmpxchg-clobber-flags.ll +++ llvm/test/CodeGen/X86/cmpxchg-clobber-flags.ll @@ -40,19 +40,13 @@ ; 32-GOOD-RA-NEXT: movl 24(%ebp), %ecx ; 32-GOOD-RA-NEXT: movl 8(%ebp), %esi ; 32-GOOD-RA-NEXT: lock cmpxchg8b (%esi) -; 32-GOOD-RA-NEXT: pushl %eax -; 32-GOOD-RA-NEXT: seto %al -; 32-GOOD-RA-NEXT: lahf -; 32-GOOD-RA-NEXT: movl %eax, %esi -; 32-GOOD-RA-NEXT: popl %eax +; 32-GOOD-RA-NEXT: setne %bl ; 32-GOOD-RA-NEXT: subl $8, %esp ; 32-GOOD-RA-NEXT: pushl %edx ; 32-GOOD-RA-NEXT: pushl %eax ; 32-GOOD-RA-NEXT: calll bar ; 32-GOOD-RA-NEXT: addl $16, %esp -; 32-GOOD-RA-NEXT: movl %esi, %eax -; 32-GOOD-RA-NEXT: addb $127, %al -; 32-GOOD-RA-NEXT: sahf +; 32-GOOD-RA-NEXT: testb $-1, %bl ; 32-GOOD-RA-NEXT: jne .LBB0_3 ; 32-GOOD-RA-NEXT: # %bb.1: # %t ; 32-GOOD-RA-NEXT: movl $42, %eax @@ -78,29 +72,13 @@ ; 32-FAST-RA-NEXT: movl 12(%ebp), %eax ; 32-FAST-RA-NEXT: movl 16(%ebp), %edx ; 32-FAST-RA-NEXT: lock cmpxchg8b (%esi) -; 32-FAST-RA-NEXT: pushl %eax -; 32-FAST-RA-NEXT: seto %al -; 32-FAST-RA-NEXT: lahf -; 32-FAST-RA-NEXT: movl %eax, %ecx -; 32-FAST-RA-NEXT: popl %eax +; 32-FAST-RA-NEXT: setne %bl ; 32-FAST-RA-NEXT: subl $8, %esp -; 32-FAST-RA-NEXT: pushl %eax -; 32-FAST-RA-NEXT: movl %ecx, %eax -; 32-FAST-RA-NEXT: addb $127, %al -; 32-FAST-RA-NEXT: sahf -; 32-FAST-RA-NEXT: popl %eax -; 32-FAST-RA-NEXT: pushl %eax -; 32-FAST-RA-NEXT: seto %al -; 32-FAST-RA-NEXT: lahf -; 32-FAST-RA-NEXT: movl %eax, %esi -; 32-FAST-RA-NEXT: popl %eax ; 32-FAST-RA-NEXT: pushl %edx ; 32-FAST-RA-NEXT: pushl %eax ; 32-FAST-RA-NEXT: calll bar ; 32-FAST-RA-NEXT: addl $16, %esp -; 32-FAST-RA-NEXT: movl %esi, %eax -; 32-FAST-RA-NEXT: addb $127, %al -; 32-FAST-RA-NEXT: sahf +; 32-FAST-RA-NEXT: testb $-1, %bl ; 32-FAST-RA-NEXT: jne .LBB0_3 ; 32-FAST-RA-NEXT: # %bb.1: # %t ; 32-FAST-RA-NEXT: movl $42, %eax @@ -114,117 +92,29 @@ ; 32-FAST-RA-NEXT: popl %ebp ; 32-FAST-RA-NEXT: retl ; -; 64-GOOD-RA-LABEL: test_intervening_call: -; 64-GOOD-RA: # %bb.0: # %entry -; 64-GOOD-RA-NEXT: pushq %rbp -; 64-GOOD-RA-NEXT: movq %rsp, %rbp -; 64-GOOD-RA-NEXT: pushq %rbx -; 64-GOOD-RA-NEXT: pushq %rax -; 64-GOOD-RA-NEXT: movq %rsi, %rax -; 64-GOOD-RA-NEXT: lock cmpxchgq %rdx, (%rdi) -; 64-GOOD-RA-NEXT: pushfq -; 64-GOOD-RA-NEXT: popq %rbx -; 64-GOOD-RA-NEXT: movq %rax, %rdi -; 64-GOOD-RA-NEXT: callq bar -; 64-GOOD-RA-NEXT: pushq %rbx -; 64-GOOD-RA-NEXT: popfq -; 64-GOOD-RA-NEXT: jne .LBB0_3 -; 64-GOOD-RA-NEXT: # %bb.1: # %t -; 64-GOOD-RA-NEXT: movl $42, %eax -; 64-GOOD-RA-NEXT: jmp .LBB0_2 -; 64-GOOD-RA-NEXT: .LBB0_3: # %f -; 64-GOOD-RA-NEXT: xorl %eax, %eax -; 64-GOOD-RA-NEXT: .LBB0_2: # %t -; 64-GOOD-RA-NEXT: addq $8, %rsp -; 64-GOOD-RA-NEXT: popq %rbx -; 64-GOOD-RA-NEXT: popq %rbp -; 64-GOOD-RA-NEXT: retq -; -; 64-FAST-RA-LABEL: test_intervening_call: -; 64-FAST-RA: # %bb.0: # %entry -; 64-FAST-RA-NEXT: pushq %rbp -; 64-FAST-RA-NEXT: movq %rsp, %rbp -; 64-FAST-RA-NEXT: pushq %rbx -; 64-FAST-RA-NEXT: pushq %rax -; 64-FAST-RA-NEXT: movq %rsi, %rax -; 64-FAST-RA-NEXT: lock cmpxchgq %rdx, (%rdi) -; 64-FAST-RA-NEXT: pushfq -; 64-FAST-RA-NEXT: popq %rbx -; 64-FAST-RA-NEXT: movq %rax, %rdi -; 64-FAST-RA-NEXT: callq bar -; 64-FAST-RA-NEXT: pushq %rbx -; 64-FAST-RA-NEXT: popfq -; 64-FAST-RA-NEXT: jne .LBB0_3 -; 64-FAST-RA-NEXT: # %bb.1: # %t -; 64-FAST-RA-NEXT: movl $42, %eax -; 64-FAST-RA-NEXT: jmp .LBB0_2 -; 64-FAST-RA-NEXT: .LBB0_3: # %f -; 64-FAST-RA-NEXT: xorl %eax, %eax -; 64-FAST-RA-NEXT: .LBB0_2: # %t -; 64-FAST-RA-NEXT: addq $8, %rsp -; 64-FAST-RA-NEXT: popq %rbx -; 64-FAST-RA-NEXT: popq %rbp -; 64-FAST-RA-NEXT: retq -; -; 64-GOOD-RA-SAHF-LABEL: test_intervening_call: -; 64-GOOD-RA-SAHF: # %bb.0: # %entry -; 64-GOOD-RA-SAHF-NEXT: pushq %rbp -; 64-GOOD-RA-SAHF-NEXT: movq %rsp, %rbp -; 64-GOOD-RA-SAHF-NEXT: pushq %rbx -; 64-GOOD-RA-SAHF-NEXT: pushq %rax -; 64-GOOD-RA-SAHF-NEXT: movq %rsi, %rax -; 64-GOOD-RA-SAHF-NEXT: lock cmpxchgq %rdx, (%rdi) -; 64-GOOD-RA-SAHF-NEXT: pushq %rax -; 64-GOOD-RA-SAHF-NEXT: seto %al -; 64-GOOD-RA-SAHF-NEXT: lahf -; 64-GOOD-RA-SAHF-NEXT: movq %rax, %rbx -; 64-GOOD-RA-SAHF-NEXT: popq %rax -; 64-GOOD-RA-SAHF-NEXT: movq %rax, %rdi -; 64-GOOD-RA-SAHF-NEXT: callq bar -; 64-GOOD-RA-SAHF-NEXT: movq %rbx, %rax -; 64-GOOD-RA-SAHF-NEXT: addb $127, %al -; 64-GOOD-RA-SAHF-NEXT: sahf -; 64-GOOD-RA-SAHF-NEXT: jne .LBB0_3 -; 64-GOOD-RA-SAHF-NEXT: # %bb.1: # %t -; 64-GOOD-RA-SAHF-NEXT: movl $42, %eax -; 64-GOOD-RA-SAHF-NEXT: jmp .LBB0_2 -; 64-GOOD-RA-SAHF-NEXT: .LBB0_3: # %f -; 64-GOOD-RA-SAHF-NEXT: xorl %eax, %eax -; 64-GOOD-RA-SAHF-NEXT: .LBB0_2: # %t -; 64-GOOD-RA-SAHF-NEXT: addq $8, %rsp -; 64-GOOD-RA-SAHF-NEXT: popq %rbx -; 64-GOOD-RA-SAHF-NEXT: popq %rbp -; 64-GOOD-RA-SAHF-NEXT: retq -; -; 64-FAST-RA-SAHF-LABEL: test_intervening_call: -; 64-FAST-RA-SAHF: # %bb.0: # %entry -; 64-FAST-RA-SAHF-NEXT: pushq %rbp -; 64-FAST-RA-SAHF-NEXT: movq %rsp, %rbp -; 64-FAST-RA-SAHF-NEXT: pushq %rbx -; 64-FAST-RA-SAHF-NEXT: pushq %rax -; 64-FAST-RA-SAHF-NEXT: movq %rsi, %rax -; 64-FAST-RA-SAHF-NEXT: lock cmpxchgq %rdx, (%rdi) -; 64-FAST-RA-SAHF-NEXT: pushq %rax -; 64-FAST-RA-SAHF-NEXT: seto %al -; 64-FAST-RA-SAHF-NEXT: lahf -; 64-FAST-RA-SAHF-NEXT: movq %rax, %rbx -; 64-FAST-RA-SAHF-NEXT: popq %rax -; 64-FAST-RA-SAHF-NEXT: movq %rax, %rdi -; 64-FAST-RA-SAHF-NEXT: callq bar -; 64-FAST-RA-SAHF-NEXT: movq %rbx, %rax -; 64-FAST-RA-SAHF-NEXT: addb $127, %al -; 64-FAST-RA-SAHF-NEXT: sahf -; 64-FAST-RA-SAHF-NEXT: jne .LBB0_3 -; 64-FAST-RA-SAHF-NEXT: # %bb.1: # %t -; 64-FAST-RA-SAHF-NEXT: movl $42, %eax -; 64-FAST-RA-SAHF-NEXT: jmp .LBB0_2 -; 64-FAST-RA-SAHF-NEXT: .LBB0_3: # %f -; 64-FAST-RA-SAHF-NEXT: xorl %eax, %eax -; 64-FAST-RA-SAHF-NEXT: .LBB0_2: # %t -; 64-FAST-RA-SAHF-NEXT: addq $8, %rsp -; 64-FAST-RA-SAHF-NEXT: popq %rbx -; 64-FAST-RA-SAHF-NEXT: popq %rbp -; 64-FAST-RA-SAHF-NEXT: retq +; 64-ALL-LABEL: test_intervening_call: +; 64-ALL: # %bb.0: # %entry +; 64-ALL-NEXT: pushq %rbp +; 64-ALL-NEXT: movq %rsp, %rbp +; 64-ALL-NEXT: pushq %rbx +; 64-ALL-NEXT: pushq %rax +; 64-ALL-NEXT: movq %rsi, %rax +; 64-ALL-NEXT: lock cmpxchgq %rdx, (%rdi) +; 64-ALL-NEXT: setne %bl +; 64-ALL-NEXT: movq %rax, %rdi +; 64-ALL-NEXT: callq bar +; 64-ALL-NEXT: testb $-1, %bl +; 64-ALL-NEXT: jne .LBB0_3 +; 64-ALL-NEXT: # %bb.1: # %t +; 64-ALL-NEXT: movl $42, %eax +; 64-ALL-NEXT: jmp .LBB0_2 +; 64-ALL-NEXT: .LBB0_3: # %f +; 64-ALL-NEXT: xorl %eax, %eax +; 64-ALL-NEXT: .LBB0_2: # %t +; 64-ALL-NEXT: addq $8, %rsp +; 64-ALL-NEXT: popq %rbx +; 64-ALL-NEXT: popq %rbp +; 64-ALL-NEXT: retq entry: %cx = cmpxchg i64* %foo, i64 %bar, i64 %baz seq_cst seq_cst %v = extractvalue { i64, i1 } %cx, 0 @@ -333,28 +223,22 @@ ; 32-GOOD-RA: # %bb.0: # %entry ; 32-GOOD-RA-NEXT: pushl %ebp ; 32-GOOD-RA-NEXT: movl %esp, %ebp -; 32-GOOD-RA-NEXT: pushl %edi +; 32-GOOD-RA-NEXT: pushl %ebx ; 32-GOOD-RA-NEXT: pushl %esi ; 32-GOOD-RA-NEXT: movl 12(%ebp), %eax ; 32-GOOD-RA-NEXT: movl 16(%ebp), %esi ; 32-GOOD-RA-NEXT: movl 8(%ebp), %ecx ; 32-GOOD-RA-NEXT: lock cmpxchgl %esi, (%ecx) -; 32-GOOD-RA-NEXT: seto %al -; 32-GOOD-RA-NEXT: lahf -; 32-GOOD-RA-NEXT: movl %eax, %edi +; 32-GOOD-RA-NEXT: sete %bl ; 32-GOOD-RA-NEXT: calll foo -; 32-GOOD-RA-NEXT: pushl %eax -; 32-GOOD-RA-NEXT: movl %edi, %eax -; 32-GOOD-RA-NEXT: addb $127, %al -; 32-GOOD-RA-NEXT: sahf -; 32-GOOD-RA-NEXT: popl %eax -; 32-GOOD-RA-NEXT: je .LBB2_2 +; 32-GOOD-RA-NEXT: testb $-1, %bl +; 32-GOOD-RA-NEXT: jne .LBB2_2 ; 32-GOOD-RA-NEXT: # %bb.1: # %entry ; 32-GOOD-RA-NEXT: movl %eax, %esi ; 32-GOOD-RA-NEXT: .LBB2_2: # %entry ; 32-GOOD-RA-NEXT: movl %esi, %eax ; 32-GOOD-RA-NEXT: popl %esi -; 32-GOOD-RA-NEXT: popl %edi +; 32-GOOD-RA-NEXT: popl %ebx ; 32-GOOD-RA-NEXT: popl %ebp ; 32-GOOD-RA-NEXT: retl ; @@ -362,118 +246,42 @@ ; 32-FAST-RA: # %bb.0: # %entry ; 32-FAST-RA-NEXT: pushl %ebp ; 32-FAST-RA-NEXT: movl %esp, %ebp -; 32-FAST-RA-NEXT: pushl %edi +; 32-FAST-RA-NEXT: pushl %ebx ; 32-FAST-RA-NEXT: pushl %esi ; 32-FAST-RA-NEXT: movl 8(%ebp), %ecx ; 32-FAST-RA-NEXT: movl 16(%ebp), %esi ; 32-FAST-RA-NEXT: movl 12(%ebp), %eax ; 32-FAST-RA-NEXT: lock cmpxchgl %esi, (%ecx) -; 32-FAST-RA-NEXT: seto %al -; 32-FAST-RA-NEXT: lahf -; 32-FAST-RA-NEXT: movl %eax, %edi +; 32-FAST-RA-NEXT: sete %bl ; 32-FAST-RA-NEXT: calll foo -; 32-FAST-RA-NEXT: pushl %eax -; 32-FAST-RA-NEXT: movl %edi, %eax -; 32-FAST-RA-NEXT: addb $127, %al -; 32-FAST-RA-NEXT: sahf -; 32-FAST-RA-NEXT: popl %eax -; 32-FAST-RA-NEXT: je .LBB2_2 +; 32-FAST-RA-NEXT: testb $-1, %bl +; 32-FAST-RA-NEXT: jne .LBB2_2 ; 32-FAST-RA-NEXT: # %bb.1: # %entry ; 32-FAST-RA-NEXT: movl %eax, %esi ; 32-FAST-RA-NEXT: .LBB2_2: # %entry ; 32-FAST-RA-NEXT: movl %esi, %eax ; 32-FAST-RA-NEXT: popl %esi -; 32-FAST-RA-NEXT: popl %edi +; 32-FAST-RA-NEXT: popl %ebx ; 32-FAST-RA-NEXT: popl %ebp ; 32-FAST-RA-NEXT: retl ; -; 64-GOOD-RA-LABEL: test_feed_cmov: -; 64-GOOD-RA: # %bb.0: # %entry -; 64-GOOD-RA-NEXT: pushq %rbp -; 64-GOOD-RA-NEXT: movq %rsp, %rbp -; 64-GOOD-RA-NEXT: pushq %r14 -; 64-GOOD-RA-NEXT: pushq %rbx -; 64-GOOD-RA-NEXT: movl %edx, %ebx -; 64-GOOD-RA-NEXT: movl %esi, %eax -; 64-GOOD-RA-NEXT: lock cmpxchgl %edx, (%rdi) -; 64-GOOD-RA-NEXT: pushfq -; 64-GOOD-RA-NEXT: popq %r14 -; 64-GOOD-RA-NEXT: callq foo -; 64-GOOD-RA-NEXT: pushq %r14 -; 64-GOOD-RA-NEXT: popfq -; 64-GOOD-RA-NEXT: cmovel %ebx, %eax -; 64-GOOD-RA-NEXT: popq %rbx -; 64-GOOD-RA-NEXT: popq %r14 -; 64-GOOD-RA-NEXT: popq %rbp -; 64-GOOD-RA-NEXT: retq -; -; 64-FAST-RA-LABEL: test_feed_cmov: -; 64-FAST-RA: # %bb.0: # %entry -; 64-FAST-RA-NEXT: pushq %rbp -; 64-FAST-RA-NEXT: movq %rsp, %rbp -; 64-FAST-RA-NEXT: pushq %r14 -; 64-FAST-RA-NEXT: pushq %rbx -; 64-FAST-RA-NEXT: movl %edx, %ebx -; 64-FAST-RA-NEXT: movl %esi, %eax -; 64-FAST-RA-NEXT: lock cmpxchgl %edx, (%rdi) -; 64-FAST-RA-NEXT: pushfq -; 64-FAST-RA-NEXT: popq %r14 -; 64-FAST-RA-NEXT: callq foo -; 64-FAST-RA-NEXT: pushq %r14 -; 64-FAST-RA-NEXT: popfq -; 64-FAST-RA-NEXT: cmovel %ebx, %eax -; 64-FAST-RA-NEXT: popq %rbx -; 64-FAST-RA-NEXT: popq %r14 -; 64-FAST-RA-NEXT: popq %rbp -; 64-FAST-RA-NEXT: retq -; -; 64-GOOD-RA-SAHF-LABEL: test_feed_cmov: -; 64-GOOD-RA-SAHF: # %bb.0: # %entry -; 64-GOOD-RA-SAHF-NEXT: pushq %rbp -; 64-GOOD-RA-SAHF-NEXT: movq %rsp, %rbp -; 64-GOOD-RA-SAHF-NEXT: pushq %r14 -; 64-GOOD-RA-SAHF-NEXT: pushq %rbx -; 64-GOOD-RA-SAHF-NEXT: movl %edx, %ebx -; 64-GOOD-RA-SAHF-NEXT: movl %esi, %eax -; 64-GOOD-RA-SAHF-NEXT: lock cmpxchgl %edx, (%rdi) -; 64-GOOD-RA-SAHF-NEXT: seto %al -; 64-GOOD-RA-SAHF-NEXT: lahf -; 64-GOOD-RA-SAHF-NEXT: movq %rax, %r14 -; 64-GOOD-RA-SAHF-NEXT: callq foo -; 64-GOOD-RA-SAHF-NEXT: pushq %rax -; 64-GOOD-RA-SAHF-NEXT: movq %r14, %rax -; 64-GOOD-RA-SAHF-NEXT: addb $127, %al -; 64-GOOD-RA-SAHF-NEXT: sahf -; 64-GOOD-RA-SAHF-NEXT: popq %rax -; 64-GOOD-RA-SAHF-NEXT: cmovel %ebx, %eax -; 64-GOOD-RA-SAHF-NEXT: popq %rbx -; 64-GOOD-RA-SAHF-NEXT: popq %r14 -; 64-GOOD-RA-SAHF-NEXT: popq %rbp -; 64-GOOD-RA-SAHF-NEXT: retq -; -; 64-FAST-RA-SAHF-LABEL: test_feed_cmov: -; 64-FAST-RA-SAHF: # %bb.0: # %entry -; 64-FAST-RA-SAHF-NEXT: pushq %rbp -; 64-FAST-RA-SAHF-NEXT: movq %rsp, %rbp -; 64-FAST-RA-SAHF-NEXT: pushq %r14 -; 64-FAST-RA-SAHF-NEXT: pushq %rbx -; 64-FAST-RA-SAHF-NEXT: movl %edx, %ebx -; 64-FAST-RA-SAHF-NEXT: movl %esi, %eax -; 64-FAST-RA-SAHF-NEXT: lock cmpxchgl %edx, (%rdi) -; 64-FAST-RA-SAHF-NEXT: seto %al -; 64-FAST-RA-SAHF-NEXT: lahf -; 64-FAST-RA-SAHF-NEXT: movq %rax, %r14 -; 64-FAST-RA-SAHF-NEXT: callq foo -; 64-FAST-RA-SAHF-NEXT: pushq %rax -; 64-FAST-RA-SAHF-NEXT: movq %r14, %rax -; 64-FAST-RA-SAHF-NEXT: addb $127, %al -; 64-FAST-RA-SAHF-NEXT: sahf -; 64-FAST-RA-SAHF-NEXT: popq %rax -; 64-FAST-RA-SAHF-NEXT: cmovel %ebx, %eax -; 64-FAST-RA-SAHF-NEXT: popq %rbx -; 64-FAST-RA-SAHF-NEXT: popq %r14 -; 64-FAST-RA-SAHF-NEXT: popq %rbp -; 64-FAST-RA-SAHF-NEXT: retq +; 64-ALL-LABEL: test_feed_cmov: +; 64-ALL: # %bb.0: # %entry +; 64-ALL-NEXT: pushq %rbp +; 64-ALL-NEXT: movq %rsp, %rbp +; 64-ALL-NEXT: pushq %r14 +; 64-ALL-NEXT: pushq %rbx +; 64-ALL-NEXT: movl %edx, %ebx +; 64-ALL-NEXT: movl %esi, %eax +; 64-ALL-NEXT: lock cmpxchgl %edx, (%rdi) +; 64-ALL-NEXT: sete %r14b +; 64-ALL-NEXT: callq foo +; 64-ALL-NEXT: testb $-1, %r14b +; 64-ALL-NEXT: cmovnel %ebx, %eax +; 64-ALL-NEXT: popq %rbx +; 64-ALL-NEXT: popq %r14 +; 64-ALL-NEXT: popq %rbp +; 64-ALL-NEXT: retq entry: %res = cmpxchg i32* %addr, i32 %desired, i32 %new seq_cst seq_cst %success = extractvalue { i32, i1 } %res, 1 Index: llvm/test/CodeGen/X86/copy-eflags.ll =================================================================== --- llvm/test/CodeGen/X86/copy-eflags.ll +++ llvm/test/CodeGen/X86/copy-eflags.ll @@ -22,27 +22,20 @@ %cval = load volatile i32, i32* @c %inc1 = add nsw i32 %cval, 1 store volatile i32 %inc1, i32* @c +; Copy a flag produced by the incb of %inc1 to a register. The flag will be +; reused by %tobool. +; CHECK: incl c{{$}} +; CHECK-NEXT: sete [[REG:%[a-z]+]] %aval = load volatile i8, i8* @a %inc2 = add i8 %aval, 1 store volatile i8 %inc2, i8* @a -; Copy flags produced by the incb of %inc1 to a register, need to save+restore -; eax around it. The flags will be reused by %tobool. -; CHECK: pushl %eax -; CHECK: seto %al -; CHECK: lahf -; CHECK: movl %eax, [[REG:%[a-z]+]] -; CHECK: popl %eax %cmp = icmp eq i8 %aval, %bval %conv5 = zext i1 %cmp to i8 store i8 %conv5, i8* @d %tobool = icmp eq i32 %inc1, 0 -; We restore flags with an 'addb, sahf' sequence, need to save+restore eax -; around it. -; CHECK: pushl %eax -; CHECK: movl [[REG]], %eax -; CHECK: addb $127, %al -; CHECK: sahf -; CHECK: popl %eax +; Test the register from above for %tobool. +; CHECK: testb $-1, [[REG]] +; CHECK: jne br i1 %tobool, label %if.end, label %if.then if.then: Index: llvm/test/CodeGen/X86/flags-copy-lowering.mir =================================================================== --- /dev/null +++ llvm/test/CodeGen/X86/flags-copy-lowering.mir @@ -0,0 +1,485 @@ +# RUN: llc -run-pass x86-flags-copy-lowering -o - %s | FileCheck %s +# +# Lower various interesting copy patterns of EFLAGS without using LAHF/SAHF. + +--- | + target triple = "x86_64-unknown-unknown" + + declare void @foo() + + define i32 @test_branch(i64 %a, i64 %b) { + entry: + call void @foo() + ret i32 0 + } + + define i32 @test_branch_fallthrough(i64 %a, i64 %b) { + entry: + call void @foo() + ret i32 0 + } + + define void @test_setcc(i64 %a, i64 %b) { + entry: + call void @foo() + ret void + } + + define void @test_cmov(i64 %a, i64 %b) { + entry: + call void @foo() + ret void + } + + define void @test_adc(i64 %a, i64 %b) { + entry: + call void @foo() + ret void + } + + define void @test_sbb(i64 %a, i64 %b) { + entry: + call void @foo() + ret void + } + + define void @test_adcx(i64 %a, i64 %b) { + entry: + call void @foo() + ret void + } + + define void @test_adox(i64 %a, i64 %b) { + entry: + call void @foo() + ret void + } + + define void @test_rcl(i64 %a, i64 %b) { + entry: + call void @foo() + ret void + } + + define void @test_rcr(i64 %a, i64 %b) { + entry: + call void @foo() + ret void + } +... +--- +name: test_branch +# CHECK-LABEL: name: test_branch +liveins: + - { reg: '$rdi', virtual-reg: '%0' } + - { reg: '$rsi', virtual-reg: '%1' } +body: | + bb.0: + successors: %bb.1, %bb.2, %bb.3 + liveins: $rdi, $rsi + + %0:gr64 = COPY $rdi + %1:gr64 = COPY $rsi + CMP64rr %0, %1, implicit-def $eflags + %2:gr64 = COPY $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + ; CHECK: %[[A_REG:[^:]*]]:gr8 = SETAr implicit $eflags + ; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETBr implicit $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + + ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax + ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + + $eflags = COPY %2 + JA_1 %bb.1, implicit $eflags + JB_1 %bb.2, implicit $eflags + JMP_1 %bb.3 + ; CHECK-NOT: $eflags = + ; + ; CHECK: TEST8ri %[[A_REG]], -1, implicit-def $eflags + ; CHECK-NEXT: JNE_1 %bb.1, implicit killed $eflags + ; CHECK-SAME: {{$[[:space:]]}} + ; CHECK-NEXT: bb.4: + ; CHECK-NEXT: successors: {{.*$}} + ; CHECK-SAME: {{$[[:space:]]}} + ; CHECK-NEXT: TEST8ri %[[B_REG]], -1, implicit-def $eflags + ; CHECK-NEXT: JNE_1 %bb.2, implicit killed $eflags + ; CHECK-NEXT: JMP_1 %bb.3 + + bb.1: + %3:gr32 = MOV32ri64 42 + $eax = COPY %3 + RET 0, $eax + + bb.2: + %4:gr32 = MOV32ri64 43 + $eax = COPY %4 + RET 0, $eax + + bb.3: + %5:gr32 = MOV32r0 implicit-def dead $eflags + $eax = COPY %5 + RET 0, $eax + +... +--- +name: test_branch_fallthrough +# CHECK-LABEL: name: test_branch_fallthrough +liveins: + - { reg: '$rdi', virtual-reg: '%0' } + - { reg: '$rsi', virtual-reg: '%1' } +body: | + bb.0: + successors: %bb.1, %bb.2, %bb.3 + liveins: $rdi, $rsi + + %0:gr64 = COPY $rdi + %1:gr64 = COPY $rsi + CMP64rr %0, %1, implicit-def $eflags + %2:gr64 = COPY $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + ; CHECK: %[[A_REG:[^:]*]]:gr8 = SETAr implicit $eflags + ; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETBr implicit $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + + ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax + ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + + $eflags = COPY %2 + JA_1 %bb.2, implicit $eflags + JB_1 %bb.3, implicit $eflags + ; CHECK-NOT: $eflags = + ; + ; CHECK: TEST8ri %[[A_REG]], -1, implicit-def $eflags + ; CHECK-NEXT: JNE_1 %bb.2, implicit killed $eflags + ; CHECK-SAME: {{$[[:space:]]}} + ; CHECK-NEXT: bb.4: + ; CHECK-NEXT: successors: {{.*$}} + ; CHECK-SAME: {{$[[:space:]]}} + ; CHECK-NEXT: TEST8ri %[[B_REG]], -1, implicit-def $eflags + ; CHECK-NEXT: JNE_1 %bb.3, implicit killed $eflags + ; CHECK-SAME: {{$[[:space:]]}} + ; CHECK-NEXT: bb.1: + + bb.1: + %5:gr32 = MOV32r0 implicit-def dead $eflags + $eax = COPY %5 + RET 0, $eax + + bb.2: + %3:gr32 = MOV32ri64 42 + $eax = COPY %3 + RET 0, $eax + + bb.3: + %4:gr32 = MOV32ri64 43 + $eax = COPY %4 + RET 0, $eax + +... +--- +name: test_setcc +# CHECK-LABEL: name: test_setcc +liveins: + - { reg: '$rdi', virtual-reg: '%0' } + - { reg: '$rsi', virtual-reg: '%1' } +body: | + bb.0: + liveins: $rdi, $rsi + + %0:gr64 = COPY $rdi + %1:gr64 = COPY $rsi + CMP64rr %0, %1, implicit-def $eflags + %2:gr64 = COPY $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + ; CHECK: %[[A_REG:[^:]*]]:gr8 = SETAr implicit $eflags + ; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETBr implicit $eflags + ; CHECK-NEXT: %[[E_REG:[^:]*]]:gr8 = SETEr implicit $eflags + ; CHECK-NEXT: %[[NE_REG:[^:]*]]:gr8 = SETNEr implicit $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + + ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax + ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + + $eflags = COPY %2 + %3:gr8 = SETAr implicit $eflags + %4:gr8 = SETBr implicit $eflags + %5:gr8 = SETEr implicit $eflags + %6:gr8 = SETNEr implicit killed $eflags + MOV8mr $rsp, 1, $noreg, -16, $noreg, killed %3 + MOV8mr $rsp, 1, $noreg, -16, $noreg, killed %4 + MOV8mr $rsp, 1, $noreg, -16, $noreg, killed %5 + MOV8mr $rsp, 1, $noreg, -16, $noreg, killed %6 + ; CHECK-NOT: $eflags = + ; CHECK-NOT: = SET{{.*}} + ; CHECK: MOV8mr {{.*}}, killed %[[A_REG]] + ; CHECK-CHECK: MOV8mr {{.*}}, killed %[[B_REG]] + ; CHECK-CHECK: MOV8mr {{.*}}, killed %[[E_REG]] + ; CHECK-CHECK: MOV8mr {{.*}}, killed %[[NE_REG]] + + RET 0 + +... +--- +name: test_cmov +# CHECK-LABEL: name: test_cmov +liveins: + - { reg: '$rdi', virtual-reg: '%0' } + - { reg: '$rsi', virtual-reg: '%1' } +body: | + bb.0: + liveins: $rdi, $rsi + + %0:gr64 = COPY $rdi + %1:gr64 = COPY $rsi + CMP64rr %0, %1, implicit-def $eflags + %2:gr64 = COPY $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + ; CHECK: %[[A_REG:[^:]*]]:gr8 = SETAr implicit $eflags + ; CHECK-NEXT: %[[B_REG:[^:]*]]:gr8 = SETBr implicit $eflags + ; CHECK-NEXT: %[[E_REG:[^:]*]]:gr8 = SETEr implicit $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + + ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax + ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + + $eflags = COPY %2 + %3:gr64 = CMOVA64rr %0, %1, implicit $eflags + %4:gr64 = CMOVB64rr %0, %1, implicit $eflags + %5:gr64 = CMOVE64rr %0, %1, implicit $eflags + %6:gr64 = CMOVNE64rr %0, %1, implicit killed $eflags + ; CHECK-NOT: $eflags = + ; CHECK: TEST8ri %[[A_REG]], -1, implicit-def $eflags + ; CHECK-NEXT: %3:gr64 = CMOVNE64rr %0, %1, implicit killed $eflags + ; CHECK-NEXT: TEST8ri %[[B_REG]], -1, implicit-def $eflags + ; CHECK-NEXT: %4:gr64 = CMOVNE64rr %0, %1, implicit killed $eflags + ; CHECK-NEXT: TEST8ri %[[E_REG]], -1, implicit-def $eflags + ; CHECK-NEXT: %5:gr64 = CMOVNE64rr %0, %1, implicit killed $eflags + ; CHECK-NEXT: TEST8ri %[[E_REG]], -1, implicit-def $eflags + ; CHECK-NEXT: %6:gr64 = CMOVE64rr %0, %1, implicit killed $eflags + MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %3 + MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %4 + MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5 + MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %6 + + RET 0 + +... +--- +name: test_adc +# CHECK-LABEL: name: test_adc +liveins: + - { reg: '$rdi', virtual-reg: '%0' } + - { reg: '$rsi', virtual-reg: '%1' } +body: | + bb.0: + liveins: $rdi, $rsi + + %0:gr64 = COPY $rdi + %1:gr64 = COPY $rsi + %2:gr64 = ADD64rr %0, %1, implicit-def $eflags + %3:gr64 = COPY $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + ; CHECK: %[[CF_REG:[^:]*]]:gr8 = SETBr implicit $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + + ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax + ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + + $eflags = COPY %3 + %4:gr64 = ADC64ri32 %2:gr64, 42, implicit-def $eflags, implicit $eflags + %5:gr64 = ADC64ri32 %4:gr64, 42, implicit-def $eflags, implicit $eflags + ; CHECK-NOT: $eflags = + ; CHECK: dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 127, implicit-def $eflags + ; CHECK-NEXT: %4:gr64 = ADC64ri32 %2, 42, implicit-def $eflags, implicit killed $eflags + ; CHECK-NEXT: %5:gr64 = ADC64ri32 %4, 42, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags + MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5 + + RET 0 + +... +--- +name: test_sbb +# CHECK-LABEL: name: test_sbb +liveins: + - { reg: '$rdi', virtual-reg: '%0' } + - { reg: '$rsi', virtual-reg: '%1' } +body: | + bb.0: + liveins: $rdi, $rsi + + %0:gr64 = COPY $rdi + %1:gr64 = COPY $rsi + %2:gr64 = SUB64rr %0, %1, implicit-def $eflags + %3:gr64 = COPY killed $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + ; CHECK: %[[CF_REG:[^:]*]]:gr8 = SETBr implicit $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + + ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax + ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + + $eflags = COPY %3 + %4:gr64 = SBB64ri32 %2:gr64, 42, implicit-def $eflags, implicit killed $eflags + %5:gr64 = SBB64ri32 %4:gr64, 42, implicit-def dead $eflags, implicit killed $eflags + ; CHECK-NOT: $eflags = + ; CHECK: dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 127, implicit-def $eflags + ; CHECK-NEXT: %4:gr64 = SBB64ri32 %2, 42, implicit-def $eflags, implicit killed $eflags + ; CHECK-NEXT: %5:gr64 = SBB64ri32 %4, 42, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags + MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5 + + RET 0 + +... +--- +name: test_adcx +# CHECK-LABEL: name: test_adcx +liveins: + - { reg: '$rdi', virtual-reg: '%0' } + - { reg: '$rsi', virtual-reg: '%1' } +body: | + bb.0: + liveins: $rdi, $rsi + + %0:gr64 = COPY $rdi + %1:gr64 = COPY $rsi + %2:gr64 = ADD64rr %0, %1, implicit-def $eflags + %3:gr64 = COPY $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + ; CHECK: %[[E_REG:[^:]*]]:gr8 = SETEr implicit $eflags + ; CHECK-NEXT: %[[CF_REG:[^:]*]]:gr8 = SETBr implicit $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + + ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax + ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + + $eflags = COPY %3 + %4:gr64 = CMOVE64rr %0, %1, implicit $eflags + %5:gr64 = MOV64ri32 42 + %6:gr64 = ADCX64rr %2, %5, implicit-def $eflags, implicit $eflags + ; CHECK-NOT: $eflags = + ; CHECK: TEST8ri %[[E_REG]], -1, implicit-def $eflags + ; CHECK-NEXT: %4:gr64 = CMOVNE64rr %0, %1, implicit killed $eflags + ; CHECK-NEXT: %5:gr64 = MOV64ri32 42 + ; CHECK-NEXT: dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 127, implicit-def $eflags + ; CHECK-NEXT: %6:gr64 = ADCX64rr %2, %5, implicit-def{{( dead)?}} $eflags, implicit killed $eflags + MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %4 + MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %6 + + RET 0 + +... +--- +name: test_adox +# CHECK-LABEL: name: test_adox +liveins: + - { reg: '$rdi', virtual-reg: '%0' } + - { reg: '$rsi', virtual-reg: '%1' } +body: | + bb.0: + liveins: $rdi, $rsi + + %0:gr64 = COPY $rdi + %1:gr64 = COPY $rsi + %2:gr64 = ADD64rr %0, %1, implicit-def $eflags + %3:gr64 = COPY $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + ; CHECK: %[[E_REG:[^:]*]]:gr8 = SETEr implicit $eflags + ; CHECK-NEXT: %[[OF_REG:[^:]*]]:gr8 = SETOr implicit $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + + ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax + ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + + $eflags = COPY %3 + %4:gr64 = CMOVE64rr %0, %1, implicit $eflags + %5:gr64 = MOV64ri32 42 + %6:gr64 = ADOX64rr %2, %5, implicit-def $eflags, implicit $eflags + ; CHECK-NOT: $eflags = + ; CHECK: TEST8ri %[[E_REG]], -1, implicit-def $eflags + ; CHECK-NEXT: %4:gr64 = CMOVNE64rr %0, %1, implicit killed $eflags + ; CHECK-NEXT: %5:gr64 = MOV64ri32 42 + ; CHECK-NEXT: dead %{{[^:]*}}:gr8 = ADD8ri %[[OF_REG]], 255, implicit-def $eflags + ; CHECK-NEXT: %6:gr64 = ADOX64rr %2, %5, implicit-def{{( dead)?}} $eflags, implicit killed $eflags + MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %4 + MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %6 + + RET 0 + +... +--- +name: test_rcl +# CHECK-LABEL: name: test_rcl +liveins: + - { reg: '$rdi', virtual-reg: '%0' } + - { reg: '$rsi', virtual-reg: '%1' } +body: | + bb.0: + liveins: $rdi, $rsi + + %0:gr64 = COPY $rdi + %1:gr64 = COPY $rsi + %2:gr64 = ADD64rr %0, %1, implicit-def $eflags + %3:gr64 = COPY $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + ; CHECK: %[[CF_REG:[^:]*]]:gr8 = SETBr implicit $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + + ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax + ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + + $eflags = COPY %3 + %4:gr64 = RCL64r1 %2:gr64, implicit-def $eflags, implicit $eflags + %5:gr64 = RCL64r1 %4:gr64, implicit-def $eflags, implicit $eflags + ; CHECK-NOT: $eflags = + ; CHECK: dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 127, implicit-def $eflags + ; CHECK-NEXT: %4:gr64 = RCL64r1 %2, implicit-def $eflags, implicit killed $eflags + ; CHECK-NEXT: %5:gr64 = RCL64r1 %4, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags + MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5 + + RET 0 + +... +--- +name: test_rcr +# CHECK-LABEL: name: test_rcr +liveins: + - { reg: '$rdi', virtual-reg: '%0' } + - { reg: '$rsi', virtual-reg: '%1' } +body: | + bb.0: + liveins: $rdi, $rsi + + %0:gr64 = COPY $rdi + %1:gr64 = COPY $rsi + %2:gr64 = ADD64rr %0, %1, implicit-def $eflags + %3:gr64 = COPY $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + ; CHECK: %[[CF_REG:[^:]*]]:gr8 = SETBr implicit $eflags + ; CHECK-NOT: COPY{{( killed)?}} $eflags + + ADJCALLSTACKDOWN64 0, 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + CALL64pcrel32 @foo, csr_64, implicit $rsp, implicit $ssp, implicit $rdi, implicit-def $rsp, implicit-def $ssp, implicit-def $eax + ADJCALLSTACKUP64 0, 0, implicit-def dead $rsp, implicit-def dead $eflags, implicit-def dead $ssp, implicit $rsp, implicit $ssp + + $eflags = COPY %3 + %4:gr64 = RCR64r1 %2:gr64, implicit-def $eflags, implicit $eflags + %5:gr64 = RCR64r1 %4:gr64, implicit-def $eflags, implicit $eflags + ; CHECK-NOT: $eflags = + ; CHECK: dead %{{[^:]*}}:gr8 = ADD8ri %[[CF_REG]], 127, implicit-def $eflags + ; CHECK-NEXT: %4:gr64 = RCR64r1 %2, implicit-def $eflags, implicit killed $eflags + ; CHECK-NEXT: %5:gr64 = RCR64r1 %4, implicit-def{{( dead)?}} $eflags, implicit{{( killed)?}} $eflags + MOV64mr $rsp, 1, $noreg, -16, $noreg, killed %5 + + RET 0 + +... Index: llvm/test/CodeGen/X86/mul-i1024.ll =================================================================== --- llvm/test/CodeGen/X86/mul-i1024.ll +++ llvm/test/CodeGen/X86/mul-i1024.ll @@ -23,13 +23,13 @@ ; X32-NEXT: movl %eax, -440(%ebp) # 4-byte Spill ; X32-NEXT: mull %ecx ; X32-NEXT: xorl %ecx, %ecx -; X32-NEXT: movl %edx, -140(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -132(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -144(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -136(%ebp) # 4-byte Spill ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: adcl %edi, %edx ; X32-NEXT: movl %edx, -884(%ebp) # 4-byte Spill ; X32-NEXT: movl 32(%esi), %eax -; X32-NEXT: movl %eax, -416(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -420(%ebp) # 4-byte Spill ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, -400(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -324(%ebp) # 4-byte Spill @@ -42,47 +42,43 @@ ; X32-NEXT: movl %eax, -892(%ebp) # 4-byte Spill ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 36(%eax), %eax -; X32-NEXT: movl %eax, -148(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -152(%ebp) # 4-byte Spill ; X32-NEXT: xorl %edx, %edx ; X32-NEXT: mull %edx -; X32-NEXT: movl %edx, -236(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -228(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, %edi -; X32-NEXT: movl %eax, -304(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -96(%ebp) # 4-byte Spill ; X32-NEXT: addl %ecx, %edi -; X32-NEXT: movl %edi, -80(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -72(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %eax ; X32-NEXT: adcl $0, %eax -; X32-NEXT: movl %eax, -220(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -352(%ebp) # 4-byte Spill ; X32-NEXT: movl 36(%esi), %eax ; X32-NEXT: movl %eax, -316(%ebp) # 4-byte Spill ; X32-NEXT: xorl %ecx, %ecx ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %edx, -124(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -128(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -184(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, %edx ; X32-NEXT: movl -400(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl %esi, %edx ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: movl %ecx, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -40(%ebp) # 4-byte Spill ; X32-NEXT: movl -324(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl %ebx, -100(%ebp) # 4-byte Spill ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -656(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -660(%ebp) # 4-byte Spill ; X32-NEXT: leal (%ebx,%edi), %eax ; X32-NEXT: movl %edx, %edi ; X32-NEXT: leal (%ecx,%edx), %edx ; X32-NEXT: adcl %eax, %edx -; X32-NEXT: movl %edx, -700(%ebp) # 4-byte Spill -; X32-NEXT: seto %al -; X32-NEXT: lahf -; X32-NEXT: movl %eax, %eax -; X32-NEXT: movl %eax, -640(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -96(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -704(%ebp) # 4-byte Spill +; X32-NEXT: setb -112(%ebp) # 1-byte Folded Spill ; X32-NEXT: addl %ecx, %edi -; X32-NEXT: movl %edi, -112(%ebp) # 4-byte Spill -; X32-NEXT: adcl %esi, -64(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl %edi, -116(%ebp) # 4-byte Spill +; X32-NEXT: adcl %esi, -40(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl %esi, %ebx ; X32-NEXT: setb -160(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl 12(%ebp), %eax @@ -101,34 +97,34 @@ ; X32-NEXT: movl %eax, -180(%ebp) # 4-byte Spill ; X32-NEXT: addl %esi, %eax ; X32-NEXT: adcl %edi, %edx -; X32-NEXT: movl %edx, -428(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -540(%ebp) # 4-byte Spill ; X32-NEXT: movl (%ecx), %eax -; X32-NEXT: movl %eax, -260(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -252(%ebp) # 4-byte Spill ; X32-NEXT: xorl %ecx, %ecx ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -264(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -136(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -256(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -140(%ebp) # 4-byte Spill ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movl %edx, %eax ; X32-NEXT: adcl %edi, %eax -; X32-NEXT: movl %eax, -452(%ebp) # 4-byte Spill -; X32-NEXT: movl -132(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %eax, -448(%ebp) # 4-byte Spill +; X32-NEXT: movl -136(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %esi, %eax -; X32-NEXT: movl -140(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -144(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %edi, %eax -; X32-NEXT: movl %eax, -764(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -760(%ebp) # 4-byte Spill ; X32-NEXT: movl -324(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movl %esi, %ecx ; X32-NEXT: adcl %edi, %ebx -; X32-NEXT: movl %ebx, -424(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -432(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %ebx -; X32-NEXT: movl %edi, -256(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -248(%ebp) # 4-byte Spill ; X32-NEXT: movl -100(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -80(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl %eax, -72(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -204(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -220(%ebp) # 4-byte Folded Spill -; X32-NEXT: setb -388(%ebp) # 1-byte Folded Spill +; X32-NEXT: adcl %eax, -352(%ebp) # 4-byte Folded Spill +; X32-NEXT: setb -304(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 4(%eax), %eax ; X32-NEXT: movl %eax, -92(%ebp) # 4-byte Spill @@ -138,17 +134,17 @@ ; X32-NEXT: addl %ebx, %edi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: adcl $0, %esi -; X32-NEXT: movl %ecx, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -32(%ebp) # 4-byte Spill ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: movl %edi, -16(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %esi ; X32-NEXT: setb %bh ; X32-NEXT: addl %eax, %esi -; X32-NEXT: movl %esi, -76(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -64(%ebp) # 4-byte Spill ; X32-NEXT: movzbl %bh, %eax ; X32-NEXT: adcl %edx, %eax ; X32-NEXT: movl %eax, %edi -; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 8(%eax), %eax ; X32-NEXT: movl %eax, -108(%ebp) # 4-byte Spill @@ -157,10 +153,10 @@ ; X32-NEXT: movl %eax, -104(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, -156(%ebp) # 4-byte Spill ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl -256(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -248(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %edx, %eax ; X32-NEXT: addl %esi, %ecx -; X32-NEXT: movl %ecx, -120(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -124(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %eax ; X32-NEXT: movl %eax, -60(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %eax @@ -168,11 +164,11 @@ ; X32-NEXT: movl %eax, -340(%ebp) # 4-byte Spill ; X32-NEXT: mull %ebx ; X32-NEXT: movl %eax, %edi -; X32-NEXT: movl -140(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -144(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: adcl $0, %esi -; X32-NEXT: movl -132(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -136(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl %ebx, %edi ; X32-NEXT: movl %edi, -192(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ecx, %esi @@ -193,32 +189,32 @@ ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %edx, %edi ; X32-NEXT: addl %esi, %ebx -; X32-NEXT: movl %ebx, -272(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -264(%ebp) # 4-byte Spill ; X32-NEXT: adcl -216(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl %edi, -24(%ebp) # 4-byte Spill -; X32-NEXT: addl -28(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -32(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -68(%ebp) # 4-byte Spill ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl -16(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -420(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -428(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: adcl -120(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -616(%ebp) # 4-byte Spill +; X32-NEXT: adcl -124(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -620(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: adcl -60(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -612(%ebp) # 4-byte Spill -; X32-NEXT: movl -64(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl %eax, -616(%ebp) # 4-byte Spill +; X32-NEXT: movl -40(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl -184(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -40(%ebp) # 4-byte Spill ; X32-NEXT: movzbl -160(%ebp), %eax # 1-byte Folded Reload -; X32-NEXT: adcl -124(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -152(%ebp) # 4-byte Spill +; X32-NEXT: adcl -128(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -384(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 40(%eax), %eax -; X32-NEXT: movl %eax, -352(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -356(%ebp) # 4-byte Spill ; X32-NEXT: xorl %ecx, %ecx ; X32-NEXT: mull %ecx -; X32-NEXT: movl %eax, -364(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -368(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %edx, -396(%ebp) # 4-byte Spill ; X32-NEXT: movl -324(%ebp), %edx # 4-byte Reload @@ -227,24 +223,21 @@ ; X32-NEXT: movl -400(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %ebx, %ecx ; X32-NEXT: addl %esi, %edi -; X32-NEXT: movl %edi, -44(%ebp) # 4-byte Spill -; X32-NEXT: adcl -152(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -52(%ebp) # 4-byte Spill -; X32-NEXT: addl -28(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -32(%ebp) # 4-byte Spill -; X32-NEXT: movl -112(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %edi, -48(%ebp) # 4-byte Spill +; X32-NEXT: adcl -384(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -56(%ebp) # 4-byte Spill +; X32-NEXT: addl -32(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl -116(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl -16(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -196(%ebp) # 4-byte Spill -; X32-NEXT: seto %al -; X32-NEXT: lahf -; X32-NEXT: movl %eax, %eax -; X32-NEXT: movl %eax, -456(%ebp) # 4-byte Spill +; X32-NEXT: setb -452(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl %edi, %eax -; X32-NEXT: adcl -120(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -504(%ebp) # 4-byte Spill +; X32-NEXT: adcl -124(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -508(%ebp) # 4-byte Spill ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: adcl -60(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -508(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -504(%ebp) # 4-byte Spill ; X32-NEXT: movl 12(%ebp), %ecx ; X32-NEXT: movl 16(%ecx), %eax ; X32-NEXT: movl %eax, -212(%ebp) # 4-byte Spill @@ -252,16 +245,16 @@ ; X32-NEXT: mull %ebx ; X32-NEXT: movl %eax, %edi ; X32-NEXT: movl %edx, %esi -; X32-NEXT: movl %edx, -84(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -80(%ebp) # 4-byte Spill ; X32-NEXT: movl 20(%ecx), %eax -; X32-NEXT: movl %eax, -252(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -244(%ebp) # 4-byte Spill ; X32-NEXT: mull %ebx ; X32-NEXT: movl %eax, %ebx ; X32-NEXT: addl %esi, %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: addl %edi, %ebx -; X32-NEXT: movl %ebx, -164(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -28(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: addl %eax, %ecx @@ -269,60 +262,60 @@ ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 24(%eax), %eax -; X32-NEXT: movl %eax, -284(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -280(%ebp) # 4-byte Spill ; X32-NEXT: xorl %edx, %edx ; X32-NEXT: mull %edx ; X32-NEXT: movl %eax, -308(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, -208(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %ebx ; X32-NEXT: addl %eax, %ebx -; X32-NEXT: movl -84(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -80(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %edx, %eax ; X32-NEXT: addl %ecx, %ebx -; X32-NEXT: movl %ebx, -40(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -164(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %eax ; X32-NEXT: movl %eax, %edx ; X32-NEXT: movl -324(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl %edi, -116(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -120(%ebp) # 4-byte Spill ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movl -400(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -84(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -80(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %ecx, %eax -; X32-NEXT: movl %eax, -768(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -764(%ebp) # 4-byte Spill ; X32-NEXT: movl %esi, %eax ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -296(%ebp) # 4-byte Spill -; X32-NEXT: movl -112(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -164(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl %eax, -292(%ebp) # 4-byte Spill +; X32-NEXT: movl -116(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -28(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %esi, %eax -; X32-NEXT: movl %eax, -776(%ebp) # 4-byte Spill -; X32-NEXT: movl -44(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %ebx, %eax ; X32-NEXT: movl %eax, -772(%ebp) # 4-byte Spill -; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %edx, %eax +; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %ebx, %eax +; X32-NEXT: movl %eax, -768(%ebp) # 4-byte Spill +; X32-NEXT: movl -56(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: movl %edx, -56(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -780(%ebp) # 4-byte Spill -; X32-NEXT: movl -132(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl %edx, -76(%ebp) # 4-byte Spill +; X32-NEXT: adcl %edx, %eax +; X32-NEXT: movl %eax, -776(%ebp) # 4-byte Spill +; X32-NEXT: movl -136(%ebp), %edx # 4-byte Reload ; X32-NEXT: movl %edx, %eax ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl -140(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -144(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %ecx, %eax -; X32-NEXT: movl %eax, -448(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -780(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %eax ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movl %eax, -332(%ebp) # 4-byte Spill ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %esi, %eax ; X32-NEXT: movl %eax, -648(%ebp) # 4-byte Spill -; X32-NEXT: movl -272(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -40(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -644(%ebp) # 4-byte Spill +; X32-NEXT: movl -264(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -164(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -576(%ebp) # 4-byte Spill ; X32-NEXT: movl -24(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %ebx, %eax -; X32-NEXT: movl %eax, -572(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -500(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 20(%eax), %eax ; X32-NEXT: movl %eax, -216(%ebp) # 4-byte Spill @@ -335,7 +328,7 @@ ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: movl -180(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl %edi, %esi -; X32-NEXT: movl %esi, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -52(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: addl %eax, %ecx @@ -343,50 +336,50 @@ ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 24(%eax), %eax -; X32-NEXT: movl %eax, -288(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -284(%ebp) # 4-byte Spill ; X32-NEXT: xorl %edx, %edx ; X32-NEXT: mull %edx -; X32-NEXT: movl %eax, -280(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -276(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, -312(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %edx ; X32-NEXT: addl %eax, %edi ; X32-NEXT: movl -320(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl -312(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: addl %ecx, %edi -; X32-NEXT: movl %edi, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -44(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ebx ; X32-NEXT: movl %ebx, -20(%ebp) # 4-byte Spill -; X32-NEXT: addl -28(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -228(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl -32(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -220(%ebp) # 4-byte Spill +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl -16(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -596(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -460(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax -; X32-NEXT: adcl -120(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -464(%ebp) # 4-byte Spill +; X32-NEXT: adcl -124(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -652(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: adcl -60(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -536(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -600(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 4(%eax), %eax -; X32-NEXT: movl %eax, -124(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -128(%ebp) # 4-byte Spill ; X32-NEXT: xorl %ecx, %ecx ; X32-NEXT: mull %ecx ; X32-NEXT: movl %eax, %esi -; X32-NEXT: movl -264(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -256(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl %ecx, %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: adcl $0, %edi -; X32-NEXT: movl -136(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -140(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl %ebx, %esi -; X32-NEXT: movl %esi, -276(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -272(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ecx, %edi ; X32-NEXT: setb %cl ; X32-NEXT: addl %eax, %edi -; X32-NEXT: movl %edi, -584(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -588(%ebp) # 4-byte Spill ; X32-NEXT: movzbl %cl, %eax ; X32-NEXT: adcl %edx, %eax -; X32-NEXT: movl %eax, -432(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -436(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 8(%eax), %eax ; X32-NEXT: movl %eax, -184(%ebp) # 4-byte Spill @@ -394,56 +387,51 @@ ; X32-NEXT: mull %ecx ; X32-NEXT: movl %eax, %ecx ; X32-NEXT: movl %eax, -160(%ebp) # 4-byte Spill -; X32-NEXT: movl %edx, -268(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -260(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %esi ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl -264(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -256(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %ecx ; X32-NEXT: adcl %edx, %ecx ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -240(%ebp) # 4-byte Spill -; X32-NEXT: adcl -432(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %eax, -232(%ebp) # 4-byte Spill +; X32-NEXT: adcl -436(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %esi, %edx -; X32-NEXT: addl -28(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -32(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -344(%ebp) # 4-byte Spill -; X32-NEXT: movl -276(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -272(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %edx ; X32-NEXT: adcl -16(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -404(%ebp) # 4-byte Spill -; X32-NEXT: pushl %eax -; X32-NEXT: seto %al -; X32-NEXT: lahf -; X32-NEXT: movl %eax, %edx -; X32-NEXT: popl %eax -; X32-NEXT: movl %edx, -736(%ebp) # 4-byte Spill +; X32-NEXT: setb -529(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl %eax, %edx -; X32-NEXT: adcl -120(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -532(%ebp) # 4-byte Spill +; X32-NEXT: adcl -124(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -596(%ebp) # 4-byte Spill ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl %ecx, -172(%ebp) # 4-byte Spill ; X32-NEXT: adcl -60(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -592(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -536(%ebp) # 4-byte Spill ; X32-NEXT: movl %esi, %edx ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -116(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -120(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -84(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -80(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl %ebx, %eax ; X32-NEXT: movl %eax, -328(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %eax ; X32-NEXT: addl %esi, %eax -; X32-NEXT: movl %eax, -368(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -376(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax -; X32-NEXT: adcl -164(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -620(%ebp) # 4-byte Spill -; X32-NEXT: movl -240(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -40(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -28(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl %edi, %eax +; X32-NEXT: movl %eax, -624(%ebp) # 4-byte Spill +; X32-NEXT: movl -232(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -164(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -788(%ebp) # 4-byte Spill ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: adcl -56(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -76(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -784(%ebp) # 4-byte Spill ; X32-NEXT: movl -180(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -100(%ebp), %edx # 4-byte Reload @@ -453,80 +441,78 @@ ; X32-NEXT: movl -204(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %ecx, %eax ; X32-NEXT: movl %eax, -804(%ebp) # 4-byte Spill -; X32-NEXT: movl -136(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -140(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %edx, %eax -; X32-NEXT: movl -264(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -256(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %ecx, %eax ; X32-NEXT: movl %eax, -820(%ebp) # 4-byte Spill ; X32-NEXT: movl -180(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -116(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -120(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %edx, %eax ; X32-NEXT: adcl %ebx, %esi -; X32-NEXT: movl %esi, -576(%ebp) # 4-byte Spill -; X32-NEXT: addl %edx, %ecx -; X32-NEXT: movl %ecx, -540(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -164(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -800(%ebp) # 4-byte Spill -; X32-NEXT: movl -36(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %esi, -580(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, %eax +; X32-NEXT: addl %edx, %eax +; X32-NEXT: movl %eax, -544(%ebp) # 4-byte Spill +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %edi, %eax +; X32-NEXT: movl %eax, -800(%ebp) # 4-byte Spill +; X32-NEXT: movl -44(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -164(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -796(%ebp) # 4-byte Spill ; X32-NEXT: movl -20(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -56(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -76(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -792(%ebp) # 4-byte Spill -; X32-NEXT: movl -220(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -304(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -220(%ebp) # 4-byte Spill -; X32-NEXT: movzbl -388(%ebp), %eax # 1-byte Folded Reload -; X32-NEXT: adcl -236(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -376(%ebp) # 4-byte Spill +; X32-NEXT: movl -352(%ebp), %esi # 4-byte Reload +; X32-NEXT: addl -96(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -352(%ebp) # 4-byte Spill +; X32-NEXT: movzbl -304(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: adcl -228(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -288(%ebp) # 4-byte Spill ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 40(%eax), %eax -; X32-NEXT: movl %eax, -236(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -228(%ebp) # 4-byte Spill ; X32-NEXT: xorl %ecx, %ecx ; X32-NEXT: mull %ecx ; X32-NEXT: movl %eax, -304(%ebp) # 4-byte Spill -; X32-NEXT: movl %edx, -128(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, %ecx +; X32-NEXT: movl %edx, -132(%ebp) # 4-byte Spill ; X32-NEXT: movl -100(%ebp), %ebx # 4-byte Reload -; X32-NEXT: movl %ebx, %edi -; X32-NEXT: addl %eax, %edi -; X32-NEXT: movl -204(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: addl %esi, %edi -; X32-NEXT: adcl -376(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, %edx +; X32-NEXT: movl %ebx, %edx +; X32-NEXT: addl %eax, %edx +; X32-NEXT: movl -204(%ebp), %edi # 4-byte Reload +; X32-NEXT: adcl %ecx, %edi +; X32-NEXT: addl %esi, %edx +; X32-NEXT: adcl -288(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl -180(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -468(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -80(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %eax, -464(%ebp) # 4-byte Spill +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -72(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %ecx, %eax ; X32-NEXT: movl %eax, -816(%ebp) # 4-byte Spill -; X32-NEXT: movl -36(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %edi, %eax -; X32-NEXT: movl %edi, -372(%ebp) # 4-byte Spill +; X32-NEXT: movl -44(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %edx, %eax +; X32-NEXT: movl %edx, -380(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -812(%ebp) # 4-byte Spill ; X32-NEXT: movl -20(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl %edx, -292(%ebp) # 4-byte Spill -; X32-NEXT: adcl %edx, %eax +; X32-NEXT: adcl %edi, %eax +; X32-NEXT: movl %edi, -372(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -808(%ebp) # 4-byte Spill -; X32-NEXT: movl -136(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -140(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movl %eax, -512(%ebp) # 4-byte Spill -; X32-NEXT: movl -276(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -272(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %ecx, %eax -; X32-NEXT: movl %eax, -676(%ebp) # 4-byte Spill -; X32-NEXT: seto %al -; X32-NEXT: lahf -; X32-NEXT: movl %eax, %eax -; X32-NEXT: movl %eax, -740(%ebp) # 4-byte Spill -; X32-NEXT: movl -240(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %edi, %eax -; X32-NEXT: movl %eax, -624(%ebp) # 4-byte Spill -; X32-NEXT: movl -172(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %eax, -680(%ebp) # 4-byte Spill +; X32-NEXT: setb -644(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -232(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %edx, %eax ; X32-NEXT: movl %eax, -628(%ebp) # 4-byte Spill +; X32-NEXT: movl -172(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %edi, %eax +; X32-NEXT: movl %eax, -632(%ebp) # 4-byte Spill ; X32-NEXT: movl 12(%ebp), %esi ; X32-NEXT: movl 48(%esi), %eax ; X32-NEXT: movl %eax, -300(%ebp) # 4-byte Spill @@ -536,14 +522,14 @@ ; X32-NEXT: movl %eax, -336(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl 52(%esi), %eax -; X32-NEXT: movl %eax, -144(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -148(%ebp) # 4-byte Spill ; X32-NEXT: mull %ecx ; X32-NEXT: movl %eax, %esi ; X32-NEXT: addl %edi, %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: addl %ebx, %esi -; X32-NEXT: movl %esi, -200(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -268(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: addl %eax, %ecx @@ -551,72 +537,72 @@ ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 56(%eax), %eax -; X32-NEXT: movl %eax, -244(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -236(%ebp) # 4-byte Spill ; X32-NEXT: xorl %edx, %edx ; X32-NEXT: mull %edx -; X32-NEXT: movl %eax, -224(%ebp) # 4-byte Spill -; X32-NEXT: movl %edx, -360(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -200(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -364(%ebp) # 4-byte Spill ; X32-NEXT: movl -336(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: movl %edi, %edx ; X32-NEXT: movl %edi, -176(%ebp) # 4-byte Spill -; X32-NEXT: adcl -360(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: adcl -364(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: addl %ecx, %ebx -; X32-NEXT: movl %ebx, -472(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -296(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %edi -; X32-NEXT: movl %edi, -436(%ebp) # 4-byte Spill -; X32-NEXT: movl -136(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %edi, -468(%ebp) # 4-byte Spill +; X32-NEXT: movl -140(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -336(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl %esi, %eax -; X32-NEXT: movl -264(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -256(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %edx, %eax ; X32-NEXT: movl %eax, -824(%ebp) # 4-byte Spill ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: addl %esi, %eax -; X32-NEXT: movl %eax, -588(%ebp) # 4-byte Spill -; X32-NEXT: movl -276(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -200(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -632(%ebp) # 4-byte Spill -; X32-NEXT: movl -240(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %ebx, %eax +; X32-NEXT: movl %eax, -592(%ebp) # 4-byte Spill +; X32-NEXT: movl -272(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -268(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -636(%ebp) # 4-byte Spill +; X32-NEXT: movl -232(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -296(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -828(%ebp) # 4-byte Spill ; X32-NEXT: movl -172(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %edi, %eax -; X32-NEXT: movl %eax, -636(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -640(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 64(%eax), %eax -; X32-NEXT: movl %eax, -476(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -472(%ebp) # 4-byte Spill ; X32-NEXT: xorl %ecx, %ecx ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi -; X32-NEXT: movl %edx, -384(%ebp) # 4-byte Spill -; X32-NEXT: movl -116(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl %edx, -388(%ebp) # 4-byte Spill +; X32-NEXT: movl -120(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %ecx ; X32-NEXT: movl %eax, %edx -; X32-NEXT: movl %eax, -480(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -476(%ebp) # 4-byte Spill ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl -84(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -80(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: adcl %esi, %eax ; X32-NEXT: movl %eax, -920(%ebp) # 4-byte Spill -; X32-NEXT: movl -28(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: addl %edx, %eax -; X32-NEXT: movl -256(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -248(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: adcl -384(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -388(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -932(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 80(%eax), %eax -; X32-NEXT: movl %eax, -548(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -552(%ebp) # 4-byte Spill ; X32-NEXT: xorl %edx, %edx ; X32-NEXT: mull %edx -; X32-NEXT: movl %eax, -380(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -360(%ebp) # 4-byte Spill ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -380(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -360(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl %esi, %eax -; X32-NEXT: movl %edx, -356(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -416(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %ecx ; X32-NEXT: movl %ecx, -948(%ebp) # 4-byte Spill ; X32-NEXT: addl %esi, %edi @@ -624,25 +610,25 @@ ; X32-NEXT: movl %ebx, -960(%ebp) # 4-byte Spill ; X32-NEXT: movl 12(%ebp), %ecx ; X32-NEXT: movl 80(%ecx), %eax -; X32-NEXT: movl %eax, -552(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -556(%ebp) # 4-byte Spill ; X32-NEXT: xorl %ebx, %ebx ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, -528(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -524(%ebp) # 4-byte Spill -; X32-NEXT: movl -136(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -140(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movl %edx, %eax -; X32-NEXT: movl -264(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -256(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl %edi, %eax ; X32-NEXT: movl %eax, -976(%ebp) # 4-byte Spill ; X32-NEXT: movl 64(%ecx), %eax ; X32-NEXT: movl %eax, -520(%ebp) # 4-byte Spill ; X32-NEXT: mull %ebx -; X32-NEXT: movl %eax, -500(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -496(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, %ecx ; X32-NEXT: addl %esi, %ecx ; X32-NEXT: movl %edx, %esi -; X32-NEXT: movl %edx, -496(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -492(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: movl %ecx, -992(%ebp) # 4-byte Spill @@ -654,102 +640,95 @@ ; X32-NEXT: adcl %ecx, %eax ; X32-NEXT: movl %eax, -1008(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %eax -; X32-NEXT: movl -336(%ebp), %edi # 4-byte Reload -; X32-NEXT: addl %edi, %eax +; X32-NEXT: movl -336(%ebp), %ebx # 4-byte Reload +; X32-NEXT: addl %ebx, %eax ; X32-NEXT: adcl -176(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -832(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %eax -; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -672(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -200(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl %ebx, %eax +; X32-NEXT: movl %eax, -676(%ebp) # 4-byte Spill +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -268(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -836(%ebp) # 4-byte Spill -; X32-NEXT: movl -36(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -472(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl -44(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -296(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -840(%ebp) # 4-byte Spill ; X32-NEXT: movl -20(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -436(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -468(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -844(%ebp) # 4-byte Spill -; X32-NEXT: movl -132(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -136(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl -100(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -680(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -684(%ebp) # 4-byte Spill ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -80(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -72(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -856(%ebp) # 4-byte Spill -; X32-NEXT: movl -272(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -372(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl %edx, %eax +; X32-NEXT: movl -264(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -380(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl %ecx, %eax ; X32-NEXT: movl %eax, -852(%ebp) # 4-byte Spill ; X32-NEXT: movl -24(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -292(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %ecx, %eax +; X32-NEXT: movl -372(%ebp), %edx # 4-byte Reload +; X32-NEXT: adcl %edx, %eax ; X32-NEXT: movl %eax, -848(%ebp) # 4-byte Spill -; X32-NEXT: movl -44(%ebp), %ebx # 4-byte Reload -; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -96(%ebp), %esi # 4-byte Reload -; X32-NEXT: pushl %eax -; X32-NEXT: movl %esi, %eax +; X32-NEXT: movb -112(%ebp), %al # 1-byte Reload ; X32-NEXT: addb $127, %al -; X32-NEXT: sahf -; X32-NEXT: popl %eax -; X32-NEXT: adcl %edx, %eax -; X32-NEXT: movl %eax, -860(%ebp) # 4-byte Spill -; X32-NEXT: movl -52(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -48(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: adcl %ecx, %eax +; X32-NEXT: movl %eax, -860(%ebp) # 4-byte Spill +; X32-NEXT: movl -56(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl %edi, %eax +; X32-NEXT: adcl %edx, %eax ; X32-NEXT: movl %eax, -864(%ebp) # 4-byte Spill ; X32-NEXT: movl -324(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: addl %edi, %eax +; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movl -400(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -176(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl %edx, %eax ; X32-NEXT: movl %eax, -868(%ebp) # 4-byte Spill ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -684(%ebp) # 4-byte Spill -; X32-NEXT: movl -112(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -200(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl %ebx, %eax +; X32-NEXT: movl %eax, -688(%ebp) # 4-byte Spill +; X32-NEXT: movl -116(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -268(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -876(%ebp) # 4-byte Spill -; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -472(%ebp), %ebx # 4-byte Reload -; X32-NEXT: adcl %ebx, %eax -; X32-NEXT: movl %eax, -872(%ebp) # 4-byte Spill -; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -436(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl %esi, %eax -; X32-NEXT: movl %eax, -880(%ebp) # 4-byte Spill -; X32-NEXT: movl -132(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -296(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -872(%ebp) # 4-byte Spill +; X32-NEXT: movl -468(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl %esi, %edi +; X32-NEXT: movl %edi, -880(%ebp) # 4-byte Spill +; X32-NEXT: movl -136(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl -140(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %ebx, %eax +; X32-NEXT: movl -144(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %edx, %eax ; X32-NEXT: movl %eax, -888(%ebp) # 4-byte Spill ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -688(%ebp) # 4-byte Spill +; X32-NEXT: addl %ebx, %eax +; X32-NEXT: movl %eax, -692(%ebp) # 4-byte Spill ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -200(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -268(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -900(%ebp) # 4-byte Spill -; X32-NEXT: movl -272(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %ebx, %eax +; X32-NEXT: movl -264(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -296(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -896(%ebp) # 4-byte Spill ; X32-NEXT: movl -24(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %esi, %eax ; X32-NEXT: movl %eax, -904(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 68(%eax), %eax -; X32-NEXT: movl %eax, -248(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -240(%ebp) # 4-byte Spill ; X32-NEXT: xorl %ecx, %ecx ; X32-NEXT: mull %ecx ; X32-NEXT: movl %eax, %esi -; X32-NEXT: movl -384(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -388(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl %edi, %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: movl -480(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -476(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl %ebx, %esi -; X32-NEXT: movl %esi, -652(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -656(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb -96(%ebp) # 1-byte Folded Spill ; X32-NEXT: addl %eax, %ecx @@ -761,50 +740,50 @@ ; X32-NEXT: xorl %edx, %edx ; X32-NEXT: mull %edx ; X32-NEXT: movl %eax, %esi -; X32-NEXT: movl %eax, -484(%ebp) # 4-byte Spill -; X32-NEXT: movl %edx, -488(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -480(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -484(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: addl %esi, %eax -; X32-NEXT: movl -384(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -388(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl %edx, %ebx ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: adcl %edi, %ebx -; X32-NEXT: movl -116(%ebp), %ecx # 4-byte Reload -; X32-NEXT: movl -480(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -120(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -476(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %edx, %ecx -; X32-NEXT: movl %ecx, -692(%ebp) # 4-byte Spill -; X32-NEXT: movl -164(%ebp), %esi # 4-byte Reload -; X32-NEXT: movl -652(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %ecx, -696(%ebp) # 4-byte Spill +; X32-NEXT: movl -28(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -656(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi ; X32-NEXT: movl %esi, -908(%ebp) # 4-byte Spill -; X32-NEXT: movl -40(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -164(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %eax, %esi ; X32-NEXT: movl %esi, -916(%ebp) # 4-byte Spill -; X32-NEXT: movl -56(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -76(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ebx, %esi ; X32-NEXT: movl %esi, -912(%ebp) # 4-byte Spill -; X32-NEXT: movl -28(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl %edx, %esi -; X32-NEXT: movl %esi, -696(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -700(%ebp) # 4-byte Spill ; X32-NEXT: adcl -16(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -652(%ebp) # 4-byte Spill -; X32-NEXT: adcl -120(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -656(%ebp) # 4-byte Spill +; X32-NEXT: adcl -124(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -924(%ebp) # 4-byte Spill ; X32-NEXT: adcl -60(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl %ebx, -928(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %ecx ; X32-NEXT: movl 84(%ecx), %eax -; X32-NEXT: movl %eax, -544(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -548(%ebp) # 4-byte Spill ; X32-NEXT: xorl %ecx, %ecx ; X32-NEXT: mull %ecx ; X32-NEXT: movl %eax, %esi -; X32-NEXT: movl -356(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -416(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl %ebx, %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: movl -380(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -360(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl %edi, %esi -; X32-NEXT: movl %esi, -660(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -664(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: addl %eax, %ecx @@ -812,44 +791,44 @@ ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 88(%eax), %eax -; X32-NEXT: movl %eax, -580(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -584(%ebp) # 4-byte Spill ; X32-NEXT: xorl %edx, %edx ; X32-NEXT: mull %edx -; X32-NEXT: movl %eax, -600(%ebp) # 4-byte Spill -; X32-NEXT: movl %edx, -604(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -604(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -608(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %ebx ; X32-NEXT: addl %eax, %edi -; X32-NEXT: movl -356(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -416(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %edx, %eax ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: adcl %esi, %eax ; X32-NEXT: movl %eax, %esi -; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -704(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -708(%ebp) # 4-byte Spill ; X32-NEXT: movl -16(%ebp), %edx # 4-byte Reload -; X32-NEXT: movl -660(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -664(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, %edx ; X32-NEXT: movl %edx, -940(%ebp) # 4-byte Spill -; X32-NEXT: movl -120(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -124(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl %edi, %edx ; X32-NEXT: movl %edx, -944(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %edx ; X32-NEXT: movl -60(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl %esi, %edi ; X32-NEXT: movl %edi, -936(%ebp) # 4-byte Spill -; X32-NEXT: movl -116(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -120(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl %ebx, %edi -; X32-NEXT: movl %edi, -708(%ebp) # 4-byte Spill -; X32-NEXT: adcl -164(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -660(%ebp) # 4-byte Spill -; X32-NEXT: adcl -40(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edi, -712(%ebp) # 4-byte Spill +; X32-NEXT: adcl -28(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -664(%ebp) # 4-byte Spill +; X32-NEXT: adcl -164(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -952(%ebp) # 4-byte Spill -; X32-NEXT: adcl -56(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -76(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -956(%ebp) # 4-byte Spill ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 84(%eax), %eax -; X32-NEXT: movl %eax, -460(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -456(%ebp) # 4-byte Spill ; X32-NEXT: xorl %ecx, %ecx ; X32-NEXT: mull %ecx ; X32-NEXT: movl %eax, %edi @@ -858,7 +837,7 @@ ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: addl -524(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -668(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -672(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: addl %eax, %ecx @@ -866,29 +845,29 @@ ; X32-NEXT: adcl %edx, %edi ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 88(%eax), %eax -; X32-NEXT: movl %eax, -492(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -488(%ebp) # 4-byte Spill ; X32-NEXT: xorl %edx, %edx ; X32-NEXT: mull %edx ; X32-NEXT: movl %eax, %esi -; X32-NEXT: movl %eax, -556(%ebp) # 4-byte Spill -; X32-NEXT: movl %edx, -560(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -560(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -564(%ebp) # 4-byte Spill ; X32-NEXT: movl -524(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, %ebx ; X32-NEXT: addl %esi, %ebx ; X32-NEXT: movl -528(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: addl %ecx, %ebx -; X32-NEXT: movl %ebx, -732(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -736(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: movl %esi, %edx -; X32-NEXT: movl %esi, -728(%ebp) # 4-byte Spill -; X32-NEXT: addl -136(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -712(%ebp) # 4-byte Spill -; X32-NEXT: movl -668(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -276(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %esi, -732(%ebp) # 4-byte Spill +; X32-NEXT: addl -140(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -716(%ebp) # 4-byte Spill +; X32-NEXT: movl -672(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -272(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -968(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: adcl -240(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -232(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -964(%ebp) # 4-byte Spill ; X32-NEXT: adcl -172(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -972(%ebp) # 4-byte Spill @@ -899,12 +878,12 @@ ; X32-NEXT: mull %ecx ; X32-NEXT: xorl %ebx, %ebx ; X32-NEXT: movl %eax, %esi -; X32-NEXT: movl -496(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -492(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl %edi, %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -500(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -664(%ebp) # 4-byte Spill +; X32-NEXT: addl -496(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -668(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb -96(%ebp) # 1-byte Folded Spill ; X32-NEXT: addl %eax, %ecx @@ -912,28 +891,28 @@ ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 72(%eax), %eax -; X32-NEXT: movl %eax, -388(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -424(%ebp) # 4-byte Spill ; X32-NEXT: mull %ebx -; X32-NEXT: movl %eax, -564(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -568(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: movl %edx, -568(%ebp) # 4-byte Spill -; X32-NEXT: movl -500(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl %edx, -572(%ebp) # 4-byte Spill +; X32-NEXT: movl -496(%ebp), %edx # 4-byte Reload ; X32-NEXT: movl %edx, %edi ; X32-NEXT: addl %eax, %edi -; X32-NEXT: movl -496(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -492(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %ebx, %eax ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: adcl %esi, %eax ; X32-NEXT: movl %eax, %ecx ; X32-NEXT: movl %edx, %eax -; X32-NEXT: addl -136(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -716(%ebp) # 4-byte Spill -; X32-NEXT: movl -664(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl -140(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -720(%ebp) # 4-byte Spill +; X32-NEXT: movl -668(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, %esi -; X32-NEXT: adcl -276(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -272(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -988(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %esi -; X32-NEXT: adcl -240(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -232(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -984(%ebp) # 4-byte Spill ; X32-NEXT: movl %ecx, %esi ; X32-NEXT: adcl -172(%ebp), %esi # 4-byte Folded Reload @@ -941,11 +920,11 @@ ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl -180(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %edx, %esi -; X32-NEXT: movl %esi, -720(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl %esi, -724(%ebp) # 4-byte Spill +; X32-NEXT: movl -52(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %esi, %eax -; X32-NEXT: movl %eax, -664(%ebp) # 4-byte Spill -; X32-NEXT: movl -36(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl %eax, -668(%ebp) # 4-byte Spill +; X32-NEXT: movl -44(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl %ebx, %edi ; X32-NEXT: movl %edi, -996(%ebp) # 4-byte Spill ; X32-NEXT: movl -20(%ebp), %edi # 4-byte Reload @@ -959,10 +938,10 @@ ; X32-NEXT: movl %eax, -1004(%ebp) # 4-byte Spill ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: addl %edx, %eax -; X32-NEXT: movl %eax, -724(%ebp) # 4-byte Spill -; X32-NEXT: adcl %esi, -668(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl %ebx, -732(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl %edi, -728(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl %eax, -728(%ebp) # 4-byte Spill +; X32-NEXT: adcl %esi, -672(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %ebx, -736(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %edi, -732(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 12(%eax), %eax ; X32-NEXT: movl %eax, -96(%ebp) # 4-byte Spill @@ -975,64 +954,64 @@ ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: movl -104(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl %ecx, %edi -; X32-NEXT: movl %edi, -232(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -224(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ebx -; X32-NEXT: setb -88(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -84(%ebp) # 1-byte Folded Spill ; X32-NEXT: addl %eax, %ebx -; X32-NEXT: movzbl -88(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -84(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %edx, %eax ; X32-NEXT: movl %ecx, %edx ; X32-NEXT: addl %ecx, %ebx ; X32-NEXT: adcl %esi, %eax -; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill -; X32-NEXT: movl -28(%ebp), %edi # 4-byte Reload -; X32-NEXT: movl -76(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %eax, -84(%ebp) # 4-byte Spill +; X32-NEXT: movl -32(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -64(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl %edi, %ecx -; X32-NEXT: movl -72(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -256(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -88(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -248(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %ecx, %edx -; X32-NEXT: movl %edx, -72(%ebp) # 4-byte Spill -; X32-NEXT: movl -232(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl %edx, -88(%ebp) # 4-byte Spill +; X32-NEXT: movl -224(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl %esi, %edx ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl %edx, -76(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -64(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %edx ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl -88(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -84(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl $0, %esi -; X32-NEXT: addl %edi, -72(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl %edi, -88(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -16(%ebp), %edi # 4-byte Reload -; X32-NEXT: adcl %edi, -76(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %edi, -64(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: adcl $0, %eax ; X32-NEXT: addl %edx, %ecx ; X32-NEXT: adcl %esi, %eax ; X32-NEXT: setb %dl ; X32-NEXT: addl -104(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: adcl -232(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -224(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movzbl %dl, %edx ; X32-NEXT: adcl %ebx, %edx -; X32-NEXT: movl %edx, -608(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -88(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -28(%ebp), %ebx # 4-byte Reload -; X32-NEXT: addl -116(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl -164(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl %edx, -612(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -84(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -32(%ebp), %ebx # 4-byte Reload +; X32-NEXT: addl -120(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl -28(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl %edi, %edx -; X32-NEXT: movl -40(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -120(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -56(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -164(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -124(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -76(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl -60(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: addl %ecx, %ebx -; X32-NEXT: movl %ebx, -232(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -224(%ebp) # 4-byte Spill ; X32-NEXT: adcl %eax, %edx -; X32-NEXT: movl %edx, -164(%ebp) # 4-byte Spill -; X32-NEXT: adcl -608(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -40(%ebp) # 4-byte Spill -; X32-NEXT: adcl -88(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -56(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -28(%ebp) # 4-byte Spill +; X32-NEXT: adcl -612(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -164(%ebp) # 4-byte Spill +; X32-NEXT: adcl -84(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -76(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 44(%eax), %eax -; X32-NEXT: movl %eax, -120(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -124(%ebp) # 4-byte Spill ; X32-NEXT: xorl %ecx, %ecx ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi @@ -1041,7 +1020,7 @@ ; X32-NEXT: movl -396(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl %esi, %ecx ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl -364(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -368(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: movl %ecx, -60(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %edx @@ -1053,76 +1032,71 @@ ; X32-NEXT: movl %eax, %esi ; X32-NEXT: addl %eax, %edx ; X32-NEXT: adcl %ecx, %ebx -; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -40(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl -324(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl -152(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -384(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -400(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi -; X32-NEXT: movl %esi, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -40(%ebp) # 4-byte Spill ; X32-NEXT: movl -60(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi ; X32-NEXT: movl %esi, -16(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %esi ; X32-NEXT: adcl $0, %esi -; X32-NEXT: movl %esi, -88(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -84(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %edi ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl -324(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl %esi, -64(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl %esi, -40(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -16(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -112(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -116(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -16(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %eax ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -88(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -84(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl %edi, %ecx -; X32-NEXT: setb -88(%ebp) # 1-byte Folded Spill -; X32-NEXT: addl -364(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: setb -84(%ebp) # 1-byte Folded Spill +; X32-NEXT: addl -368(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -60(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movzbl -88(%ebp), %esi # 1-byte Folded Reload +; X32-NEXT: movzbl -84(%ebp), %esi # 1-byte Folded Reload ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl %esi, -60(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: movl -324(%ebp), %edx # 4-byte Reload -; X32-NEXT: addl -132(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -88(%ebp) # 4-byte Spill +; X32-NEXT: addl -136(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -84(%ebp) # 4-byte Spill ; X32-NEXT: movl -192(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl -112(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl -44(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -272(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -52(%ebp), %edi # 4-byte Reload +; X32-NEXT: adcl -116(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl -48(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -264(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -56(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl -24(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: addl %eax, -88(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl %eax, -84(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl %edx, -192(%ebp) # 4-byte Spill ; X32-NEXT: adcl -60(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -44(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -48(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %edi -; X32-NEXT: movl %edi, -52(%ebp) # 4-byte Spill -; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -456(%ebp), %ecx # 4-byte Reload -; X32-NEXT: pushl %eax -; X32-NEXT: movl %ecx, %eax -; X32-NEXT: addb $127, %al -; X32-NEXT: sahf -; X32-NEXT: popl %eax -; X32-NEXT: adcl -72(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -608(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -56(%ebp) # 4-byte Spill +; X32-NEXT: addb $127, -452(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -40(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -88(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -612(%ebp) # 4-byte Spill ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -76(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -760(%ebp) # 4-byte Spill -; X32-NEXT: movl -88(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -232(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -64(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -756(%ebp) # 4-byte Spill -; X32-NEXT: movl %edx, %eax -; X32-NEXT: adcl -164(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl -84(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -224(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -752(%ebp) # 4-byte Spill -; X32-NEXT: movl %esi, %eax -; X32-NEXT: adcl -40(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %edx, %eax +; X32-NEXT: adcl -28(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -748(%ebp) # 4-byte Spill -; X32-NEXT: movl %edi, %eax -; X32-NEXT: adcl -56(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %esi, %eax +; X32-NEXT: adcl -164(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -744(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, %eax +; X32-NEXT: adcl -76(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -740(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 12(%eax), %eax ; X32-NEXT: movl %eax, -60(%ebp) # 4-byte Spill @@ -1130,7 +1104,7 @@ ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ecx -; X32-NEXT: movl -268(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -260(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl %ebx, %ecx ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl -160(%ebp), %edi # 4-byte Reload @@ -1144,24 +1118,24 @@ ; X32-NEXT: movl %edi, %esi ; X32-NEXT: addl %edi, %edx ; X32-NEXT: adcl %ebx, %eax -; X32-NEXT: movl %eax, -112(%ebp) # 4-byte Spill -; X32-NEXT: movl -136(%ebp), %edi # 4-byte Reload -; X32-NEXT: movl -584(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %eax, -116(%ebp) # 4-byte Spill +; X32-NEXT: movl -140(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -588(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl %edi, %ecx -; X32-NEXT: movl -432(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -264(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl -436(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -256(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: addl %ecx, %esi -; X32-NEXT: movl %esi, -432(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -436(%ebp) # 4-byte Spill ; X32-NEXT: movl -24(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %eax, %esi -; X32-NEXT: movl %esi, -456(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -452(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %esi ; X32-NEXT: adcl $0, %esi -; X32-NEXT: movl -112(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -116(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: addl %edi, -432(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -276(%ebp), %edi # 4-byte Reload -; X32-NEXT: adcl %edi, -456(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl %edi, -436(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -272(%ebp), %edi # 4-byte Reload +; X32-NEXT: adcl %edi, -452(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: adcl $0, %eax ; X32-NEXT: addl %esi, %ecx @@ -1172,50 +1146,47 @@ ; X32-NEXT: movzbl %bl, %esi ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl %esi, -24(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -112(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -136(%ebp), %ebx # 4-byte Reload +; X32-NEXT: adcl $0, -116(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -140(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl -180(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl %edi, %edx -; X32-NEXT: adcl -48(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl -240(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -36(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -52(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl -232(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -44(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl -172(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl -20(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: addl %ecx, %ebx -; X32-NEXT: movl %ebx, -584(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -588(%ebp) # 4-byte Spill ; X32-NEXT: adcl %eax, %edx -; X32-NEXT: movl %edx, -276(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -272(%ebp) # 4-byte Spill ; X32-NEXT: adcl -24(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -240(%ebp) # 4-byte Spill -; X32-NEXT: adcl -112(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -232(%ebp) # 4-byte Spill +; X32-NEXT: adcl -116(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl %edi, -172(%ebp) # 4-byte Spill -; X32-NEXT: movl -736(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl %eax, %eax -; X32-NEXT: addb $127, %al -; X32-NEXT: sahf -; X32-NEXT: movl -72(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -432(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill -; X32-NEXT: movl -76(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -456(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill -; X32-NEXT: adcl %ebx, -232(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl %edx, -164(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl %esi, -40(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl %edi, -56(%ebp) # 4-byte Folded Spill +; X32-NEXT: addb $127, -529(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -88(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -436(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill +; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -452(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill +; X32-NEXT: adcl %ebx, -224(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %edx, -28(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %esi, -164(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %edi, -76(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 44(%eax), %eax -; X32-NEXT: movl %eax, -112(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -116(%ebp) # 4-byte Spill ; X32-NEXT: xorl %ecx, %ecx ; X32-NEXT: mull %ecx ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: movl -128(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -132(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl %edi, %ebx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl -304(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl %ecx, %ebx -; X32-NEXT: movl %ebx, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -44(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: setb %bl ; X32-NEXT: addl %eax, %esi @@ -1224,84 +1195,76 @@ ; X32-NEXT: movl %ecx, %edx ; X32-NEXT: addl %ecx, %esi ; X32-NEXT: adcl %edi, %eax -; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill ; X32-NEXT: movl -100(%ebp), %edi # 4-byte Reload -; X32-NEXT: movl -220(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -352(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl -376(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -288(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -204(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edx -; X32-NEXT: movl %edx, -376(%ebp) # 4-byte Spill -; X32-NEXT: movl -36(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl %edx, -384(%ebp) # 4-byte Spill +; X32-NEXT: movl -44(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl %edx, -220(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -352(%ebp) # 4-byte Spill ; X32-NEXT: movl %esi, %edx ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl %edx, -20(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: addl %edi, -376(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -220(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl -80(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -220(%ebp) # 4-byte Spill +; X32-NEXT: addl %edi, -384(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -352(%ebp), %edx # 4-byte Reload +; X32-NEXT: adcl -72(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -352(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %eax ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: addl -20(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl %ebx, %ecx ; X32-NEXT: setb %dl ; X32-NEXT: addl -304(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: adcl -36(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -44(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movzbl %dl, %edx ; X32-NEXT: adcl %esi, %edx -; X32-NEXT: movl %edx, -36(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -48(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl %edx, -44(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -52(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl %edi, %ebx ; X32-NEXT: addl -336(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl -200(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl -80(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl -472(%ebp), %edi # 4-byte Reload -; X32-NEXT: adcl -372(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -436(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -292(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -268(%ebp), %edx # 4-byte Reload +; X32-NEXT: adcl -72(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl -296(%ebp), %edi # 4-byte Reload +; X32-NEXT: adcl -380(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl -468(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -372(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl %edx, -200(%ebp) # 4-byte Spill -; X32-NEXT: adcl -36(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: adcl -48(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -740(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl %eax, %eax -; X32-NEXT: addb $127, %al -; X32-NEXT: sahf -; X32-NEXT: movl -376(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl %edx, -432(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -220(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %ecx, -456(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl %ebx, -584(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -200(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -276(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl %edi, -240(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl %esi, -172(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -640(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl %eax, %eax -; X32-NEXT: addb $127, %al -; X32-NEXT: sahf -; X32-NEXT: adcl -64(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -376(%ebp) # 4-byte Spill -; X32-NEXT: adcl -16(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -220(%ebp) # 4-byte Spill -; X32-NEXT: adcl -88(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -640(%ebp) # 4-byte Spill -; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -200(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl -44(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -472(%ebp) # 4-byte Spill ; X32-NEXT: adcl -52(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -436(%ebp) # 4-byte Spill +; X32-NEXT: addb $127, -644(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -384(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -436(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -352(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl %ecx, -452(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %ebx, -588(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %edx, -272(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %edi, -232(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %esi, -172(%ebp) # 4-byte Folded Spill +; X32-NEXT: addb $127, -112(%ebp) # 1-byte Folded Spill +; X32-NEXT: adcl -40(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -384(%ebp) # 4-byte Spill +; X32-NEXT: adcl -16(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -352(%ebp) # 4-byte Spill +; X32-NEXT: adcl -84(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -644(%ebp) # 4-byte Spill +; X32-NEXT: adcl -192(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -268(%ebp) # 4-byte Spill +; X32-NEXT: adcl -48(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -296(%ebp) # 4-byte Spill +; X32-NEXT: adcl -56(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -468(%ebp) # 4-byte Spill ; X32-NEXT: movl -408(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -168(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, -16(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 60(%eax), %eax @@ -1316,7 +1279,7 @@ ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload @@ -1325,11 +1288,11 @@ ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -392(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -28(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -32(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -412(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -256(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -248(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -80(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -72(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl %esi, -16(%ebp) # 4-byte Spill ; X32-NEXT: movl -440(%ebp), %esi # 4-byte Reload @@ -1349,7 +1312,7 @@ ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl -340(%ebp), %edi # 4-byte Reload @@ -1359,31 +1322,31 @@ ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: addl -68(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: adcl -764(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -48(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -760(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -52(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -20(%ebp) # 4-byte Spill -; X32-NEXT: adcl -36(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -36(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -80(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl -44(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -44(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -72(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -16(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -440(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -108(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -44(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %eax, %ecx -; X32-NEXT: addl -44(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -48(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -96(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -56(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %edi ; X32-NEXT: setb %cl ; X32-NEXT: movl -340(%ebp), %eax # 4-byte Reload @@ -1391,37 +1354,37 @@ ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -132(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -136(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl -104(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -140(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -144(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -156(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl -20(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -48(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -36(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -52(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl %eax, -52(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -44(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -56(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: adcl $0, %esi -; X32-NEXT: addl -80(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -72(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl -16(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: setb -36(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -44(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -408(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -108(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %edx, -80(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -72(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -16(%ebp) # 4-byte Spill ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -80(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -72(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl %edx, -20(%ebp) # 4-byte Spill ; X32-NEXT: movl -408(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -96(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -80(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill ; X32-NEXT: adcl -20(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: setb -20(%ebp) # 1-byte Folded Spill @@ -1438,26 +1401,26 @@ ; X32-NEXT: adcl %edx, %ebx ; X32-NEXT: movl -16(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ecx, %edx -; X32-NEXT: movl -80(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -72(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: movzbl -36(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -44(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: addl -68(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -16(%ebp) # 4-byte Spill -; X32-NEXT: adcl -420(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -80(%ebp) # 4-byte Spill -; X32-NEXT: adcl -616(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -88(%ebp) # 4-byte Spill -; X32-NEXT: adcl -612(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -272(%ebp) # 4-byte Spill -; X32-NEXT: movl -352(%ebp), %edi # 4-byte Reload +; X32-NEXT: adcl -428(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -72(%ebp) # 4-byte Spill +; X32-NEXT: adcl -620(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -84(%ebp) # 4-byte Spill +; X32-NEXT: adcl -616(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -264(%ebp) # 4-byte Spill +; X32-NEXT: movl -356(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: movl -168(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %eax, %esi @@ -1471,25 +1434,25 @@ ; X32-NEXT: movl %eax, -68(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %edi ; X32-NEXT: setb %bl -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -364(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -28(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -368(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -32(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -396(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -256(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -248(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: movl %ecx, -20(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -36(%ebp) # 4-byte Spill -; X32-NEXT: movl -416(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %esi, -44(%ebp) # 4-byte Spill +; X32-NEXT: movl -420(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -168(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi -; X32-NEXT: movl %eax, -616(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -620(%ebp) # 4-byte Spill ; X32-NEXT: movl -316(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi @@ -1501,29 +1464,29 @@ ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -612(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -616(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -152(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -112(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -316(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %edi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -152(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -112(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -32(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: adcl -424(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -44(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -152(%ebp) # 4-byte Spill +; X32-NEXT: addl -36(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -432(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -48(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -112(%ebp) # 4-byte Spill ; X32-NEXT: adcl -68(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -44(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -48(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -20(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -36(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -416(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl $0, -44(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -420(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -108(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi -; X32-NEXT: movl %eax, -424(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -432(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx @@ -1535,7 +1498,7 @@ ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -420(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -428(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %esi ; X32-NEXT: setb %cl ; X32-NEXT: movl -316(%ebp), %eax # 4-byte Reload @@ -1549,105 +1512,105 @@ ; X32-NEXT: adcl -156(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -152(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -424(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -44(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -420(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -112(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -432(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -428(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %edi ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: addl -20(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: adcl -36(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -44(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: setb -68(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -352(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -356(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -108(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, -20(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, %ebx ; X32-NEXT: addl -20(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl %edx, -44(%ebp) # 4-byte Spill -; X32-NEXT: movl -352(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %edx, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl -356(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -96(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movl %eax, -20(%ebp) # 4-byte Spill -; X32-NEXT: adcl -44(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -48(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: setb -44(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: setb -48(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movzbl -44(%ebp), %esi # 1-byte Folded Reload +; X32-NEXT: movzbl -48(%ebp), %esi # 1-byte Folded Reload ; X32-NEXT: adcl %esi, %edx -; X32-NEXT: movl -364(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -368(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl -104(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl -396(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -156(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -44(%ebp) # 4-byte Spill -; X32-NEXT: movl -36(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl %esi, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl -44(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %edi, %edx ; X32-NEXT: movl -20(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi ; X32-NEXT: movzbl -68(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %ebx -; X32-NEXT: movl -44(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax -; X32-NEXT: addl -32(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -36(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: adcl -196(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: adcl -504(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: adcl -508(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -508(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -504(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: addl -24(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -36(%ebp) # 4-byte Spill -; X32-NEXT: adcl -64(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %edx, -44(%ebp) # 4-byte Spill +; X32-NEXT: adcl -40(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -20(%ebp) # 4-byte Spill -; X32-NEXT: adcl -48(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -292(%ebp) # 4-byte Spill -; X32-NEXT: adcl -52(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill +; X32-NEXT: adcl -52(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -288(%ebp) # 4-byte Spill +; X32-NEXT: adcl -56(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -16(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -80(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -88(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -272(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -352(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl $0, -72(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -84(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -264(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -356(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -212(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -52(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill -; X32-NEXT: movl -120(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl %edx, -56(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill +; X32-NEXT: movl -124(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -52(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -56(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: mull -252(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -244(%ebp) # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl %edi, %eax -; X32-NEXT: movl -252(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -244(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -364(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -116(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -368(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -120(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -396(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -84(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -80(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: movl %ecx, -24(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -52(%ebp) # 4-byte Spill -; X32-NEXT: movl -416(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %esi, -56(%ebp) # 4-byte Spill +; X32-NEXT: movl -420(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -212(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi @@ -1671,20 +1634,20 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -296(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: adcl -768(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -48(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -372(%ebp) # 4-byte Spill -; X32-NEXT: adcl -64(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -292(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -764(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -52(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -380(%ebp) # 4-byte Spill +; X32-NEXT: adcl -40(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -68(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -24(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -52(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -416(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl $0, -56(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -420(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -284(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -280(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: movl %eax, -152(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -112(%ebp) # 4-byte Spill ; X32-NEXT: movl -316(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi @@ -1696,10 +1659,10 @@ ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %ebx ; X32-NEXT: movl %ebx, %esi -; X32-NEXT: movl %ebx, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -52(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ebx ; X32-NEXT: setb %cl ; X32-NEXT: movl -316(%ebp), %eax # 4-byte Reload @@ -1713,78 +1676,78 @@ ; X32-NEXT: adcl -208(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -372(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -152(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -380(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -112(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -40(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl -68(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: addl -24(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: adcl -52(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: setb -372(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -352(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -284(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -56(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: setb -380(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -356(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -280(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, -24(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %eax, -56(%ebp) # 4-byte Spill +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, %edi ; X32-NEXT: addl -24(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl %edx, -68(%ebp) # 4-byte Spill -; X32-NEXT: movl -352(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -48(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -356(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movl %eax, -24(%ebp) # 4-byte Spill ; X32-NEXT: adcl -68(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %edi ; X32-NEXT: setb -68(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl -68(%ebp), %esi # 1-byte Folded Reload ; X32-NEXT: adcl %esi, %edx -; X32-NEXT: movl -364(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -368(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl -308(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl -396(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -208(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl %esi, -68(%ebp) # 4-byte Spill -; X32-NEXT: movl -52(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -56(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ebx, %edx ; X32-NEXT: movl -24(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi -; X32-NEXT: movzbl -372(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -380(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: movl -68(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax -; X32-NEXT: addl -296(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: adcl -776(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: adcl -772(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: adcl -780(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl -36(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -292(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -772(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -768(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: adcl -776(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl -44(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl %ecx, -508(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -20(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %ecx, -504(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -292(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %ecx, -152(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -44(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %ecx, -64(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -288(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl %ecx, -112(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -48(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl %ecx, -40(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %edx ; X32-NEXT: adcl $0, %esi ; X32-NEXT: adcl $0, %edi ; X32-NEXT: adcl $0, %eax ; X32-NEXT: addl -16(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -52(%ebp) # 4-byte Spill -; X32-NEXT: adcl -80(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %edx, -56(%ebp) # 4-byte Spill +; X32-NEXT: adcl -72(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -24(%ebp) # 4-byte Spill -; X32-NEXT: adcl -88(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -44(%ebp) # 4-byte Spill -; X32-NEXT: adcl -272(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -84(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -48(%ebp) # 4-byte Spill +; X32-NEXT: adcl -264(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -68(%ebp) # 4-byte Spill ; X32-NEXT: setb -20(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -408(%ebp), %ebx # 4-byte Reload @@ -1792,7 +1755,7 @@ ; X32-NEXT: movl -212(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi @@ -1800,11 +1763,11 @@ ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -252(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -244(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -272(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -264(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb -16(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload @@ -1813,11 +1776,11 @@ ; X32-NEXT: movzbl -16(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -392(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -116(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -120(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -412(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -84(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -80(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -80(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -72(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl %esi, -16(%ebp) # 4-byte Spill ; X32-NEXT: movl -440(%ebp), %ebx # 4-byte Reload @@ -1825,7 +1788,7 @@ ; X32-NEXT: movl -212(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -292(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -288(%ebp) # 4-byte Spill ; X32-NEXT: movl -340(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi @@ -1833,33 +1796,33 @@ ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -252(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -244(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -372(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -380(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -88(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -84(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -340(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -88(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -84(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: addl -332(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: adcl -448(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -36(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -448(%ebp) # 4-byte Spill -; X32-NEXT: adcl -272(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -36(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -80(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl -780(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -44(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -372(%ebp) # 4-byte Spill +; X32-NEXT: adcl -264(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -44(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -72(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -16(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -440(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -284(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -280(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -84(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi @@ -1867,11 +1830,11 @@ ; X32-NEXT: addl %ebx, %ecx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -48(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -296(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -292(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: setb %cl ; X32-NEXT: movl -340(%ebp), %eax # 4-byte Reload @@ -1879,44 +1842,44 @@ ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -132(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -136(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl -308(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl -140(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -144(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -208(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -448(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -88(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -36(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -296(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -372(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -84(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -44(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -292(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -80(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -72(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl -16(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: setb -16(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -408(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -284(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -280(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -80(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -272(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -72(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -264(%ebp) # 4-byte Spill ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, %edi -; X32-NEXT: addl -80(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -72(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl %edx, -80(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -72(%ebp) # 4-byte Spill ; X32-NEXT: movl -408(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -48(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill -; X32-NEXT: adcl -80(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill +; X32-NEXT: adcl -72(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %edi -; X32-NEXT: setb -80(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -72(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movzbl -80(%ebp), %esi # 1-byte Folded Reload +; X32-NEXT: movzbl -72(%ebp), %esi # 1-byte Folded Reload ; X32-NEXT: adcl %esi, %edx ; X32-NEXT: movl -392(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl -308(%ebp), %edi # 4-byte Folded Reload @@ -1924,60 +1887,60 @@ ; X32-NEXT: adcl -208(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -80(%ebp) # 4-byte Spill -; X32-NEXT: movl -272(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl %esi, -72(%ebp) # 4-byte Spill +; X32-NEXT: movl -264(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ebx, %edx -; X32-NEXT: movl -36(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -44(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi ; X32-NEXT: movzbl -16(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi -; X32-NEXT: movl -80(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -72(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax ; X32-NEXT: addl -332(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: adcl -648(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -36(%ebp) # 4-byte Spill -; X32-NEXT: adcl -644(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -44(%ebp) # 4-byte Spill +; X32-NEXT: adcl -576(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl %edi, -332(%ebp) # 4-byte Spill -; X32-NEXT: adcl -572(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -80(%ebp) # 4-byte Spill -; X32-NEXT: movl -292(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -52(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -372(%ebp), %edx # 4-byte Reload +; X32-NEXT: adcl -500(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill +; X32-NEXT: movl -288(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -56(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -380(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl -24(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl -88(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -44(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -296(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -84(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -48(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -292(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl -68(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movzbl -20(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %ebx -; X32-NEXT: movl %ebx, -272(%ebp) # 4-byte Spill -; X32-NEXT: movl -36(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %ebx, -264(%ebp) # 4-byte Spill +; X32-NEXT: movl -44(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax ; X32-NEXT: movl -332(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: adcl $0, -80(%ebp) # 4-byte Folded Spill -; X32-NEXT: addl -32(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -292(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -72(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl -36(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -288(%ebp) # 4-byte Spill ; X32-NEXT: adcl -196(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -372(%ebp) # 4-byte Spill -; X32-NEXT: adcl -608(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -88(%ebp) # 4-byte Spill -; X32-NEXT: adcl -760(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -296(%ebp) # 4-byte Spill -; X32-NEXT: movl -756(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %ecx, -272(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl -752(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill -; X32-NEXT: adcl -748(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -380(%ebp) # 4-byte Spill +; X32-NEXT: adcl -612(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -84(%ebp) # 4-byte Spill +; X32-NEXT: adcl -756(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -292(%ebp) # 4-byte Spill +; X32-NEXT: movl -752(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl %ecx, -264(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl -748(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill +; X32-NEXT: adcl -744(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl %ebx, -332(%ebp) # 4-byte Spill -; X32-NEXT: movl -744(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -80(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -288(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -740(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -72(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -284(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -168(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -56(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 28(%eax), %eax @@ -2000,32 +1963,32 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -280(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -28(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -276(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -32(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -312(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -256(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -248(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -44(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -48(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl %esi, -20(%ebp) # 4-byte Spill ; X32-NEXT: movl -348(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -168(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -32(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -572(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -576(%ebp) # 4-byte Spill ; X32-NEXT: movl -216(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -32(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -36(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -92(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -448(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -500(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl -216(%ebp), %edi # 4-byte Reload @@ -2034,13 +1997,13 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -228(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: adcl -428(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -52(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -32(%ebp) # 4-byte Spill +; X32-NEXT: addl -220(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -540(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -56(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill ; X32-NEXT: adcl -24(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -52(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -44(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl %edx, -56(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -48(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -20(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -348(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax @@ -2059,7 +2022,7 @@ ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -428(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -372(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %edi ; X32-NEXT: setb %cl ; X32-NEXT: movl -216(%ebp), %eax # 4-byte Reload @@ -2073,31 +2036,31 @@ ; X32-NEXT: adcl -156(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -36(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %eax, -196(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -428(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -56(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -372(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: adcl $0, %esi -; X32-NEXT: addl -44(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -48(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl -20(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: setb -52(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -288(%ebp), %eax # 4-byte Reload +; X32-NEXT: setb -56(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -284(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -108(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %edx, -44(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -48(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -20(%ebp) # 4-byte Spill ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -44(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -48(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl %edx, -24(%ebp) # 4-byte Spill -; X32-NEXT: movl -288(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -284(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -96(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill ; X32-NEXT: adcl -24(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: setb -24(%ebp) # 1-byte Folded Spill @@ -2106,7 +2069,7 @@ ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movzbl -24(%ebp), %edi # 1-byte Folded Reload ; X32-NEXT: adcl %edi, %edx -; X32-NEXT: movl -280(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -276(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl -104(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl -312(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl -156(%ebp), %ebx # 4-byte Folded Reload @@ -2114,25 +2077,25 @@ ; X32-NEXT: adcl %edx, %ebx ; X32-NEXT: movl -20(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ecx, %edx -; X32-NEXT: movl -44(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -48(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: movzbl -52(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -56(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: addl -228(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -220(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -20(%ebp) # 4-byte Spill -; X32-NEXT: adcl -596(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -44(%ebp) # 4-byte Spill -; X32-NEXT: adcl -464(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -464(%ebp) # 4-byte Spill -; X32-NEXT: adcl -536(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -460(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -48(%ebp) # 4-byte Spill +; X32-NEXT: adcl -652(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -460(%ebp) # 4-byte Spill +; X32-NEXT: adcl -600(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl %ebx, -68(%ebp) # 4-byte Spill ; X32-NEXT: movl -184(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: movl -168(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -32(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill ; X32-NEXT: movl -60(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ebx @@ -2144,7 +2107,7 @@ ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: addl %esi, %eax -; X32-NEXT: movl %eax, -228(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -220(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %edi ; X32-NEXT: setb %bl ; X32-NEXT: movl -60(%ebp), %eax # 4-byte Reload @@ -2153,20 +2116,20 @@ ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -160(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -28(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -268(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -256(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -32(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -260(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -248(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: movl %ecx, -24(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -52(%ebp) # 4-byte Spill -; X32-NEXT: movl -260(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl %esi, -56(%ebp) # 4-byte Spill +; X32-NEXT: movl -252(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: movl -168(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -648(%ebp) # 4-byte Spill -; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %eax, -652(%ebp) # 4-byte Spill +; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ebx @@ -2177,29 +2140,29 @@ ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -644(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -648(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -536(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -124(%ebp), %ebx # 4-byte Reload +; X32-NEXT: setb -540(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -128(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %edi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -536(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -540(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: addl -344(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: adcl -452(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -32(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -452(%ebp) # 4-byte Spill -; X32-NEXT: adcl -228(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -32(%ebp) # 4-byte Spill +; X32-NEXT: adcl -448(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -36(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -448(%ebp) # 4-byte Spill +; X32-NEXT: adcl -220(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -36(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -24(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -52(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -260(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl $0, -56(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -252(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -108(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi -; X32-NEXT: movl %eax, -536(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -540(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx @@ -2211,157 +2174,157 @@ ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -596(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -600(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %esi ; X32-NEXT: setb %cl -; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -136(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -140(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl -104(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -264(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -256(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -156(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -452(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -536(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -596(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -448(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -540(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -36(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -600(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %edi ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: addl -24(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: adcl -52(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: setb -228(%ebp) # 1-byte Folded Spill +; X32-NEXT: adcl -56(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: setb -220(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -184(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -108(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, -24(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -56(%ebp) # 4-byte Spill ; X32-NEXT: movl -60(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, %ebx ; X32-NEXT: addl -24(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl %edx, -32(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -36(%ebp) # 4-byte Spill ; X32-NEXT: movl -184(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -96(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movl %eax, -24(%ebp) # 4-byte Spill -; X32-NEXT: adcl -32(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -36(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: setb -32(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -36(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -60(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movzbl -32(%ebp), %esi # 1-byte Folded Reload +; X32-NEXT: movzbl -36(%ebp), %esi # 1-byte Folded Reload ; X32-NEXT: adcl %esi, %edx ; X32-NEXT: movl -160(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl -104(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl -268(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -260(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -156(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -32(%ebp) # 4-byte Spill -; X32-NEXT: movl -52(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl %esi, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl -56(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %edi, %edx ; X32-NEXT: movl -24(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi -; X32-NEXT: movzbl -228(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -220(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %ebx -; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -36(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax ; X32-NEXT: addl -344(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: adcl -404(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: adcl -532(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: adcl -592(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: addl -572(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -52(%ebp) # 4-byte Spill -; X32-NEXT: adcl -448(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -596(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -536(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -576(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -56(%ebp) # 4-byte Spill +; X32-NEXT: adcl -500(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -24(%ebp) # 4-byte Spill ; X32-NEXT: adcl -196(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -572(%ebp) # 4-byte Spill -; X32-NEXT: adcl -428(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -32(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -576(%ebp) # 4-byte Spill +; X32-NEXT: adcl -372(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -20(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -44(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -464(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -48(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -460(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -68(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -184(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -212(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -228(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -428(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -220(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -372(%ebp) # 4-byte Spill ; X32-NEXT: movl -60(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -228(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -220(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: mull -252(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -244(%ebp) # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -452(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -448(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl %edi, %eax -; X32-NEXT: movl -252(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -244(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -160(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -116(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -268(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -84(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -120(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -260(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -80(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: movl %ecx, -196(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -228(%ebp) # 4-byte Spill -; X32-NEXT: movl -260(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %esi, -220(%ebp) # 4-byte Spill +; X32-NEXT: movl -252(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -212(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -532(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -592(%ebp) # 4-byte Spill -; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %edx, -536(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -596(%ebp) # 4-byte Spill +; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -532(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -536(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -532(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -536(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb %bl -; X32-NEXT: movl -124(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %edi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -368(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -376(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -328(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -428(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -448(%ebp) # 4-byte Spill -; X32-NEXT: adcl -452(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -372(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -500(%ebp) # 4-byte Spill +; X32-NEXT: adcl -448(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -328(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -196(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -228(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -260(%ebp), %edi # 4-byte Reload +; X32-NEXT: adcl $0, -220(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -252(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax -; X32-NEXT: movl -284(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -280(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: movl %eax, -428(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -372(%ebp) # 4-byte Spill ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi @@ -2369,38 +2332,38 @@ ; X32-NEXT: addl %ebx, %ecx ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %edi, %eax -; X32-NEXT: movl -48(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -452(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -448(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ebx ; X32-NEXT: setb %cl -; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -136(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -140(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl -308(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl -264(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -256(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -208(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -448(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -428(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -500(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -372(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -328(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -452(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %eax, -448(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: addl -196(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: adcl -228(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: setb -448(%ebp) # 1-byte Folded Spill +; X32-NEXT: adcl -220(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: setb -500(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -184(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -284(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -280(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, -196(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -228(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -220(%ebp) # 4-byte Spill ; X32-NEXT: movl -60(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, %edi @@ -2408,7 +2371,7 @@ ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl %edx, -328(%ebp) # 4-byte Spill ; X32-NEXT: movl -184(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -48(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movl %eax, -196(%ebp) # 4-byte Spill @@ -2422,45 +2385,45 @@ ; X32-NEXT: adcl %esi, %edx ; X32-NEXT: movl -160(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl -308(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -268(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -260(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -208(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl %esi, -328(%ebp) # 4-byte Spill -; X32-NEXT: movl -228(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -220(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ebx, %edx ; X32-NEXT: movl -196(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi -; X32-NEXT: movzbl -448(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -500(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: movl -328(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax -; X32-NEXT: addl -368(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: adcl -620(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -376(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -624(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: adcl -788(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl -784(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl -52(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl %ecx, -592(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -56(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl %ecx, -596(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -24(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %ecx, -532(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -572(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %ecx, -428(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -32(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %ecx, -452(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %ecx, -536(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -576(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl %ecx, -372(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -36(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl %ecx, -448(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %edx ; X32-NEXT: adcl $0, %esi ; X32-NEXT: adcl $0, %edi ; X32-NEXT: adcl $0, %eax ; X32-NEXT: addl -20(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -228(%ebp) # 4-byte Spill -; X32-NEXT: adcl -44(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %edx, -220(%ebp) # 4-byte Spill +; X32-NEXT: adcl -48(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -196(%ebp) # 4-byte Spill -; X32-NEXT: adcl -464(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -620(%ebp) # 4-byte Spill +; X32-NEXT: adcl -460(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -624(%ebp) # 4-byte Spill ; X32-NEXT: adcl -68(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -328(%ebp) # 4-byte Spill -; X32-NEXT: setb -464(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -288(%ebp), %ebx # 4-byte Reload +; X32-NEXT: setb -460(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -284(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: movl -212(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi @@ -2473,32 +2436,32 @@ ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -252(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -244(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movl %eax, -24(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -44(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -48(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -44(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -48(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -280(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -116(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -276(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -120(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -312(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -84(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -80(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -52(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -56(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -44(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -48(%ebp) # 4-byte Spill ; X32-NEXT: movl -348(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: movl -212(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -32(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill ; X32-NEXT: movl -216(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi @@ -2506,45 +2469,45 @@ ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -252(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -244(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movl %eax, -68(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -368(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -376(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -216(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -368(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -376(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -540(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: adcl -576(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -544(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -580(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: addl -20(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -576(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -580(%ebp) # 4-byte Spill ; X32-NEXT: adcl -24(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -24(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -52(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -44(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -56(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -48(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -348(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -284(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -280(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -368(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -376(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -20(%ebp) # 4-byte Spill ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ecx -; X32-NEXT: addl -368(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -376(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -48(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -368(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -376(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: setb %cl ; X32-NEXT: movl -216(%ebp), %eax # 4-byte Reload @@ -2558,31 +2521,31 @@ ; X32-NEXT: adcl -208(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %edx, %edi -; X32-NEXT: movl -576(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -580(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %eax, -20(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -24(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -368(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %eax, -376(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: adcl $0, %edi -; X32-NEXT: addl -52(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: adcl -44(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: setb -576(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -288(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -284(%ebp), %esi # 4-byte Reload +; X32-NEXT: addl -56(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -48(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: setb -580(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -284(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -280(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -52(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -56(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, %ecx -; X32-NEXT: addl -52(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -56(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl %edx, -24(%ebp) # 4-byte Spill -; X32-NEXT: movl -288(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -48(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -284(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -56(%ebp) # 4-byte Spill ; X32-NEXT: adcl -24(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: setb -24(%ebp) # 1-byte Folded Spill @@ -2591,84 +2554,84 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl -24(%ebp), %esi # 1-byte Folded Reload ; X32-NEXT: adcl %esi, %edx -; X32-NEXT: movl -280(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -276(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl -308(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl -312(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -208(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: movl %esi, -24(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -44(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -48(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ebx, %edx -; X32-NEXT: movl -52(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -56(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %edi, %esi -; X32-NEXT: movzbl -576(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -580(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: movl -24(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -540(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -44(%ebp) # 4-byte Spill +; X32-NEXT: addl -544(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -48(%ebp) # 4-byte Spill ; X32-NEXT: adcl -800(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -52(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -56(%ebp) # 4-byte Spill ; X32-NEXT: adcl -796(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl %edi, -24(%ebp) # 4-byte Spill ; X32-NEXT: adcl -792(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, %edi -; X32-NEXT: movl -32(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -228(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -36(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -220(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -68(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl -196(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl -20(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -620(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -368(%ebp), %ebx # 4-byte Reload +; X32-NEXT: adcl -624(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -376(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl -328(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movzbl -464(%ebp), %eax # 1-byte Folded Reload -; X32-NEXT: adcl %eax, -44(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -52(%ebp) # 4-byte Folded Spill +; X32-NEXT: movzbl -460(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: adcl %eax, -48(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -56(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -24(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %edi ; X32-NEXT: addl -344(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -32(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -36(%ebp) # 4-byte Spill ; X32-NEXT: adcl -404(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -68(%ebp) # 4-byte Spill -; X32-NEXT: adcl -72(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -88(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -20(%ebp) # 4-byte Spill -; X32-NEXT: adcl -76(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl -44(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -232(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl -52(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -164(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -64(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -224(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl -56(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -28(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -24(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl -40(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: adcl -56(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -32(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -616(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -32(%ebp) # 4-byte Spill +; X32-NEXT: adcl -164(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -76(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl -36(%ebp), %esi # 4-byte Reload +; X32-NEXT: addl -620(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -36(%ebp) # 4-byte Spill ; X32-NEXT: movl -68(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -612(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -616(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -68(%ebp) # 4-byte Spill ; X32-NEXT: movl -20(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -424(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -432(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -20(%ebp) # 4-byte Spill -; X32-NEXT: adcl -420(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -368(%ebp) # 4-byte Spill +; X32-NEXT: adcl -428(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -376(%ebp) # 4-byte Spill ; X32-NEXT: adcl -508(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill ; X32-NEXT: adcl -504(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -52(%ebp) # 4-byte Spill -; X32-NEXT: adcl -152(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -56(%ebp) # 4-byte Spill +; X32-NEXT: adcl -112(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -24(%ebp) # 4-byte Spill -; X32-NEXT: adcl -64(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -464(%ebp) # 4-byte Spill +; X32-NEXT: adcl -40(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -460(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -288(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -380(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -84(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -292(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -372(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -88(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -296(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -272(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -36(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -264(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -44(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -332(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -80(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -288(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl $0, -72(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -284(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -188(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi @@ -2681,11 +2644,11 @@ ; X32-NEXT: addl %ecx, %ebx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -148(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -152(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload @@ -2693,32 +2656,32 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -280(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -276(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl -100(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -312(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -204(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -56(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -76(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -40(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -28(%ebp) # 4-byte Spill ; X32-NEXT: movl -348(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -188(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -72(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -152(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -88(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -112(%ebp) # 4-byte Spill ; X32-NEXT: movl -216(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -72(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -88(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -148(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -152(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -228(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -220(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl -216(%ebp), %edi # 4-byte Reload @@ -2727,17 +2690,17 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -468(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -464(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -804(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: addl -164(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill -; X32-NEXT: adcl -76(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -76(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -56(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -40(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill +; X32-NEXT: adcl -64(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -64(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -76(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -28(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -348(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -236(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -228(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %eax, -164(%ebp) # 4-byte Spill @@ -2748,11 +2711,11 @@ ; X32-NEXT: addl %ebx, %ecx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -112(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -116(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -232(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -224(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ebx ; X32-NEXT: setb %cl ; X32-NEXT: movl -216(%ebp), %eax # 4-byte Reload @@ -2763,65 +2726,65 @@ ; X32-NEXT: movl -180(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl -304(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl -320(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -128(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -132(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -72(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -88(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %eax, -164(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -76(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -232(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -224(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -56(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: adcl -40(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: setb -72(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -288(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -236(%ebp), %esi # 4-byte Reload +; X32-NEXT: addl -76(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -28(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: setb -88(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -284(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -228(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -40(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -56(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, %edi -; X32-NEXT: addl -40(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -28(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl %edx, -40(%ebp) # 4-byte Spill -; X32-NEXT: movl -288(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -112(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl %edx, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl -284(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -116(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill -; X32-NEXT: adcl -40(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill +; X32-NEXT: adcl -28(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %edi -; X32-NEXT: setb -40(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -28(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movzbl -40(%ebp), %esi # 1-byte Folded Reload +; X32-NEXT: movzbl -28(%ebp), %esi # 1-byte Folded Reload ; X32-NEXT: adcl %esi, %edx -; X32-NEXT: movl -280(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -276(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl -304(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl -312(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -128(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -132(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -40(%ebp) # 4-byte Spill -; X32-NEXT: movl -56(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl %esi, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl -76(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ebx, %edx -; X32-NEXT: movl -76(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -64(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi -; X32-NEXT: movzbl -72(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -88(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi -; X32-NEXT: movl -40(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax -; X32-NEXT: addl -468(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -56(%ebp) # 4-byte Spill +; X32-NEXT: addl -464(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -76(%ebp) # 4-byte Spill ; X32-NEXT: adcl -816(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -76(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -64(%ebp) # 4-byte Spill ; X32-NEXT: adcl -812(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl %edi, -344(%ebp) # 4-byte Spill ; X32-NEXT: adcl -808(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -28(%ebp) # 4-byte Spill ; X32-NEXT: movl -184(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -188(%ebp), %edi # 4-byte Reload @@ -2835,7 +2798,7 @@ ; X32-NEXT: addl %esi, %ebx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -148(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -152(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ebx, %eax @@ -2849,33 +2812,33 @@ ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -160(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl -100(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -268(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -260(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -204(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -40(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -72(%ebp) # 4-byte Spill -; X32-NEXT: movl -260(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %esi, -88(%ebp) # 4-byte Spill +; X32-NEXT: movl -252(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -188(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -468(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -464(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -508(%ebp) # 4-byte Spill -; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -468(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -464(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -148(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -152(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movl %eax, -504(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl -; X32-NEXT: movl -124(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %esi ; X32-NEXT: addl %ecx, %eax @@ -2887,11 +2850,11 @@ ; X32-NEXT: movl %eax, -404(%ebp) # 4-byte Spill ; X32-NEXT: adcl -328(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -196(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -64(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -72(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -260(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl $0, -40(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -88(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -252(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -236(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -228(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %eax, -328(%ebp) # 4-byte Spill @@ -2902,49 +2865,49 @@ ; X32-NEXT: addl %ebx, %ecx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -112(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -116(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -468(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -464(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ebx ; X32-NEXT: setb %cl -; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -136(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -140(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl -304(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -264(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -128(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -256(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -132(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx ; X32-NEXT: movl -404(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %eax, -328(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -196(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -468(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %eax, -464(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %esi ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -64(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: adcl -72(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -40(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -88(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: setb -196(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -184(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -236(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -228(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %edx, -64(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -40(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill ; X32-NEXT: movl -60(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -64(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -40(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl %edx, -404(%ebp) # 4-byte Spill ; X32-NEXT: movl -184(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -112(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -116(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill ; X32-NEXT: adcl -404(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: setb -404(%ebp) # 1-byte Folded Spill @@ -2955,106 +2918,106 @@ ; X32-NEXT: adcl %edi, %edx ; X32-NEXT: movl -160(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl -304(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -268(%ebp), %ebx # 4-byte Reload -; X32-NEXT: adcl -128(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl -260(%ebp), %ebx # 4-byte Reload +; X32-NEXT: adcl -132(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ebx -; X32-NEXT: movl -72(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -88(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %esi, %edx -; X32-NEXT: movl -64(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -40(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi ; X32-NEXT: movzbl -196(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: addl -512(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: adcl -676(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: adcl -624(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: adcl -628(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: addl -152(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -72(%ebp) # 4-byte Spill -; X32-NEXT: adcl -228(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -64(%ebp) # 4-byte Spill +; X32-NEXT: adcl -680(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -628(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: adcl -632(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -112(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -88(%ebp) # 4-byte Spill +; X32-NEXT: adcl -220(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -40(%ebp) # 4-byte Spill ; X32-NEXT: adcl -164(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -628(%ebp) # 4-byte Spill -; X32-NEXT: adcl -232(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -624(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -56(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl %edi, -632(%ebp) # 4-byte Spill +; X32-NEXT: adcl -224(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -628(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -76(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -64(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -344(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -40(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -28(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -184(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -300(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %edx, -232(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -224(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -164(%ebp) # 4-byte Spill ; X32-NEXT: movl -60(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %eax, %edi -; X32-NEXT: addl -232(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -224(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: mull -144(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -148(%ebp) # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -228(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -220(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl %esi, %eax -; X32-NEXT: mull -144(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -148(%ebp) # 4-byte Folded Reload ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -160(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl -336(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -268(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -260(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -176(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -152(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -112(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -232(%ebp) # 4-byte Spill -; X32-NEXT: movl -260(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %esi, -224(%ebp) # 4-byte Spill +; X32-NEXT: movl -252(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -300(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, -404(%ebp) # 4-byte Spill -; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx ; X32-NEXT: addl %esi, %ebx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -144(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -148(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -540(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -544(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb -196(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -124(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %esi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl -196(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -588(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -592(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -824(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: addl -164(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -420(%ebp) # 4-byte Spill -; X32-NEXT: adcl -228(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -424(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -152(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -232(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -260(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl %eax, -428(%ebp) # 4-byte Spill +; X32-NEXT: adcl -220(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -432(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -112(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -224(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -252(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax -; X32-NEXT: movl -244(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -236(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi -; X32-NEXT: movl %eax, -228(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -220(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx @@ -3071,94 +3034,94 @@ ; X32-NEXT: movl %eax, -196(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %edi ; X32-NEXT: setb %cl -; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -136(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -224(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -264(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -360(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -140(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -200(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -256(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -364(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl -420(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -228(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -424(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -428(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -220(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -432(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -196(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: adcl $0, %esi -; X32-NEXT: addl -152(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: adcl -232(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: setb -232(%ebp) # 1-byte Folded Spill +; X32-NEXT: addl -112(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -224(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: setb -224(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -184(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -244(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -236(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %edx, -152(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -424(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -112(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -432(%ebp) # 4-byte Spill ; X32-NEXT: movl -60(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -152(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -112(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl %edx, -152(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -112(%ebp) # 4-byte Spill ; X32-NEXT: movl -184(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -164(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -420(%ebp) # 4-byte Spill -; X32-NEXT: adcl -152(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %eax, -428(%ebp) # 4-byte Spill +; X32-NEXT: adcl -112(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: setb -152(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -112(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -60(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movzbl -152(%ebp), %edi # 1-byte Folded Reload +; X32-NEXT: movzbl -112(%ebp), %edi # 1-byte Folded Reload ; X32-NEXT: adcl %edi, %edx ; X32-NEXT: movl -160(%ebp), %edi # 4-byte Reload -; X32-NEXT: addl -224(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -268(%ebp), %ebx # 4-byte Reload -; X32-NEXT: adcl -360(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -200(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl -260(%ebp), %ebx # 4-byte Reload +; X32-NEXT: adcl -364(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ebx -; X32-NEXT: movl -424(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -432(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ecx, %edx -; X32-NEXT: movl -420(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -428(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: movzbl -232(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -224(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: addl -588(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: adcl -632(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -592(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -636(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl -828(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: adcl -636(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl -72(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -640(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl -88(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %eax, -404(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -540(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -40(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -544(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -632(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -220(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -628(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -228(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -624(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -196(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %edx ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: addl -56(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -424(%ebp) # 4-byte Spill -; X32-NEXT: adcl -76(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -420(%ebp) # 4-byte Spill +; X32-NEXT: addl -76(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -432(%ebp) # 4-byte Spill +; X32-NEXT: adcl -64(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -428(%ebp) # 4-byte Spill ; X32-NEXT: adcl -344(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -636(%ebp) # 4-byte Spill -; X32-NEXT: adcl -40(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -632(%ebp) # 4-byte Spill -; X32-NEXT: setb -588(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -288(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl %edi, -640(%ebp) # 4-byte Spill +; X32-NEXT: adcl -28(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -636(%ebp) # 4-byte Spill +; X32-NEXT: setb -592(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -284(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: movl -300(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi -; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi @@ -3166,11 +3129,11 @@ ; X32-NEXT: addl %esi, %ecx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -144(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -148(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: setb %cl ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload @@ -3178,20 +3141,20 @@ ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -280(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -276(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl -336(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -312(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -176(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -56(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -76(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -40(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -28(%ebp) # 4-byte Spill ; X32-NEXT: movl -348(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: movl -300(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -232(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -224(%ebp) # 4-byte Spill ; X32-NEXT: movl -216(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi @@ -3199,33 +3162,33 @@ ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -144(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -148(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -152(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -112(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -64(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -40(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -216(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -64(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -40(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -672(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -676(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -832(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -76(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -64(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -344(%ebp) # 4-byte Spill -; X32-NEXT: adcl -72(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -76(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -56(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -40(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl -88(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -64(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -76(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -28(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -348(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -244(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -236(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi @@ -3237,7 +3200,7 @@ ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: setb %cl ; X32-NEXT: movl -216(%ebp), %eax # 4-byte Reload @@ -3246,164 +3209,164 @@ ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -180(%ebp), %ebx # 4-byte Reload -; X32-NEXT: addl -224(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -200(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl -320(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -360(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -364(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %edx, %ecx ; X32-NEXT: movl -344(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -72(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -76(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -64(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl %eax, -88(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -40(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -56(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: adcl -40(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: setb -56(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -288(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -244(%ebp), %esi # 4-byte Reload +; X32-NEXT: addl -76(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -28(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: setb -76(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -284(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -236(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -40(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -28(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -344(%ebp) # 4-byte Spill ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, %edi -; X32-NEXT: addl -40(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -28(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl %edx, -76(%ebp) # 4-byte Spill -; X32-NEXT: movl -288(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %edx, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl -284(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -164(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill -; X32-NEXT: adcl -76(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %eax, -28(%ebp) # 4-byte Spill +; X32-NEXT: adcl -64(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %edi -; X32-NEXT: setb -76(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -64(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movzbl -76(%ebp), %esi # 1-byte Folded Reload +; X32-NEXT: movzbl -64(%ebp), %esi # 1-byte Folded Reload ; X32-NEXT: adcl %esi, %edx -; X32-NEXT: movl -280(%ebp), %edi # 4-byte Reload -; X32-NEXT: addl -224(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl -276(%ebp), %edi # 4-byte Reload +; X32-NEXT: addl -200(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl -312(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -360(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -364(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -76(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -64(%ebp) # 4-byte Spill ; X32-NEXT: movl -344(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ebx, %edx -; X32-NEXT: movl -40(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -28(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi -; X32-NEXT: movzbl -56(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -76(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi -; X32-NEXT: movl -76(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax -; X32-NEXT: addl -672(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -676(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: adcl -836(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -40(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -28(%ebp) # 4-byte Spill ; X32-NEXT: adcl -840(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -56(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -76(%ebp) # 4-byte Spill ; X32-NEXT: adcl -844(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill -; X32-NEXT: movl -232(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -424(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -152(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl -420(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl -72(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -636(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -64(%ebp), %edi # 4-byte Reload -; X32-NEXT: adcl -632(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movzbl -588(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl -224(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -432(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -112(%ebp), %edx # 4-byte Reload +; X32-NEXT: adcl -428(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl -88(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -640(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -40(%ebp), %edi # 4-byte Reload +; X32-NEXT: adcl -636(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movzbl -592(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %ebx ; X32-NEXT: movl %ebx, -344(%ebp) # 4-byte Spill -; X32-NEXT: movl -40(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax -; X32-NEXT: movl -56(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -76(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: adcl $0, -76(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -64(%ebp) # 4-byte Folded Spill ; X32-NEXT: addl -512(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -232(%ebp) # 4-byte Spill -; X32-NEXT: adcl -676(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -152(%ebp) # 4-byte Spill -; X32-NEXT: adcl -432(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -72(%ebp) # 4-byte Spill -; X32-NEXT: adcl -456(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -224(%ebp) # 4-byte Spill +; X32-NEXT: adcl -680(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -112(%ebp) # 4-byte Spill +; X32-NEXT: adcl -436(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -88(%ebp) # 4-byte Spill +; X32-NEXT: adcl -452(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -40(%ebp) # 4-byte Spill ; X32-NEXT: movl -344(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -584(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: adcl -276(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill -; X32-NEXT: adcl -240(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -56(%ebp) # 4-byte Spill -; X32-NEXT: movl -76(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -588(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -272(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -28(%ebp) # 4-byte Spill +; X32-NEXT: adcl -232(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -76(%ebp) # 4-byte Spill +; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl -172(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl -32(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -36(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %edx, -508(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -68(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl %edx, -504(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -20(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl %edx, -328(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -368(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl %edx, -468(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -44(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -376(%ebp), %edx # 4-byte Reload +; X32-NEXT: adcl %edx, -464(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -48(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl %edx, -404(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -52(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl %edx, -540(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -56(%ebp), %edx # 4-byte Reload +; X32-NEXT: adcl %edx, -544(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -24(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl %edx, -228(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -464(%ebp), %edx # 4-byte Reload +; X32-NEXT: adcl %edx, -220(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -460(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl %edx, -196(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -232(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -224(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl -152(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -112(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl $0, %esi -; X32-NEXT: movl -72(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -88(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl $0, %edi -; X32-NEXT: movl -64(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -40(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: adcl $0, -40(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -56(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -28(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -76(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %eax -; X32-NEXT: addl -292(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -232(%ebp) # 4-byte Spill -; X32-NEXT: adcl -372(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -152(%ebp) # 4-byte Spill -; X32-NEXT: adcl -88(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -72(%ebp) # 4-byte Spill -; X32-NEXT: adcl -296(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -64(%ebp) # 4-byte Spill -; X32-NEXT: adcl -272(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -288(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -224(%ebp) # 4-byte Spill +; X32-NEXT: adcl -380(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -112(%ebp) # 4-byte Spill +; X32-NEXT: adcl -84(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -88(%ebp) # 4-byte Spill +; X32-NEXT: adcl -292(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -40(%ebp) # 4-byte Spill +; X32-NEXT: adcl -264(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -344(%ebp) # 4-byte Spill -; X32-NEXT: movl -40(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -36(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -40(%ebp) # 4-byte Spill -; X32-NEXT: movl -56(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -28(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -44(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl -76(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -332(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -56(%ebp) # 4-byte Spill -; X32-NEXT: adcl -80(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill -; X32-NEXT: setb -372(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl %ecx, -76(%ebp) # 4-byte Spill +; X32-NEXT: adcl -72(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill +; X32-NEXT: setb -380(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -408(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -188(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -240(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -276(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -232(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -272(%ebp) # 4-byte Spill ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -240(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -232(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -148(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -152(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -240(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -232(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: setb %bl ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload @@ -3416,27 +3379,27 @@ ; X32-NEXT: movl -412(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -204(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -80(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -72(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl %esi, -172(%ebp) # 4-byte Spill ; X32-NEXT: movl -440(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -188(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -36(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -272(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -44(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -264(%ebp) # 4-byte Spill ; X32-NEXT: movl -340(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -36(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -44(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -148(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -152(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -296(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -292(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl -340(%ebp), %edi # 4-byte Reload @@ -3445,20 +3408,20 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -680(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -684(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -884(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -276(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -272(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -20(%ebp) # 4-byte Spill -; X32-NEXT: adcl -240(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -36(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -80(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl -232(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -44(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -72(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -172(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -440(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -236(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -228(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi -; X32-NEXT: movl %eax, -276(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -272(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi @@ -3466,11 +3429,11 @@ ; X32-NEXT: addl %esi, %ecx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -112(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -116(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -240(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -232(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ebx ; X32-NEXT: setb %cl ; X32-NEXT: movl -340(%ebp), %eax # 4-byte Reload @@ -3478,26 +3441,26 @@ ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -132(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -136(%ebp), %ebx # 4-byte Reload ; X32-NEXT: addl -304(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl -140(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -128(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -144(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -132(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %edx, %ecx ; X32-NEXT: movl -20(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -276(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -36(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -240(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl %eax, -272(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -44(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -232(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -80(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -72(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl -172(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: setb -20(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -408(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -236(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -228(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, -172(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -80(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, %edi @@ -3505,10 +3468,10 @@ ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl %edx, -172(%ebp) # 4-byte Spill ; X32-NEXT: movl -408(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -112(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -116(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill ; X32-NEXT: adcl -172(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %edi ; X32-NEXT: setb -172(%ebp) # 1-byte Folded Spill @@ -3520,33 +3483,33 @@ ; X32-NEXT: movl -392(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl -304(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl -412(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -128(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -132(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl %esi, -172(%ebp) # 4-byte Spill -; X32-NEXT: movl -80(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -72(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ebx, %edx -; X32-NEXT: movl -36(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -44(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi ; X32-NEXT: movzbl -20(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: movl -172(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax -; X32-NEXT: addl -680(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -80(%ebp) # 4-byte Spill +; X32-NEXT: addl -684(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -72(%ebp) # 4-byte Spill ; X32-NEXT: adcl -856(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -44(%ebp) # 4-byte Spill ; X32-NEXT: adcl -852(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -292(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -288(%ebp) # 4-byte Spill ; X32-NEXT: adcl -848(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -172(%ebp) # 4-byte Spill -; X32-NEXT: movl -352(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -356(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -188(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, -20(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill -; X32-NEXT: movl -120(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl -124(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %edi @@ -3554,19 +3517,19 @@ ; X32-NEXT: addl -20(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: mull -148(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -152(%ebp) # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -56(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -148(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -152(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -364(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -368(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl -100(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -396(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl -204(%ebp), %edi # 4-byte Folded Reload @@ -3574,23 +3537,23 @@ ; X32-NEXT: movl %ecx, -24(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %edi ; X32-NEXT: movl %edi, -20(%ebp) # 4-byte Spill -; X32-NEXT: movl -416(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -420(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -188(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %edx, -88(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -432(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -84(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -436(%ebp) # 4-byte Spill ; X32-NEXT: movl -316(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -88(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -84(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -456(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -452(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl -316(%ebp), %edi # 4-byte Reload @@ -3599,20 +3562,20 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -656(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -660(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -892(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -44(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -32(%ebp) # 4-byte Spill -; X32-NEXT: adcl -52(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -88(%ebp) # 4-byte Spill +; X32-NEXT: addl -48(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill +; X32-NEXT: adcl -56(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -84(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -24(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -20(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -416(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -420(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -236(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -228(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi @@ -3620,11 +3583,11 @@ ; X32-NEXT: addl %ebx, %ecx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -112(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -116(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -56(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ebx ; X32-NEXT: setb %cl ; X32-NEXT: movl -316(%ebp), %eax # 4-byte Reload @@ -3635,105 +3598,105 @@ ; X32-NEXT: movl -324(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl -304(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -400(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -128(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -132(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -44(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -88(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -52(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -36(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -48(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -84(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -56(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: adcl $0, %esi ; X32-NEXT: addl -24(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl -20(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: setb -24(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -352(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -236(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -356(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -228(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %edx, -88(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -84(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -20(%ebp) # 4-byte Spill -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -88(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -84(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl %edx, -32(%ebp) # 4-byte Spill -; X32-NEXT: movl -352(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -112(%ebp), %edi # 4-byte Reload -; X32-NEXT: mull %edi -; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill -; X32-NEXT: adcl -32(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl -356(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -116(%ebp), %edi # 4-byte Reload +; X32-NEXT: mull %edi +; X32-NEXT: addl %ebx, %eax +; X32-NEXT: movl %eax, -84(%ebp) # 4-byte Spill +; X32-NEXT: adcl -36(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: setb -32(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: setb -36(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movzbl -32(%ebp), %edi # 1-byte Folded Reload +; X32-NEXT: movzbl -36(%ebp), %edi # 1-byte Folded Reload ; X32-NEXT: adcl %edi, %edx -; X32-NEXT: movl -364(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -368(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl -304(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl -396(%ebp), %ebx # 4-byte Reload -; X32-NEXT: adcl -128(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -132(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ebx ; X32-NEXT: movl -20(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ecx, %edx -; X32-NEXT: movl -88(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -84(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: movzbl -24(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: addl -656(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: adcl -700(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -660(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -704(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl -860(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl -864(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: addl -272(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -264(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -20(%ebp) # 4-byte Spill -; X32-NEXT: adcl -296(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -88(%ebp) # 4-byte Spill -; X32-NEXT: adcl -276(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: adcl -292(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -84(%ebp) # 4-byte Spill +; X32-NEXT: adcl -272(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl %edi, -332(%ebp) # 4-byte Spill -; X32-NEXT: adcl -240(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -368(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -80(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -36(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -292(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl -232(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -376(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -72(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -44(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -288(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -172(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -352(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -356(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: movl -300(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi -; X32-NEXT: movl %eax, -276(%ebp) # 4-byte Spill -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %eax, -272(%ebp) # 4-byte Spill +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ecx ; X32-NEXT: addl %esi, %ecx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -144(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -148(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -240(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -232(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: setb %cl -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -364(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -368(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl -336(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -396(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -176(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -32(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -36(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -296(%ebp) # 4-byte Spill -; X32-NEXT: movl -416(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl %esi, -292(%ebp) # 4-byte Spill +; X32-NEXT: movl -420(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: movl -300(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi @@ -3746,11 +3709,11 @@ ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -144(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -148(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -272(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -264(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb -68(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -316(%ebp), %esi # 4-byte Reload @@ -3759,20 +3722,20 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl -68(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -684(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -688(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -868(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -276(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -272(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -512(%ebp) # 4-byte Spill -; X32-NEXT: adcl -240(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -232(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -68(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -32(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -296(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -416(%ebp), %edi # 4-byte Reload +; X32-NEXT: adcl $0, -36(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -292(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -420(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax -; X32-NEXT: movl -244(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -236(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: movl %eax, -276(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -272(%ebp) # 4-byte Spill ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi @@ -3784,7 +3747,7 @@ ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -240(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -232(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %edi ; X32-NEXT: setb %cl ; X32-NEXT: movl -316(%ebp), %eax # 4-byte Reload @@ -3793,90 +3756,90 @@ ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -324(%ebp), %ebx # 4-byte Reload -; X32-NEXT: addl -224(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -200(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl -400(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -360(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -364(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %edx, %ecx ; X32-NEXT: movl -512(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -276(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl %eax, -272(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -68(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -240(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %eax, -232(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -32(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: adcl -296(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -36(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -292(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: setb -512(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -352(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -244(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -356(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -236(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -32(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -296(%ebp) # 4-byte Spill -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %edx, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -292(%ebp) # 4-byte Spill +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, %edi -; X32-NEXT: addl -32(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -36(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl %edx, -68(%ebp) # 4-byte Spill -; X32-NEXT: movl -352(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -356(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -164(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -32(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill ; X32-NEXT: adcl -68(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %edi ; X32-NEXT: setb -68(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl -68(%ebp), %esi # 1-byte Folded Reload ; X32-NEXT: adcl %esi, %edx -; X32-NEXT: movl -364(%ebp), %edi # 4-byte Reload -; X32-NEXT: addl -224(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl -368(%ebp), %edi # 4-byte Reload +; X32-NEXT: addl -200(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl -396(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -360(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -364(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl %esi, -68(%ebp) # 4-byte Spill -; X32-NEXT: movl -296(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -292(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ebx, %edx -; X32-NEXT: movl -32(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -36(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi ; X32-NEXT: movzbl -512(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: movl -68(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax -; X32-NEXT: addl -684(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -688(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: adcl -876(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: adcl -872(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl -880(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl -20(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl %ecx, -24(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -88(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %ecx, -272(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -84(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl %ecx, -264(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -332(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %ecx, -276(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -368(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %ecx, -240(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %ecx, -272(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -376(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl %ecx, -232(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %edx ; X32-NEXT: adcl $0, %esi ; X32-NEXT: adcl $0, %edi ; X32-NEXT: adcl $0, %eax -; X32-NEXT: addl -80(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -296(%ebp) # 4-byte Spill -; X32-NEXT: adcl -36(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -32(%ebp) # 4-byte Spill -; X32-NEXT: adcl -292(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -292(%ebp) # 4-byte Spill +; X32-NEXT: addl -72(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -292(%ebp) # 4-byte Spill +; X32-NEXT: adcl -44(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -36(%ebp) # 4-byte Spill +; X32-NEXT: adcl -288(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -288(%ebp) # 4-byte Spill ; X32-NEXT: adcl -172(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -68(%ebp) # 4-byte Spill -; X32-NEXT: setb -88(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -84(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -408(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: movl -300(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill ; X32-NEXT: movl -192(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi @@ -3884,7 +3847,7 @@ ; X32-NEXT: addl %ecx, %esi ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -144(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -148(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %esi, %eax @@ -3917,11 +3880,11 @@ ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -144(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -148(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -80(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb -332(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -340(%ebp), %eax # 4-byte Reload @@ -3930,19 +3893,19 @@ ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: movzbl -332(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edx -; X32-NEXT: addl -688(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -692(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl -888(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -36(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -44(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl -20(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -332(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -336(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -176(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -440(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -244(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -236(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, -20(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -44(%ebp) # 4-byte Spill ; X32-NEXT: movl -340(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx @@ -3962,25 +3925,25 @@ ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -132(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -224(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -140(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -360(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -136(%ebp), %esi # 4-byte Reload +; X32-NEXT: addl -200(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -144(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -364(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: addl %edi, -36(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl %edi, -44(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -332(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -20(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %esi ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: addl -336(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -132(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -136(%ebp) # 4-byte Spill ; X32-NEXT: adcl -176(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -140(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -144(%ebp) # 4-byte Spill ; X32-NEXT: setb -176(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -408(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -244(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -236(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, -332(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -336(%ebp) # 4-byte Spill @@ -4003,253 +3966,253 @@ ; X32-NEXT: movzbl -332(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -392(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -224(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -200(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl -412(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -360(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -364(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx ; X32-NEXT: movl -336(%ebp), %ebx # 4-byte Reload -; X32-NEXT: addl -132(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: adcl -140(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -136(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -144(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movzbl -176(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %esi ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -688(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -692(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl -900(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -360(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -364(%ebp) # 4-byte Spill ; X32-NEXT: adcl -896(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -392(%ebp) # 4-byte Spill ; X32-NEXT: adcl -904(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -412(%ebp) # 4-byte Spill ; X32-NEXT: movl -172(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -296(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -80(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl -32(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl -36(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -292(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -292(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -72(%ebp), %edx # 4-byte Reload +; X32-NEXT: adcl -36(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl -44(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -288(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl -20(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl -68(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movzbl -88(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -84(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %ebx ; X32-NEXT: movl %ebx, -336(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -360(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -364(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -392(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax ; X32-NEXT: movl -412(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: addl -656(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -660(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -172(%ebp) # 4-byte Spill -; X32-NEXT: adcl -700(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -80(%ebp) # 4-byte Spill -; X32-NEXT: adcl -376(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: adcl -220(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: adcl -704(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -72(%ebp) # 4-byte Spill +; X32-NEXT: adcl -384(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -352(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl -336(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -640(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -360(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl -200(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: adcl -472(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -644(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -364(%ebp), %edx # 4-byte Reload +; X32-NEXT: adcl -268(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -296(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -392(%ebp) # 4-byte Spill -; X32-NEXT: adcl -436(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl -232(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -432(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -152(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -456(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -72(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -44(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -52(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl -468(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl -224(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -436(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -112(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -452(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -88(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -48(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -40(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -56(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -344(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -24(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -40(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -272(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -56(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -276(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -264(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -76(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -240(%ebp) # 4-byte Folded Spill -; X32-NEXT: movzbl -372(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: adcl %eax, -272(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -232(%ebp) # 4-byte Folded Spill +; X32-NEXT: movzbl -380(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, -172(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -80(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -72(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %esi -; X32-NEXT: movl %esi, -36(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -44(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %edi, -20(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: movl %ecx, -336(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl %edx, -360(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -364(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -392(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: movl %ebx, -412(%ebp) # 4-byte Spill -; X32-NEXT: movl -284(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -280(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -476(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -472(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -140(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -132(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %edx, -144(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -136(%ebp) # 4-byte Spill +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -140(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -144(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -248(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -240(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -140(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -144(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: setb %bl -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -308(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -480(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -476(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -208(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -384(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -388(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -200(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -28(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl %esi, -176(%ebp) # 4-byte Spill ; X32-NEXT: movl -212(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -476(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -472(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill -; X32-NEXT: movl -252(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill +; X32-NEXT: movl -244(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx ; X32-NEXT: addl %ecx, %ebx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -248(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -240(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -220(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx -; X32-NEXT: setb -40(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -252(%ebp), %edi # 4-byte Reload +; X32-NEXT: setb -76(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -244(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, %ebx ; X32-NEXT: addl %ecx, %ebx -; X32-NEXT: movzbl -40(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -76(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edx -; X32-NEXT: addl -692(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -696(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl -920(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -132(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: adcl -140(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -56(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -200(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl -136(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -144(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -200(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -28(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -176(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -212(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -516(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -132(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -140(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -136(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -144(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ecx -; X32-NEXT: addl -132(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -136(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 76(%eax), %edx -; X32-NEXT: movl %edx, -132(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -136(%ebp) # 4-byte Spill ; X32-NEXT: movl -212(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %edi ; X32-NEXT: setb %cl -; X32-NEXT: movl -252(%ebp), %eax # 4-byte Reload -; X32-NEXT: mull -132(%ebp) # 4-byte Folded Reload +; X32-NEXT: movl -244(%ebp), %eax # 4-byte Reload +; X32-NEXT: mull -136(%ebp) # 4-byte Folded Reload ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -116(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -484(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -84(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -488(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -120(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -480(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -80(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -484(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: addl %ebx, -140(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -56(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -40(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl %ebx, -144(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -200(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -76(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: adcl $0, %esi -; X32-NEXT: addl -200(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -28(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl -176(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: setb -56(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -284(%ebp), %eax # 4-byte Reload +; X32-NEXT: setb -200(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -280(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -516(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %edx, -200(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -28(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -176(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -200(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -28(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl %edx, -224(%ebp) # 4-byte Spill -; X32-NEXT: movl -284(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -132(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl %edx, -268(%ebp) # 4-byte Spill +; X32-NEXT: movl -280(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -136(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -200(%ebp) # 4-byte Spill -; X32-NEXT: adcl -224(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %eax, -28(%ebp) # 4-byte Spill +; X32-NEXT: adcl -268(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: setb -224(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: setb -268(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movzbl -224(%ebp), %edi # 1-byte Folded Reload +; X32-NEXT: movzbl -268(%ebp), %edi # 1-byte Folded Reload ; X32-NEXT: adcl %edi, %edx ; X32-NEXT: movl -308(%ebp), %edi # 4-byte Reload -; X32-NEXT: addl -484(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -480(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl -208(%ebp), %ebx # 4-byte Reload -; X32-NEXT: adcl -488(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -484(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ebx ; X32-NEXT: movl -176(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ecx, %edx -; X32-NEXT: movl -200(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -28(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: movzbl -56(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -200(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: addl -692(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -696(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -176(%ebp) # 4-byte Spill ; X32-NEXT: adcl -908(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -200(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -28(%ebp) # 4-byte Spill ; X32-NEXT: adcl -916(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl %edi, -68(%ebp) # 4-byte Spill ; X32-NEXT: adcl -912(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -32(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -36(%ebp) # 4-byte Spill ; X32-NEXT: movl -108(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -476(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -472(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -56(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -200(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -296(%ebp) # 4-byte Spill ; X32-NEXT: movl -96(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -56(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -200(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -248(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -240(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: setb %bl ; X32-NEXT: movl -96(%ebp), %eax # 4-byte Reload @@ -4258,31 +4221,31 @@ ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -104(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -480(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -476(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -156(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -384(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -388(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -224(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -268(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -56(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -200(%ebp) # 4-byte Spill ; X32-NEXT: movl -168(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -476(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -472(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -436(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -352(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -344(%ebp) # 4-byte Spill ; X32-NEXT: movl -92(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -436(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -352(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -248(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -240(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -232(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -224(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl -92(%ebp), %edi # 4-byte Reload @@ -4291,32 +4254,32 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -696(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -700(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -932(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -76(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill -; X32-NEXT: adcl -72(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -76(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -224(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -56(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl -296(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -84(%ebp) # 4-byte Spill +; X32-NEXT: adcl -64(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -296(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -268(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -200(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -168(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -516(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -72(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -436(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -352(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %eax, %ecx -; X32-NEXT: addl -72(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -64(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -132(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -136(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -472(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -468(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %edi ; X32-NEXT: setb %cl ; X32-NEXT: movl -92(%ebp), %eax # 4-byte Reload @@ -4324,164 +4287,164 @@ ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -28(%ebp), %edi # 4-byte Reload -; X32-NEXT: addl -484(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -256(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -488(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -32(%ebp), %edi # 4-byte Reload +; X32-NEXT: addl -480(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl -248(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -484(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -88(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -436(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -76(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -472(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -84(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -352(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -296(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -468(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %edi ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -224(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: adcl -56(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: setb -56(%ebp) # 1-byte Folded Spill +; X32-NEXT: addl -268(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: adcl -200(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: setb -200(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -108(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -516(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -76(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -224(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -296(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -268(%ebp) # 4-byte Spill ; X32-NEXT: movl -96(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -76(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -296(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl %edx, -72(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -64(%ebp) # 4-byte Spill ; X32-NEXT: movl -108(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -132(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -136(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill -; X32-NEXT: adcl -72(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %eax, -296(%ebp) # 4-byte Spill +; X32-NEXT: adcl -64(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: setb -72(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -64(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -96(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movzbl -72(%ebp), %esi # 1-byte Folded Reload +; X32-NEXT: movzbl -64(%ebp), %esi # 1-byte Folded Reload ; X32-NEXT: adcl %esi, %edx ; X32-NEXT: movl -104(%ebp), %ebx # 4-byte Reload -; X32-NEXT: addl -484(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -480(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl -156(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -488(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -484(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ebx ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -72(%ebp) # 4-byte Spill -; X32-NEXT: movl -224(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl %esi, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl -268(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %edi, %edx -; X32-NEXT: movl -76(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -296(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi -; X32-NEXT: movzbl -56(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -200(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %ebx -; X32-NEXT: movl -72(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl $0, %eax -; X32-NEXT: addl -696(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: adcl -652(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -700(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -656(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: adcl -924(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl -928(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: addl -64(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -224(%ebp) # 4-byte Spill -; X32-NEXT: adcl -220(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -76(%ebp) # 4-byte Spill -; X32-NEXT: adcl -140(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -152(%ebp) # 4-byte Spill -; X32-NEXT: adcl -40(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill +; X32-NEXT: addl -88(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -268(%ebp) # 4-byte Spill +; X32-NEXT: adcl -40(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -296(%ebp) # 4-byte Spill +; X32-NEXT: adcl -144(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -112(%ebp) # 4-byte Spill +; X32-NEXT: adcl -76(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -176(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -200(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -28(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -68(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -32(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -36(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -108(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -548(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -552(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -40(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -140(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -76(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -144(%ebp) # 4-byte Spill ; X32-NEXT: movl -96(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -40(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -76(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: mull -544(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -548(%ebp) # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl %edi, %eax -; X32-NEXT: movl -544(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -548(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -104(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -380(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -360(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -156(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -356(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -416(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -220(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -40(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -88(%ebp) # 4-byte Spill ; X32-NEXT: movl -168(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -548(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -552(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -56(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -200(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -84(%ebp) # 4-byte Spill ; X32-NEXT: movl -92(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -56(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -200(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -296(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -292(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -56(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -200(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -92(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %edi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -56(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -200(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -704(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -708(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -948(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -140(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -292(%ebp) # 4-byte Spill -; X32-NEXT: adcl -40(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -376(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -220(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -64(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl -144(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -288(%ebp) # 4-byte Spill +; X32-NEXT: adcl -76(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -384(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -40(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -88(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -168(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -580(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -584(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -140(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -144(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ecx -; X32-NEXT: addl -140(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -144(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl 8(%ebp), %eax ; X32-NEXT: movl 92(%eax), %ebx ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %ebx ; X32-NEXT: movl %ebx, %esi -; X32-NEXT: movl %ebx, -140(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -144(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -56(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -200(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ebx ; X32-NEXT: setb %cl ; X32-NEXT: movl -92(%ebp), %eax # 4-byte Reload @@ -4489,152 +4452,152 @@ ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -28(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -600(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -256(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -604(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -32(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -604(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -248(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -608(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl -292(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -40(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -376(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -56(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -288(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -76(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -384(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -200(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: adcl $0, %esi -; X32-NEXT: addl -220(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: adcl -64(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: setb -376(%ebp) # 1-byte Folded Spill +; X32-NEXT: addl -40(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -88(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: setb -384(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -108(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -580(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -584(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %edx, -220(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -40(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill ; X32-NEXT: movl -96(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -220(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -40(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx -; X32-NEXT: movl %edx, -292(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -288(%ebp) # 4-byte Spill ; X32-NEXT: movl -108(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -140(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -144(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -220(%ebp) # 4-byte Spill -; X32-NEXT: adcl -292(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill +; X32-NEXT: adcl -288(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: setb -292(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -288(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -96(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movzbl -292(%ebp), %edi # 1-byte Folded Reload +; X32-NEXT: movzbl -288(%ebp), %edi # 1-byte Folded Reload ; X32-NEXT: adcl %edi, %edx ; X32-NEXT: movl -104(%ebp), %edi # 4-byte Reload -; X32-NEXT: addl -600(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -604(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl -156(%ebp), %ebx # 4-byte Reload -; X32-NEXT: adcl -604(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -608(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ebx -; X32-NEXT: movl -64(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -88(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ecx, %edx -; X32-NEXT: movl -220(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -40(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: movzbl -376(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -384(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: addl -704(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -708(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: adcl -940(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl -944(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl -936(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl -224(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -88(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -76(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -296(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -152(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -40(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -72(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -56(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -268(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -84(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -296(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -292(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -112(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -76(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -200(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %edx ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: addl -176(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -64(%ebp) # 4-byte Spill -; X32-NEXT: adcl -200(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -220(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -88(%ebp) # 4-byte Spill +; X32-NEXT: adcl -28(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -40(%ebp) # 4-byte Spill ; X32-NEXT: adcl -68(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl %edi, -68(%ebp) # 4-byte Spill -; X32-NEXT: adcl -32(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -152(%ebp) # 4-byte Spill -; X32-NEXT: setb -32(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -284(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -36(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -36(%ebp) # 4-byte Spill +; X32-NEXT: setb -64(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -280(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -548(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -552(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, -176(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %eax, %ecx ; X32-NEXT: addl %edi, %ecx ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -544(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -548(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -200(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -28(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %esi ; X32-NEXT: setb %cl -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -380(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -360(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl -308(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -356(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -416(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -208(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi -; X32-NEXT: movl %esi, -380(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -360(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl %ecx, -356(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -416(%ebp) # 4-byte Spill ; X32-NEXT: movl -212(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax -; X32-NEXT: movl -548(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -552(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -76(%ebp) # 4-byte Spill -; X32-NEXT: movl -252(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %eax, -268(%ebp) # 4-byte Spill +; X32-NEXT: movl -244(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ebx ; X32-NEXT: addl %ecx, %ebx ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %edi, %eax -; X32-NEXT: movl -544(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -548(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -72(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -296(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb %bl -; X32-NEXT: movl -252(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -244(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %edi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -708(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -712(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -960(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: addl -176(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -376(%ebp) # 4-byte Spill -; X32-NEXT: adcl -200(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -224(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -380(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -356(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl %eax, -384(%ebp) # 4-byte Spill +; X32-NEXT: adcl -28(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -112(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -360(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -416(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -212(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -580(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -584(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, -176(%ebp) # 4-byte Spill @@ -4645,47 +4608,47 @@ ; X32-NEXT: addl %edi, %ecx ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: movl -212(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -140(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -144(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -200(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -28(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %esi ; X32-NEXT: setb %cl -; X32-NEXT: movl -252(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -244(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edi, %ebx ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -116(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -600(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -84(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -604(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -120(%ebp), %esi # 4-byte Reload +; X32-NEXT: addl -604(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -80(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -608(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -376(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -384(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %eax, -176(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -224(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -200(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -112(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -28(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %esi ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -380(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -116(%ebp) # 4-byte Spill -; X32-NEXT: adcl -356(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -84(%ebp) # 4-byte Spill -; X32-NEXT: setb -356(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -284(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -360(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -120(%ebp) # 4-byte Spill +; X32-NEXT: adcl -416(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -80(%ebp) # 4-byte Spill +; X32-NEXT: setb -360(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -280(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -580(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -584(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -380(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -224(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %edx, -112(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -416(%ebp) # 4-byte Spill +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %edi -; X32-NEXT: addl -380(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -112(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: mull %ebx @@ -4693,41 +4656,41 @@ ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movl %eax, %edi ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -380(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: setb -112(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -380(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -112(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -308(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -600(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -604(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl -208(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -604(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -608(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -224(%ebp), %edx # 4-byte Reload -; X32-NEXT: addl -116(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: adcl -84(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movzbl -356(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movl -416(%ebp), %edx # 4-byte Reload +; X32-NEXT: addl -120(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -80(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movzbl -360(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %esi ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -708(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: adcl -660(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -712(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -664(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl -952(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: adcl -956(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -64(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -76(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -220(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -72(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -88(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -268(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -40(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -296(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -68(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -176(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -152(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -200(%ebp) # 4-byte Folded Spill -; X32-NEXT: movzbl -32(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movl -36(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -28(%ebp) # 4-byte Folded Spill +; X32-NEXT: movzbl -64(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edx -; X32-NEXT: movl %edx, -224(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -416(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %edi -; X32-NEXT: movl %edi, -380(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -64(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %esi, -308(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %ecx @@ -4736,121 +4699,121 @@ ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -188(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -116(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -356(%ebp) # 4-byte Spill -; X32-NEXT: movl -132(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %edx, -120(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -360(%ebp) # 4-byte Spill +; X32-NEXT: movl -136(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -116(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -120(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -148(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -152(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -32(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -36(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl -; X32-NEXT: movl -132(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -136(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -484(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -480(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl -100(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -488(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -484(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -204(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -84(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -80(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -116(%ebp) # 4-byte Spill -; X32-NEXT: movl -476(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %esi, -120(%ebp) # 4-byte Spill +; X32-NEXT: movl -472(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -188(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -220(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -64(%ebp) # 4-byte Spill -; X32-NEXT: movl -248(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %edx, -40(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -88(%ebp) # 4-byte Spill +; X32-NEXT: movl -240(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -220(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -40(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -148(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -152(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -220(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -40(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl -; X32-NEXT: movl -248(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -240(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -100(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -480(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -476(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl -204(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -384(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -388(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: addl -356(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -360(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -100(%ebp) # 4-byte Spill -; X32-NEXT: adcl -32(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -36(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -204(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -84(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -116(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -476(%ebp), %ebx # 4-byte Reload +; X32-NEXT: adcl $0, -80(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -120(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -472(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -236(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -228(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -356(%ebp) # 4-byte Spill -; X32-NEXT: movl -248(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %eax, -360(%ebp) # 4-byte Spill +; X32-NEXT: movl -240(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %edi ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -112(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -116(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movl %eax, %edi ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -32(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -248(%ebp), %eax # 4-byte Reload +; X32-NEXT: setb -36(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -240(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -32(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -36(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -480(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -476(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl -304(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -384(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -128(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -388(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -132(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx ; X32-NEXT: movl -100(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -356(%ebp) # 4-byte Folded Spill +; X32-NEXT: addl %eax, -360(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl -204(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -32(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -36(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %esi ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -84(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -480(%ebp) # 4-byte Spill -; X32-NEXT: adcl -116(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -384(%ebp) # 4-byte Spill +; X32-NEXT: addl -80(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -476(%ebp) # 4-byte Spill +; X32-NEXT: adcl -120(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -388(%ebp) # 4-byte Spill ; X32-NEXT: setb -204(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -516(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -236(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -228(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, -100(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -116(%ebp) # 4-byte Spill -; X32-NEXT: movl -132(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl %eax, -120(%ebp) # 4-byte Spill +; X32-NEXT: movl -136(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi @@ -4858,64 +4821,64 @@ ; X32-NEXT: addl -100(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: mull -112(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -116(%ebp) # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movl %eax, -100(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -84(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -80(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -112(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -116(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -84(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -80(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -484(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -480(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl -304(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -488(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -128(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -484(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -132(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -480(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -116(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -384(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -476(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -120(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -388(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -100(%ebp) # 4-byte Folded Spill ; X32-NEXT: movzbl -204(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %esi -; X32-NEXT: movl %esi, -484(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -480(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: movl %ecx, -488(%ebp) # 4-byte Spill -; X32-NEXT: movl -548(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %ecx, -484(%ebp) # 4-byte Spill +; X32-NEXT: movl -552(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %edi, %ecx ; X32-NEXT: imull %eax, %ecx -; X32-NEXT: movl -236(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -228(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, -204(%ebp) # 4-byte Spill ; X32-NEXT: addl %ecx, %edx -; X32-NEXT: imull -544(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: imull -548(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %edx, %esi -; X32-NEXT: movl %esi, -236(%ebp) # 4-byte Spill -; X32-NEXT: movl -580(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %esi, -228(%ebp) # 4-byte Spill +; X32-NEXT: movl -584(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, %esi -; X32-NEXT: movl -148(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -152(%ebp), %ebx # 4-byte Reload ; X32-NEXT: imull %ebx, %esi ; X32-NEXT: movl -188(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %eax, %ecx ; X32-NEXT: addl %esi, %edx -; X32-NEXT: movl -140(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -144(%ebp), %esi # 4-byte Reload ; X32-NEXT: imull %edi, %esi ; X32-NEXT: addl %edx, %esi ; X32-NEXT: addl -204(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -84(%ebp) # 4-byte Spill -; X32-NEXT: adcl -236(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -140(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -80(%ebp) # 4-byte Spill +; X32-NEXT: adcl -228(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -144(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: movl %edi, %esi -; X32-NEXT: movl -548(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -552(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -236(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -228(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %edi @@ -4923,52 +4886,52 @@ ; X32-NEXT: addl %ecx, %ebx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -544(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -548(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movl %eax, -204(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: setb %bl -; X32-NEXT: movl -148(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -152(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -84(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -80(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -304(%ebp) # 4-byte Spill -; X32-NEXT: adcl -140(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -84(%ebp) # 4-byte Spill -; X32-NEXT: movl -476(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -144(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -80(%ebp) # 4-byte Spill +; X32-NEXT: movl -472(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -164(%ebp), %esi # 4-byte Reload ; X32-NEXT: imull %eax, %esi -; X32-NEXT: movl -244(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -236(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx -; X32-NEXT: movl %eax, -148(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -152(%ebp) # 4-byte Spill ; X32-NEXT: addl %esi, %edx -; X32-NEXT: imull -248(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: imull -240(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %edx, %ecx -; X32-NEXT: movl %ecx, -244(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -236(%ebp) # 4-byte Spill ; X32-NEXT: movl -516(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, %esi -; X32-NEXT: movl -144(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -148(%ebp), %ebx # 4-byte Reload ; X32-NEXT: imull %ebx, %esi ; X32-NEXT: movl -300(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %eax, %edi ; X32-NEXT: addl %esi, %edx ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -132(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -136(%ebp), %ecx # 4-byte Reload ; X32-NEXT: imull %eax, %ecx ; X32-NEXT: addl %edx, %ecx -; X32-NEXT: addl -148(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -128(%ebp) # 4-byte Spill -; X32-NEXT: adcl -244(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -132(%ebp) # 4-byte Spill -; X32-NEXT: movl -476(%ebp), %esi # 4-byte Reload +; X32-NEXT: addl -152(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -132(%ebp) # 4-byte Spill +; X32-NEXT: adcl -236(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -136(%ebp) # 4-byte Spill +; X32-NEXT: movl -472(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -148(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -152(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi @@ -4976,39 +4939,39 @@ ; X32-NEXT: addl %ecx, %esi ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl -300(%ebp), %eax # 4-byte Reload -; X32-NEXT: mull -248(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -240(%ebp) # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %eax, %ecx ; X32-NEXT: addl %esi, %ecx ; X32-NEXT: adcl %edi, %ebx -; X32-NEXT: setb -244(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -144(%ebp), %eax # 4-byte Reload -; X32-NEXT: mull -248(%ebp) # 4-byte Folded Reload +; X32-NEXT: setb -236(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -148(%ebp), %eax # 4-byte Reload +; X32-NEXT: mull -240(%ebp) # 4-byte Folded Reload ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movzbl -244(%ebp), %esi # 1-byte Folded Reload +; X32-NEXT: movzbl -236(%ebp), %esi # 1-byte Folded Reload ; X32-NEXT: adcl %esi, %edx -; X32-NEXT: addl -128(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: adcl -132(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl -148(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -236(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -132(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -136(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl -152(%ebp), %esi # 4-byte Reload +; X32-NEXT: addl -228(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: adcl -204(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl -304(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: adcl -84(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -116(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -148(%ebp) # 4-byte Spill +; X32-NEXT: adcl -80(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -120(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -152(%ebp) # 4-byte Spill ; X32-NEXT: adcl -100(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -164(%ebp) # 4-byte Spill -; X32-NEXT: adcl -484(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -384(%ebp) # 4-byte Spill -; X32-NEXT: adcl -488(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -480(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -388(%ebp) # 4-byte Spill +; X32-NEXT: adcl -484(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -300(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %esi ; X32-NEXT: movl 104(%esi), %ebx ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl %ebx, -244(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -236(%ebp) # 4-byte Spill ; X32-NEXT: movl -168(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %eax, -236(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -228(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: movl 108(%esi), %eax ; X32-NEXT: movl %eax, -100(%ebp) # 4-byte Spill @@ -5024,79 +4987,79 @@ ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movl %eax, -204(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ebx -; X32-NEXT: setb -116(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -120(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -100(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %edi ; X32-NEXT: addl %ebx, %edi -; X32-NEXT: movzbl -116(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -120(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %esi -; X32-NEXT: movl -244(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -236(%ebp), %eax # 4-byte Reload ; X32-NEXT: xorl %ecx, %ecx ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -128(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -248(%ebp) # 4-byte Spill -; X32-NEXT: addl -28(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: adcl -256(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -132(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -240(%ebp) # 4-byte Spill +; X32-NEXT: addl -32(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -248(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -112(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -116(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %edx -; X32-NEXT: movl %edx, -140(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -144(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %ecx ; X32-NEXT: movl 96(%ecx), %edi ; X32-NEXT: movl %edi, %eax -; X32-NEXT: movl %edi, -84(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -80(%ebp) # 4-byte Spill ; X32-NEXT: movl -168(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, -304(%ebp) # 4-byte Spill -; X32-NEXT: movl %edx, -132(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -136(%ebp) # 4-byte Spill ; X32-NEXT: movl 100(%ecx), %eax -; X32-NEXT: movl %eax, -116(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -120(%ebp) # 4-byte Spill ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %eax, %esi -; X32-NEXT: addl -132(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -136(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: movl %edi, %eax ; X32-NEXT: movl -92(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: addl %esi, %eax -; X32-NEXT: movl %eax, -132(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -136(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %edi -; X32-NEXT: setb -144(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -116(%ebp), %ebx # 4-byte Reload +; X32-NEXT: setb -148(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -120(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ecx ; X32-NEXT: addl %edi, %ecx -; X32-NEXT: movzbl -144(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -148(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %esi -; X32-NEXT: movl -84(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -80(%ebp), %eax # 4-byte Reload ; X32-NEXT: xorl %edx, %edx ; X32-NEXT: mull %edx ; X32-NEXT: movl %edx, -188(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -144(%ebp) # 4-byte Spill -; X32-NEXT: movl -28(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl %eax, -148(%ebp) # 4-byte Spill +; X32-NEXT: movl -32(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl %eax, %edi -; X32-NEXT: movl -256(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -248(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %edx, %eax ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: adcl %esi, %eax -; X32-NEXT: addl -236(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -28(%ebp) # 4-byte Spill +; X32-NEXT: addl -228(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -32(%ebp) # 4-byte Spill ; X32-NEXT: adcl -204(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -256(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -112(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -140(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -84(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl %eax, -248(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -116(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -144(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -80(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -108(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, -204(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -236(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -228(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi @@ -5111,46 +5074,46 @@ ; X32-NEXT: movl %eax, -204(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ebx ; X32-NEXT: setb %cl -; X32-NEXT: movl -116(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -144(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -148(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl -104(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl -188(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -156(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -236(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -256(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -228(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -248(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -204(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %esi ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -112(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -144(%ebp) # 4-byte Spill -; X32-NEXT: adcl -140(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -116(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -148(%ebp) # 4-byte Spill +; X32-NEXT: adcl -144(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -188(%ebp) # 4-byte Spill -; X32-NEXT: setb -112(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -244(%ebp), %ecx # 4-byte Reload +; X32-NEXT: setb -116(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -236(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -108(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -256(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -248(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -32(%ebp) # 4-byte Spill ; X32-NEXT: movl -100(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -256(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -248(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: mull -96(%ebp) # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -256(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -248(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl %edi, %eax @@ -5159,28 +5122,28 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -248(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -240(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl -104(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -128(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -132(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -156(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -144(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -28(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -148(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -32(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -188(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -256(%ebp) # 4-byte Folded Spill -; X32-NEXT: movzbl -112(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: adcl %eax, -248(%ebp) # 4-byte Folded Spill +; X32-NEXT: movzbl -116(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi -; X32-NEXT: movl %edi, -248(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -240(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: movl %ecx, -128(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -132(%ebp) # 4-byte Spill ; X32-NEXT: movl 8(%ebp), %ecx ; X32-NEXT: movl 112(%ecx), %eax ; X32-NEXT: movl %eax, -156(%ebp) # 4-byte Spill ; X32-NEXT: imull %eax, %esi ; X32-NEXT: movl -108(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %eax, -144(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -148(%ebp) # 4-byte Spill ; X32-NEXT: addl %esi, %edx ; X32-NEXT: movl 116(%ecx), %eax ; X32-NEXT: movl %eax, -104(%ebp) # 4-byte Spill @@ -5200,18 +5163,18 @@ ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: imull %ecx, %ebx ; X32-NEXT: addl %edx, %ebx -; X32-NEXT: movl -144(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -148(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl %ecx, -96(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl -108(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl -156(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -144(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -148(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -108(%ebp) # 4-byte Spill ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: movl %eax, %edi -; X32-NEXT: addl -144(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -148(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: movl -168(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull -104(%ebp) # 4-byte Folded Reload @@ -5229,19 +5192,19 @@ ; X32-NEXT: movl %eax, -92(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %edx ; X32-NEXT: movl %edx, -96(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %edi # 4-byte Reload -; X32-NEXT: movl -84(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -80(%ebp), %eax # 4-byte Reload ; X32-NEXT: imull %eax, %edi -; X32-NEXT: movl -284(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -280(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %eax, -104(%ebp) # 4-byte Spill ; X32-NEXT: addl %edi, %edx -; X32-NEXT: imull -116(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: imull -120(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %edx, %ecx -; X32-NEXT: movl %ecx, -284(%ebp) # 4-byte Spill -; X32-NEXT: movl -244(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %ecx, -280(%ebp) # 4-byte Spill +; X32-NEXT: movl -236(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, %ecx -; X32-NEXT: movl -252(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -244(%ebp), %ebx # 4-byte Reload ; X32-NEXT: imull %ebx, %ecx ; X32-NEXT: movl -212(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi @@ -5252,14 +5215,14 @@ ; X32-NEXT: addl %edx, %ecx ; X32-NEXT: addl -104(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -104(%ebp) # 4-byte Spill -; X32-NEXT: adcl -284(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -280(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -100(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: movl %edi, %ecx -; X32-NEXT: movl -84(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -80(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %esi -; X32-NEXT: movl %eax, -284(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -280(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %edi @@ -5267,79 +5230,79 @@ ; X32-NEXT: addl %esi, %ebx ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: mull -116(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -120(%ebp) # 4-byte Folded Reload ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ecx ; X32-NEXT: addl %ebx, %ecx ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: setb %bl -; X32-NEXT: movl -252(%ebp), %eax # 4-byte Reload -; X32-NEXT: mull -116(%ebp) # 4-byte Folded Reload +; X32-NEXT: movl -244(%ebp), %eax # 4-byte Reload +; X32-NEXT: mull -120(%ebp) # 4-byte Folded Reload ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movzbl %bl, %esi ; X32-NEXT: adcl %esi, %edx ; X32-NEXT: addl -104(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -100(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl -284(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -280(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl -108(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: adcl -168(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl -92(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -96(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -28(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -32(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, %edi -; X32-NEXT: adcl -256(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -248(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, %ebx -; X32-NEXT: adcl -248(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -116(%ebp) # 4-byte Spill -; X32-NEXT: adcl -128(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -256(%ebp) # 4-byte Spill +; X32-NEXT: adcl -240(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -120(%ebp) # 4-byte Spill +; X32-NEXT: adcl -132(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -248(%ebp) # 4-byte Spill ; X32-NEXT: movl -304(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl -64(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl -132(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -220(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -236(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl -356(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -88(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl -136(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -40(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -228(%ebp), %edx # 4-byte Reload +; X32-NEXT: adcl -360(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl -204(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -32(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: adcl -148(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -284(%ebp) # 4-byte Spill +; X32-NEXT: adcl -36(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -152(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -280(%ebp) # 4-byte Spill ; X32-NEXT: adcl -164(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl -384(%ebp), %edi # 4-byte Reload -; X32-NEXT: adcl %edi, -116(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -256(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -388(%ebp), %edi # 4-byte Reload +; X32-NEXT: adcl %edi, -120(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -248(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl -300(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: addl -76(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -268(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -304(%ebp) # 4-byte Spill -; X32-NEXT: adcl -72(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -132(%ebp) # 4-byte Spill +; X32-NEXT: adcl -296(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -136(%ebp) # 4-byte Spill ; X32-NEXT: adcl -176(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -236(%ebp) # 4-byte Spill -; X32-NEXT: adcl -200(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %edx, -228(%ebp) # 4-byte Spill +; X32-NEXT: adcl -28(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -204(%ebp) # 4-byte Spill -; X32-NEXT: movl -224(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -284(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl -380(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -140(%ebp) # 4-byte Spill +; X32-NEXT: movl -416(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -280(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl -64(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -144(%ebp) # 4-byte Spill ; X32-NEXT: movl -308(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -116(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %eax, -120(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl -208(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -256(%ebp) # 4-byte Spill -; X32-NEXT: movl -492(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl %edi, -248(%ebp) # 4-byte Spill +; X32-NEXT: movl -488(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -260(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -252(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %eax, -108(%ebp) # 4-byte Spill -; X32-NEXT: movl %edx, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -32(%ebp) # 4-byte Spill ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 92(%eax), %eax ; X32-NEXT: movl %eax, -96(%ebp) # 4-byte Spill ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -28(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -32(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -124(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax @@ -5351,49 +5314,49 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -556(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -136(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -560(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -264(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -560(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -140(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -564(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -256(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: movl %ecx, -92(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -28(%ebp) # 4-byte Spill -; X32-NEXT: movl -552(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %esi, -32(%ebp) # 4-byte Spill +; X32-NEXT: movl -556(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -260(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -252(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, -168(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -148(%ebp) # 4-byte Spill -; X32-NEXT: movl -460(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %eax, -152(%ebp) # 4-byte Spill +; X32-NEXT: movl -456(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx ; X32-NEXT: addl -168(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -124(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -128(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -132(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl -; X32-NEXT: movl -460(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -456(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %esi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -712(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -716(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -976(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: addl -108(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill ; X32-NEXT: adcl -104(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -168(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -92(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -28(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -552(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl $0, -32(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -556(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -184(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx @@ -5413,7 +5376,7 @@ ; X32-NEXT: movl %eax, -104(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %edi ; X32-NEXT: setb %cl -; X32-NEXT: movl -460(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -456(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl %cl, %ecx @@ -5421,19 +5384,19 @@ ; X32-NEXT: movl -524(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl -160(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -528(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -268(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -260(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl -48(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -52(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %eax, -108(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -168(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -104(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: adcl $0, %esi ; X32-NEXT: addl -92(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: adcl -28(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: setb -28(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -492(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -32(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: setb -32(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -488(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -184(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, -92(%ebp) # 4-byte Spill @@ -5444,7 +5407,7 @@ ; X32-NEXT: addl -92(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl %edx, -92(%ebp) # 4-byte Spill -; X32-NEXT: movl -492(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -488(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -60(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax @@ -5457,65 +5420,65 @@ ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movzbl -92(%ebp), %edi # 1-byte Folded Reload ; X32-NEXT: adcl %edi, %edx -; X32-NEXT: movl -556(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -560(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl -160(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -560(%ebp), %ebx # 4-byte Reload -; X32-NEXT: adcl -268(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl -564(%ebp), %ebx # 4-byte Reload +; X32-NEXT: adcl -260(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ebx ; X32-NEXT: movl -212(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ecx, %edx ; X32-NEXT: movl -208(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: movzbl -28(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -32(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: addl -712(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -716(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -212(%ebp) # 4-byte Spill ; X32-NEXT: adcl -968(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -208(%ebp) # 4-byte Spill ; X32-NEXT: adcl -964(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -244(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -236(%ebp) # 4-byte Spill ; X32-NEXT: adcl -972(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -248(%ebp) # 4-byte Spill -; X32-NEXT: movl -388(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl %ebx, -240(%ebp) # 4-byte Spill +; X32-NEXT: movl -424(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -260(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -252(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %eax, -92(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, -168(%ebp) # 4-byte Spill ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 76(%eax), %eax -; X32-NEXT: movl %eax, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -32(%ebp) # 4-byte Spill ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx ; X32-NEXT: addl -168(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -124(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -252(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -244(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl -; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -564(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -136(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -568(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -264(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -568(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -140(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -572(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -256(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: movl %ecx, -156(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -52(%ebp) # 4-byte Spill ; X32-NEXT: movl -520(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -260(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -252(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, -308(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -168(%ebp) # 4-byte Spill @@ -5526,7 +5489,7 @@ ; X32-NEXT: addl -308(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -124(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax @@ -5539,20 +5502,20 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -716(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -720(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -992(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: addl -92(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -84(%ebp) # 4-byte Spill -; X32-NEXT: adcl -252(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %eax, -80(%ebp) # 4-byte Spill +; X32-NEXT: adcl -244(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -100(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -156(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -48(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -52(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -520(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -184(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, -92(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -252(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -244(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx @@ -5572,81 +5535,81 @@ ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -500(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -496(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl -160(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -496(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -268(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -492(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -260(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -84(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -252(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -80(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -244(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -100(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -92(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %esi ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: addl -156(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: adcl -48(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: setb -48(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -388(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -52(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: setb -52(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -424(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -184(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, -156(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -100(%ebp) # 4-byte Spill -; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %eax, %ebx ; X32-NEXT: addl -156(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl %edx, -156(%ebp) # 4-byte Spill -; X32-NEXT: movl -388(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -424(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -60(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -84(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -80(%ebp) # 4-byte Spill ; X32-NEXT: adcl -156(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: setb -156(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movzbl -156(%ebp), %edi # 1-byte Folded Reload ; X32-NEXT: adcl %edi, %edx -; X32-NEXT: movl -564(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -568(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl -160(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -568(%ebp), %ebx # 4-byte Reload -; X32-NEXT: adcl -268(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl -572(%ebp), %ebx # 4-byte Reload +; X32-NEXT: adcl -260(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ebx ; X32-NEXT: movl -100(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %esi, %edx -; X32-NEXT: movl -84(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -80(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %ecx, %esi -; X32-NEXT: movzbl -48(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -52(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: addl -716(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -720(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: adcl -988(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: adcl -984(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl -980(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: addl -148(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: addl -152(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -100(%ebp) # 4-byte Spill -; X32-NEXT: adcl -128(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -84(%ebp) # 4-byte Spill +; X32-NEXT: adcl -132(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl %esi, -80(%ebp) # 4-byte Spill ; X32-NEXT: adcl -108(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -144(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -148(%ebp) # 4-byte Spill ; X32-NEXT: adcl -104(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl %ebx, -188(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -212(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -208(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -244(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -248(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -388(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl $0, -236(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -240(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -424(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -348(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: movl %eax, -108(%ebp) # 4-byte Spill -; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx @@ -5657,22 +5620,22 @@ ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl -; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -564(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -568(%ebp), %ecx # 4-byte Reload ; X32-NEXT: addl -180(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -568(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -572(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -320(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx -; X32-NEXT: movl %ecx, -128(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -132(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi -; X32-NEXT: movl %esi, -148(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -152(%ebp) # 4-byte Spill ; X32-NEXT: movl -520(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -348(%ebp), %edi # 4-byte Reload @@ -5692,27 +5655,27 @@ ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movl %eax, -104(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx -; X32-NEXT: setb -112(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -116(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -444(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -112(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -116(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -720(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -724(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -1008(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: addl -108(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -300(%ebp) # 4-byte Spill -; X32-NEXT: adcl -48(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -112(%ebp) # 4-byte Spill -; X32-NEXT: adcl $0, -128(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -148(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl -52(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -116(%ebp) # 4-byte Spill +; X32-NEXT: adcl $0, -132(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -152(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -520(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -288(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -284(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi -; X32-NEXT: movl %eax, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -52(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx @@ -5732,68 +5695,68 @@ ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -500(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -280(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -496(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -496(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -276(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -492(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl -312(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl -300(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -48(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -112(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -52(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -116(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -108(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: adcl $0, %esi -; X32-NEXT: addl -128(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: adcl -148(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: setb -112(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -388(%ebp), %eax # 4-byte Reload -; X32-NEXT: movl -288(%ebp), %edi # 4-byte Reload +; X32-NEXT: addl -132(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -152(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: setb -116(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl -424(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -284(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi -; X32-NEXT: movl %edx, -128(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -148(%ebp) # 4-byte Spill -; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %edx, -132(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -152(%ebp) # 4-byte Spill +; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -128(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -132(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edx ; X32-NEXT: movl %edx, -300(%ebp) # 4-byte Spill -; X32-NEXT: movl -388(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -424(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -16(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -128(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -132(%ebp) # 4-byte Spill ; X32-NEXT: adcl -300(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: setb -300(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ebx, %eax ; X32-NEXT: movzbl -300(%ebp), %edi # 1-byte Folded Reload ; X32-NEXT: adcl %edi, %edx -; X32-NEXT: movl -564(%ebp), %edi # 4-byte Reload -; X32-NEXT: addl -280(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -568(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -568(%ebp), %edi # 4-byte Reload +; X32-NEXT: addl -276(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl -572(%ebp), %ebx # 4-byte Reload ; X32-NEXT: adcl -312(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ebx -; X32-NEXT: movl -148(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl -152(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl %ecx, %edx -; X32-NEXT: movl -128(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -132(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: movzbl -112(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -116(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edi ; X32-NEXT: adcl $0, %ebx -; X32-NEXT: addl -720(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: adcl -664(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -724(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -668(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl -996(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl -1000(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl -100(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %eax, -156(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -84(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -80(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -104(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -144(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -48(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -148(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -52(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -188(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -108(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %edx @@ -5801,15 +5764,15 @@ ; X32-NEXT: adcl $0, %edi ; X32-NEXT: adcl $0, %ebx ; X32-NEXT: addl -212(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -148(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -152(%ebp) # 4-byte Spill ; X32-NEXT: adcl -208(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -128(%ebp) # 4-byte Spill -; X32-NEXT: adcl -244(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -84(%ebp) # 4-byte Spill -; X32-NEXT: adcl -248(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -144(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -132(%ebp) # 4-byte Spill +; X32-NEXT: adcl -236(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -80(%ebp) # 4-byte Spill +; X32-NEXT: adcl -240(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl %ebx, -148(%ebp) # 4-byte Spill ; X32-NEXT: setb -100(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -492(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -488(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: movl -348(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi @@ -5828,27 +5791,27 @@ ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movl %eax, -208(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx -; X32-NEXT: setb -248(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -240(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -96(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -248(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -240(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -180(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -556(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -560(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl -320(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -560(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -564(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: movl %esi, -180(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %ecx ; X32-NEXT: movl %ecx, -320(%ebp) # 4-byte Spill -; X32-NEXT: movl -552(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -556(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: movl -348(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -248(%ebp) # 4-byte Spill -; X32-NEXT: movl -460(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %eax, -240(%ebp) # 4-byte Spill +; X32-NEXT: movl -456(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %edi @@ -5859,29 +5822,29 @@ ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -244(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -236(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb -188(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -460(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -456(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %eax, %edi ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: movzbl -188(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edx -; X32-NEXT: addl -724(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -728(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl -1004(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: addl -212(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl -208(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -188(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -180(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -320(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -552(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -556(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax -; X32-NEXT: movl -288(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -284(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, -208(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -212(%ebp) # 4-byte Spill -; X32-NEXT: movl -460(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -456(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %eax, %ecx @@ -5894,13 +5857,13 @@ ; X32-NEXT: movl %eax, -208(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ebx, %esi ; X32-NEXT: setb %cl -; X32-NEXT: movl -460(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -456(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull -16(%ebp) # 4-byte Folded Reload ; X32-NEXT: addl %esi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -524(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -280(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -276(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl -528(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -312(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi @@ -5915,9 +5878,9 @@ ; X32-NEXT: adcl -320(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -528(%ebp) # 4-byte Spill ; X32-NEXT: setb -180(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -492(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -488(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -288(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -284(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, -188(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -320(%ebp) # 4-byte Spill @@ -5940,9 +5903,9 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl -188(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -556(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -280(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -560(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -560(%ebp), %esi # 4-byte Reload +; X32-NEXT: addl -276(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -564(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -312(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx @@ -5952,17 +5915,17 @@ ; X32-NEXT: movzbl -180(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %esi ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: addl -724(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: adcl -668(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: adcl -732(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: adcl -728(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl -148(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -248(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -244(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -84(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl -728(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -672(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: adcl -736(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -732(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -152(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -240(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -132(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl %eax, -236(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -80(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -212(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -144(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -148(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %eax, -208(%ebp) # 4-byte Folded Spill ; X32-NEXT: movzbl -100(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %edx @@ -5970,9 +5933,9 @@ ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %edi, -300(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %esi -; X32-NEXT: movl %esi, -556(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -560(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: movl %ecx, -560(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -564(%ebp) # 4-byte Spill ; X32-NEXT: movl 12(%ebp), %ebx ; X32-NEXT: movl 96(%ebx), %ecx ; X32-NEXT: movl %ecx, -312(%ebp) # 4-byte Spill @@ -5993,36 +5956,36 @@ ; X32-NEXT: movl %ebx, -100(%ebp) # 4-byte Spill ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -148(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -152(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi -; X32-NEXT: setb -280(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -276(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -60(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: movl %eax, %ebx ; X32-NEXT: addl %esi, %ebx -; X32-NEXT: movzbl -280(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movzbl -276(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %ecx ; X32-NEXT: movl -312(%ebp), %eax # 4-byte Reload ; X32-NEXT: xorl %edx, %edx ; X32-NEXT: mull %edx -; X32-NEXT: movl %eax, -84(%ebp) # 4-byte Spill -; X32-NEXT: movl %edx, -280(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -80(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -276(%ebp) # 4-byte Spill ; X32-NEXT: movl -160(%ebp), %edi # 4-byte Reload ; X32-NEXT: addl %eax, %edi -; X32-NEXT: movl -268(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -260(%ebp), %esi # 4-byte Reload ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: addl %ebx, %edi ; X32-NEXT: movl %edi, -188(%ebp) # 4-byte Spill ; X32-NEXT: adcl %ecx, %esi -; X32-NEXT: movl %esi, -144(%ebp) # 4-byte Spill -; X32-NEXT: movl -260(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl %esi, -148(%ebp) # 4-byte Spill +; X32-NEXT: movl -252(%ebp), %edi # 4-byte Reload ; X32-NEXT: movl %edi, %eax ; X32-NEXT: movl -312(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %eax, -164(%ebp) # 4-byte Spill -; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ecx @@ -6033,53 +5996,53 @@ ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -384(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -388(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %edi ; X32-NEXT: setb %cl -; X32-NEXT: movl -124(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %ebx ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -84(%ebp), %edi # 4-byte Reload -; X32-NEXT: addl -136(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -280(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -264(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -80(%ebp), %edi # 4-byte Reload +; X32-NEXT: addl -140(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl -276(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -256(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %edi ; X32-NEXT: adcl %edx, %ecx ; X32-NEXT: addl -180(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -84(%ebp) # 4-byte Spill -; X32-NEXT: adcl -148(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -280(%ebp) # 4-byte Spill +; X32-NEXT: movl %edi, -80(%ebp) # 4-byte Spill +; X32-NEXT: adcl -152(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -276(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -188(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl $0, -144(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl $0, -148(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 104(%eax), %ecx ; X32-NEXT: movl %ecx, -180(%ebp) # 4-byte Spill -; X32-NEXT: movl -260(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -252(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %ecx -; X32-NEXT: movl %edx, -128(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -148(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -132(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -152(%ebp) # 4-byte Spill ; X32-NEXT: movl %esi, %eax ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ecx -; X32-NEXT: addl -128(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -132(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl 12(%ebp), %eax ; X32-NEXT: movl 108(%eax), %edx ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: movl %edx, -112(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -116(%ebp) # 4-byte Spill ; X32-NEXT: mull %edx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movl %eax, -128(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -132(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %esi ; X32-NEXT: setb -176(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: movl %eax, %edi @@ -6090,77 +6053,77 @@ ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: xorl %edx, %edx ; X32-NEXT: mull %edx -; X32-NEXT: movl %edx, -200(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -28(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -176(%ebp) # 4-byte Spill -; X32-NEXT: movl -136(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -140(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl %eax, %esi -; X32-NEXT: movl -264(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -256(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl %edx, %eax ; X32-NEXT: addl %edi, %esi ; X32-NEXT: adcl %ecx, %eax -; X32-NEXT: movl -84(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl %ecx, -148(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -280(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl %ecx, -128(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -80(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl %ecx, -152(%ebp) # 4-byte Folded Spill +; X32-NEXT: movl -276(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl %ecx, -132(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, %esi ; X32-NEXT: adcl $0, %eax ; X32-NEXT: addl -188(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -136(%ebp) # 4-byte Spill -; X32-NEXT: adcl -144(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -264(%ebp) # 4-byte Spill -; X32-NEXT: setb -84(%ebp) # 1-byte Folded Spill +; X32-NEXT: movl %esi, -140(%ebp) # 4-byte Spill +; X32-NEXT: adcl -148(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -256(%ebp) # 4-byte Spill +; X32-NEXT: setb -80(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -184(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl %ebx, %esi ; X32-NEXT: mull %ebx -; X32-NEXT: movl %edx, -144(%ebp) # 4-byte Spill -; X32-NEXT: movl %eax, -280(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -148(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -276(%ebp) # 4-byte Spill ; X32-NEXT: movl -60(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %edi -; X32-NEXT: addl -144(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -148(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: mull -112(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -116(%ebp) # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movl %eax, %edi ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -144(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -148(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -112(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -116(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -144(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -148(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -160(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl -176(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -268(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -200(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -260(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -28(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -136(%ebp), %eax # 4-byte Reload -; X32-NEXT: addl %eax, -280(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl -264(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -136(%ebp) # 4-byte Spill -; X32-NEXT: movzbl -84(%ebp), %eax # 1-byte Folded Reload +; X32-NEXT: movl -140(%ebp), %eax # 4-byte Reload +; X32-NEXT: addl %eax, -276(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl -256(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -140(%ebp) # 4-byte Spill +; X32-NEXT: movzbl -80(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %esi ; X32-NEXT: movl %esi, -160(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %ecx -; X32-NEXT: movl %ecx, -268(%ebp) # 4-byte Spill +; X32-NEXT: movl %ecx, -260(%ebp) # 4-byte Spill ; X32-NEXT: movl -348(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %ebx, %ecx ; X32-NEXT: imull %eax, %ecx ; X32-NEXT: movl -180(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %eax, -264(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -256(%ebp) # 4-byte Spill ; X32-NEXT: addl %ecx, %edx ; X32-NEXT: imull -216(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %edx, %esi ; X32-NEXT: movl %esi, -180(%ebp) # 4-byte Spill -; X32-NEXT: movl -288(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -284(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, %esi ; X32-NEXT: movl -100(%ebp), %ebx # 4-byte Reload ; X32-NEXT: imull %ebx, %esi @@ -6171,15 +6134,15 @@ ; X32-NEXT: movl -16(%ebp), %esi # 4-byte Reload ; X32-NEXT: imull %edi, %esi ; X32-NEXT: addl %edx, %esi -; X32-NEXT: addl -264(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -84(%ebp) # 4-byte Spill +; X32-NEXT: addl -256(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -80(%ebp) # 4-byte Spill ; X32-NEXT: adcl -180(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -16(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: movl -348(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx -; X32-NEXT: movl %eax, -288(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -284(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi @@ -6191,7 +6154,7 @@ ; X32-NEXT: mull %edi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -264(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -256(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl -100(%ebp), %eax # 4-byte Reload @@ -6199,20 +6162,20 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -84(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -80(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -348(%ebp) # 4-byte Spill ; X32-NEXT: adcl -16(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -180(%ebp) # 4-byte Spill ; X32-NEXT: movl 12(%ebp), %edx ; X32-NEXT: movl 124(%edx), %ecx -; X32-NEXT: movl -260(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -252(%ebp), %eax # 4-byte Reload ; X32-NEXT: imull %eax, %ecx ; X32-NEXT: movl 120(%edx), %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: mull %esi ; X32-NEXT: movl %eax, -216(%ebp) # 4-byte Spill ; X32-NEXT: addl %ecx, %edx -; X32-NEXT: imull -124(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: imull -128(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %edx, %esi ; X32-NEXT: movl 112(%edi), %ebx ; X32-NEXT: movl 116(%edi), %ecx @@ -6230,7 +6193,7 @@ ; X32-NEXT: adcl %esi, %ecx ; X32-NEXT: movl %ecx, -60(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -260(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -252(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, -312(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -216(%ebp) # 4-byte Spill @@ -6241,39 +6204,39 @@ ; X32-NEXT: addl -312(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: mull -124(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -128(%ebp) # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx ; X32-NEXT: movl %eax, %ecx ; X32-NEXT: addl %esi, %ecx ; X32-NEXT: adcl %edi, %ebx -; X32-NEXT: setb -260(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -252(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload -; X32-NEXT: mull -124(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -128(%ebp) # 4-byte Folded Reload ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movzbl -260(%ebp), %esi # 1-byte Folded Reload +; X32-NEXT: movzbl -252(%ebp), %esi # 1-byte Folded Reload ; X32-NEXT: adcl %esi, %edx ; X32-NEXT: addl -184(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -60(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl -216(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -288(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: adcl -264(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -284(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -256(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl -348(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -180(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: addl -280(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -276(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -216(%ebp) # 4-byte Spill -; X32-NEXT: adcl -136(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -264(%ebp) # 4-byte Spill +; X32-NEXT: adcl -140(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -256(%ebp) # 4-byte Spill ; X32-NEXT: adcl -160(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -180(%ebp) # 4-byte Spill -; X32-NEXT: adcl -268(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -288(%ebp) # 4-byte Spill -; X32-NEXT: movl -352(%ebp), %esi # 4-byte Reload +; X32-NEXT: adcl -260(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -284(%ebp) # 4-byte Spill +; X32-NEXT: movl -356(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, %eax ; X32-NEXT: movl -520(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, -16(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -60(%ebp) # 4-byte Spill -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx @@ -6284,40 +6247,40 @@ ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -136(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -140(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -364(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -500(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -368(%ebp), %ecx # 4-byte Reload +; X32-NEXT: addl -496(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -396(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -496(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -492(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %eax, %ecx ; X32-NEXT: movl %ecx, -160(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edx, %esi ; X32-NEXT: movl %esi, -16(%ebp) # 4-byte Spill -; X32-NEXT: movl -416(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -420(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -520(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -124(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -128(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -184(%ebp) # 4-byte Spill ; X32-NEXT: movl -316(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %edi ; X32-NEXT: movl %eax, %ebx -; X32-NEXT: addl -124(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: addl -128(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl $0, %edi ; X32-NEXT: movl %ecx, %eax ; X32-NEXT: movl -444(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -124(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -128(%ebp) # 4-byte Spill ; X32-NEXT: adcl %edi, %ecx ; X32-NEXT: setb %bl ; X32-NEXT: movl -316(%ebp), %eax # 4-byte Reload @@ -6325,21 +6288,21 @@ ; X32-NEXT: addl %ecx, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -500(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -496(%ebp), %esi # 4-byte Reload ; X32-NEXT: addl -324(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -496(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -492(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -400(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx ; X32-NEXT: addl -60(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl %esi, -500(%ebp) # 4-byte Spill -; X32-NEXT: adcl -136(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -496(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -496(%ebp) # 4-byte Spill +; X32-NEXT: adcl -140(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -492(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, -160(%ebp) # 4-byte Folded Spill ; X32-NEXT: adcl $0, -16(%ebp) # 4-byte Folded Spill -; X32-NEXT: movl -416(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -420(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -388(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -424(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: movl %eax, -60(%ebp) # 4-byte Spill @@ -6350,28 +6313,28 @@ ; X32-NEXT: addl %ecx, %edi ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -28(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movl %eax, %edi ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -136(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -140(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl -316(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -136(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -140(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx ; X32-NEXT: movl -324(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -564(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -568(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl -400(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -568(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -572(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx -; X32-NEXT: movl -500(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -496(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %eax, -60(%ebp) # 4-byte Folded Spill -; X32-NEXT: adcl -496(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -136(%ebp) # 4-byte Spill +; X32-NEXT: adcl -492(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -140(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %esi ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: addl -160(%ebp), %esi # 4-byte Folded Reload @@ -6379,57 +6342,57 @@ ; X32-NEXT: adcl -16(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -400(%ebp) # 4-byte Spill ; X32-NEXT: setb -160(%ebp) # 1-byte Folded Spill -; X32-NEXT: movl -352(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -356(%ebp), %ecx # 4-byte Reload ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: movl -388(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -424(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %edx, -268(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -260(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, -16(%ebp) # 4-byte Spill -; X32-NEXT: movl -120(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -124(%ebp), %ebx # 4-byte Reload ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %edi -; X32-NEXT: addl -268(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: addl -260(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl $0, %esi ; X32-NEXT: movl %ecx, %eax -; X32-NEXT: mull -28(%ebp) # 4-byte Folded Reload +; X32-NEXT: mull -32(%ebp) # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ecx ; X32-NEXT: addl %edi, %eax -; X32-NEXT: movl %eax, -268(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -260(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %ecx -; X32-NEXT: setb -260(%ebp) # 1-byte Folded Spill +; X32-NEXT: setb -252(%ebp) # 1-byte Folded Spill ; X32-NEXT: movl %ebx, %eax -; X32-NEXT: movl -28(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %edi # 4-byte Reload ; X32-NEXT: mull %edi ; X32-NEXT: addl %ecx, %eax -; X32-NEXT: movzbl -260(%ebp), %ecx # 1-byte Folded Reload +; X32-NEXT: movzbl -252(%ebp), %ecx # 1-byte Folded Reload ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: movl -364(%ebp), %esi # 4-byte Reload -; X32-NEXT: addl -564(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -368(%ebp), %esi # 4-byte Reload +; X32-NEXT: addl -568(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl -396(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -568(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -572(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %eax, %esi ; X32-NEXT: adcl %edx, %ecx ; X32-NEXT: movl -324(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl %eax, -16(%ebp) # 4-byte Folded Spill ; X32-NEXT: movl -400(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl %eax, -268(%ebp) # 4-byte Folded Spill +; X32-NEXT: adcl %eax, -260(%ebp) # 4-byte Folded Spill ; X32-NEXT: movzbl -160(%ebp), %eax # 1-byte Folded Reload ; X32-NEXT: adcl %eax, %esi -; X32-NEXT: movl %esi, -364(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -368(%ebp) # 4-byte Spill ; X32-NEXT: adcl $0, %ecx ; X32-NEXT: movl %ecx, -396(%ebp) # 4-byte Spill ; X32-NEXT: movl -440(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %edi, %ecx ; X32-NEXT: imull %eax, %ecx -; X32-NEXT: movl -388(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -424(%ebp), %esi # 4-byte Reload ; X32-NEXT: mull %esi -; X32-NEXT: movl %eax, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -32(%ebp) # 4-byte Spill ; X32-NEXT: addl %ecx, %edx ; X32-NEXT: imull -340(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl %edx, %esi -; X32-NEXT: movl %esi, -388(%ebp) # 4-byte Spill +; X32-NEXT: movl %esi, -424(%ebp) # 4-byte Spill ; X32-NEXT: movl -408(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, %esi ; X32-NEXT: movl -444(%ebp), %ebx # 4-byte Reload @@ -6441,9 +6404,9 @@ ; X32-NEXT: movl -192(%ebp), %esi # 4-byte Reload ; X32-NEXT: imull %edi, %esi ; X32-NEXT: addl %edx, %esi -; X32-NEXT: addl -28(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -28(%ebp) # 4-byte Spill -; X32-NEXT: adcl -388(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: addl -32(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -32(%ebp) # 4-byte Spill +; X32-NEXT: adcl -424(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -192(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: movl -440(%ebp), %esi # 4-byte Reload @@ -6461,7 +6424,7 @@ ; X32-NEXT: mull %ecx ; X32-NEXT: movl %edx, %edi ; X32-NEXT: addl %ebx, %eax -; X32-NEXT: movl %eax, -260(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -252(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %edi ; X32-NEXT: setb %bl ; X32-NEXT: movl -444(%ebp), %eax # 4-byte Reload @@ -6469,46 +6432,46 @@ ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl %bl, %ecx ; X32-NEXT: adcl %ecx, %edx -; X32-NEXT: addl -28(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -32(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -340(%ebp) # 4-byte Spill ; X32-NEXT: adcl -192(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -192(%ebp) # 4-byte Spill -; X32-NEXT: movl -416(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -420(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -96(%ebp), %edi # 4-byte Reload ; X32-NEXT: imull %eax, %edi ; X32-NEXT: movl %eax, %esi -; X32-NEXT: movl -492(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -488(%ebp), %ecx # 4-byte Reload ; X32-NEXT: mull %ecx -; X32-NEXT: movl %eax, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -32(%ebp) # 4-byte Spill ; X32-NEXT: addl %edi, %edx ; X32-NEXT: imull -316(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: addl %edx, %ecx -; X32-NEXT: movl %ecx, -492(%ebp) # 4-byte Spill -; X32-NEXT: movl -352(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl %ecx, -488(%ebp) # 4-byte Spill +; X32-NEXT: movl -356(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, %ecx -; X32-NEXT: movl -460(%ebp), %edi # 4-byte Reload +; X32-NEXT: movl -456(%ebp), %edi # 4-byte Reload ; X32-NEXT: imull %edi, %ecx -; X32-NEXT: movl -552(%ebp), %ebx # 4-byte Reload +; X32-NEXT: movl -556(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: addl %ecx, %edx -; X32-NEXT: movl -120(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -124(%ebp), %ecx # 4-byte Reload ; X32-NEXT: imull %ebx, %ecx ; X32-NEXT: addl %edx, %ecx -; X32-NEXT: addl -28(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -32(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -96(%ebp) # 4-byte Spill -; X32-NEXT: adcl -492(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -120(%ebp) # 4-byte Spill +; X32-NEXT: adcl -488(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -124(%ebp) # 4-byte Spill ; X32-NEXT: movl %ebx, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: movl %eax, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -32(%ebp) # 4-byte Spill ; X32-NEXT: movl %edi, %eax ; X32-NEXT: mull %esi ; X32-NEXT: movl %edx, %esi ; X32-NEXT: movl %eax, %ecx ; X32-NEXT: addl %ebx, %ecx ; X32-NEXT: adcl $0, %esi -; X32-NEXT: movl -552(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -556(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl -316(%ebp), %ebx # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %edi @@ -6516,161 +6479,161 @@ ; X32-NEXT: movl %eax, -160(%ebp) # 4-byte Spill ; X32-NEXT: adcl %esi, %edi ; X32-NEXT: setb %cl -; X32-NEXT: movl -460(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -456(%ebp), %eax # 4-byte Reload ; X32-NEXT: mull %ebx ; X32-NEXT: movl %edx, %esi ; X32-NEXT: addl %edi, %eax ; X32-NEXT: movzbl %cl, %ecx ; X32-NEXT: adcl %ecx, %esi ; X32-NEXT: addl -96(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: adcl -120(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -28(%ebp), %edx # 4-byte Reload +; X32-NEXT: adcl -124(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -32(%ebp), %edx # 4-byte Reload ; X32-NEXT: addl -324(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl -160(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -260(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -252(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: adcl -340(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: adcl -192(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: addl -16(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, %ebx -; X32-NEXT: adcl -268(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -260(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -160(%ebp) # 4-byte Spill ; X32-NEXT: movl %eax, %edx -; X32-NEXT: adcl -364(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -368(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: adcl -396(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -16(%ebp) # 4-byte Spill ; X32-NEXT: movl -184(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl -164(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl -124(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -384(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl -128(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -388(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl -60(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -148(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -136(%ebp), %edi # 4-byte Reload -; X32-NEXT: adcl -128(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: adcl -152(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -140(%ebp), %edi # 4-byte Reload +; X32-NEXT: adcl -132(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: adcl -216(%ebp), %ebx # 4-byte Folded Reload -; X32-NEXT: movl %ebx, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl %ebx, -32(%ebp) # 4-byte Spill ; X32-NEXT: movl -160(%ebp), %ebx # 4-byte Reload -; X32-NEXT: adcl -264(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -256(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: adcl -180(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -120(%ebp) # 4-byte Spill +; X32-NEXT: movl %edx, -124(%ebp) # 4-byte Spill ; X32-NEXT: movl -16(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl -288(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: adcl -284(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: movl %edx, -16(%ebp) # 4-byte Spill -; X32-NEXT: addl -248(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: addl -240(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -184(%ebp) # 4-byte Spill -; X32-NEXT: adcl -244(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -124(%ebp) # 4-byte Spill +; X32-NEXT: adcl -236(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -128(%ebp) # 4-byte Spill ; X32-NEXT: adcl -212(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -60(%ebp) # 4-byte Spill ; X32-NEXT: adcl -208(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -136(%ebp) # 4-byte Spill -; X32-NEXT: movl -28(%ebp), %edx # 4-byte Reload +; X32-NEXT: movl %edi, -140(%ebp) # 4-byte Spill +; X32-NEXT: movl -32(%ebp), %edx # 4-byte Reload ; X32-NEXT: adcl -320(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: adcl -300(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl %ebx, -160(%ebp) # 4-byte Spill -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -556(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -120(%ebp) # 4-byte Spill -; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl -560(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -124(%ebp) # 4-byte Spill +; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -564(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -16(%ebp) # 4-byte Spill ; X32-NEXT: movl -168(%ebp), %eax # 4-byte Reload ; X32-NEXT: addl -344(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -168(%ebp) # 4-byte Spill ; X32-NEXT: movl -308(%ebp), %esi # 4-byte Reload -; X32-NEXT: adcl -232(%ebp), %esi # 4-byte Folded Reload -; X32-NEXT: movl -252(%ebp), %edi # 4-byte Reload -; X32-NEXT: adcl -436(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: adcl -224(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: movl -244(%ebp), %edi # 4-byte Reload +; X32-NEXT: adcl -352(%ebp), %edi # 4-byte Folded Reload ; X32-NEXT: movl -92(%ebp), %ebx # 4-byte Reload -; X32-NEXT: adcl -472(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -468(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl %ebx, -92(%ebp) # 4-byte Spill ; X32-NEXT: movl -156(%ebp), %ebx # 4-byte Reload -; X32-NEXT: adcl -88(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: adcl -84(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl -104(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -296(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -292(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -104(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -40(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -48(%ebp) # 4-byte Spill +; X32-NEXT: movl -52(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -76(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -52(%ebp) # 4-byte Spill ; X32-NEXT: movl -108(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -56(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -200(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -108(%ebp) # 4-byte Spill ; X32-NEXT: movl -184(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl -304(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -184(%ebp) # 4-byte Spill -; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -132(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -124(%ebp) # 4-byte Spill +; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -136(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: movl %eax, -128(%ebp) # 4-byte Spill ; X32-NEXT: movl -60(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -236(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -228(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -60(%ebp) # 4-byte Spill -; X32-NEXT: movl -136(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -140(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl -204(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -136(%ebp) # 4-byte Spill -; X32-NEXT: adcl -284(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl %edx, -28(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -140(%ebp) # 4-byte Spill +; X32-NEXT: adcl -280(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %edx, -32(%ebp) # 4-byte Spill ; X32-NEXT: movl -160(%ebp), %edx # 4-byte Reload -; X32-NEXT: adcl -140(%ebp), %edx # 4-byte Folded Reload -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload -; X32-NEXT: adcl -116(%ebp), %eax # 4-byte Folded Reload +; X32-NEXT: adcl -144(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload +; X32-NEXT: adcl -120(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl -16(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -256(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -248(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -16(%ebp) # 4-byte Spill ; X32-NEXT: movl -168(%ebp), %ecx # 4-byte Reload -; X32-NEXT: addl -432(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: addl -436(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -168(%ebp) # 4-byte Spill -; X32-NEXT: adcl -456(%ebp), %esi # 4-byte Folded Reload +; X32-NEXT: adcl -452(%ebp), %esi # 4-byte Folded Reload ; X32-NEXT: movl %esi, -308(%ebp) # 4-byte Spill -; X32-NEXT: adcl -44(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl %edi, -252(%ebp) # 4-byte Spill +; X32-NEXT: adcl -48(%ebp), %edi # 4-byte Folded Reload +; X32-NEXT: movl %edi, -244(%ebp) # 4-byte Spill ; X32-NEXT: movl -92(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -52(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -56(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -92(%ebp) # 4-byte Spill ; X32-NEXT: adcl -24(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl %ebx, -156(%ebp) # 4-byte Spill ; X32-NEXT: movl -104(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -272(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -264(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -104(%ebp) # 4-byte Spill -; X32-NEXT: movl -48(%ebp), %ebx # 4-byte Reload -; X32-NEXT: adcl -276(%ebp), %ebx # 4-byte Folded Reload +; X32-NEXT: movl -52(%ebp), %ebx # 4-byte Reload +; X32-NEXT: adcl -272(%ebp), %ebx # 4-byte Folded Reload ; X32-NEXT: movl -108(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -240(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -232(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -108(%ebp) # 4-byte Spill ; X32-NEXT: movl -184(%ebp), %edi # 4-byte Reload ; X32-NEXT: adcl -172(%ebp), %edi # 4-byte Folded Reload -; X32-NEXT: movl -124(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -80(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -124(%ebp) # 4-byte Spill +; X32-NEXT: movl -128(%ebp), %ecx # 4-byte Reload +; X32-NEXT: adcl -72(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -128(%ebp) # 4-byte Spill ; X32-NEXT: movl -60(%ebp), %ecx # 4-byte Reload -; X32-NEXT: adcl -36(%ebp), %ecx # 4-byte Folded Reload +; X32-NEXT: adcl -44(%ebp), %ecx # 4-byte Folded Reload ; X32-NEXT: movl %ecx, -60(%ebp) # 4-byte Spill -; X32-NEXT: movl -136(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl -140(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -20(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -136(%ebp) # 4-byte Spill -; X32-NEXT: movl -28(%ebp), %ecx # 4-byte Reload +; X32-NEXT: movl %ecx, -140(%ebp) # 4-byte Spill +; X32-NEXT: movl -32(%ebp), %ecx # 4-byte Reload ; X32-NEXT: adcl -336(%ebp), %ecx # 4-byte Folded Reload -; X32-NEXT: movl %ecx, -28(%ebp) # 4-byte Spill -; X32-NEXT: adcl -360(%ebp), %edx # 4-byte Folded Reload +; X32-NEXT: movl %ecx, -32(%ebp) # 4-byte Spill +; X32-NEXT: adcl -364(%ebp), %edx # 4-byte Folded Reload ; X32-NEXT: adcl -392(%ebp), %eax # 4-byte Folded Reload -; X32-NEXT: movl %eax, -120(%ebp) # 4-byte Spill +; X32-NEXT: movl %eax, -124(%ebp) # 4-byte Spill ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload ; X32-NEXT: adcl -412(%ebp), %eax # 4-byte Folded Reload ; X32-NEXT: movl %eax, -16(%ebp) # 4-byte Spill ; X32-NEXT: movl 16(%ebp), %ecx -; X32-NEXT: movl -648(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -652(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, (%ecx) -; X32-NEXT: movl -644(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -648(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 4(%ecx) -; X32-NEXT: movl -536(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -540(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 8(%ecx) -; X32-NEXT: movl -596(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -600(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 12(%ecx) -; X32-NEXT: movl -592(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -596(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 16(%ecx) -; X32-NEXT: movl -532(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -536(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 20(%ecx) -; X32-NEXT: movl -428(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -372(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 24(%ecx) -; X32-NEXT: movl -452(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -448(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 28(%ecx) ; X32-NEXT: movl -508(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 32(%ecx) @@ -6678,13 +6641,13 @@ ; X32-NEXT: movl %esi, 36(%ecx) ; X32-NEXT: movl -328(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 40(%ecx) -; X32-NEXT: movl -468(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -464(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 44(%ecx) ; X32-NEXT: movl -404(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 48(%ecx) -; X32-NEXT: movl -540(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -544(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 52(%ecx) -; X32-NEXT: movl -228(%ebp), %esi # 4-byte Reload +; X32-NEXT: movl -220(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 56(%ecx) ; X32-NEXT: movl -196(%ebp), %esi # 4-byte Reload ; X32-NEXT: movl %esi, 60(%ecx) @@ -6692,7 +6655,7 @@ ; X32-NEXT: movl %eax, 64(%ecx) ; X32-NEXT: movl -308(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, 68(%ecx) -; X32-NEXT: movl -252(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -244(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, 72(%ecx) ; X32-NEXT: movl -92(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, 76(%ecx) @@ -6704,16 +6667,16 @@ ; X32-NEXT: movl -108(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, 92(%ecx) ; X32-NEXT: movl %edi, 96(%ecx) -; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -128(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, 100(%ecx) ; X32-NEXT: movl -60(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, 104(%ecx) -; X32-NEXT: movl -136(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -140(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, 108(%ecx) -; X32-NEXT: movl -28(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -32(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, 112(%ecx) ; X32-NEXT: movl %edx, 116(%ecx) -; X32-NEXT: movl -120(%ebp), %eax # 4-byte Reload +; X32-NEXT: movl -124(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, 120(%ecx) ; X32-NEXT: movl -16(%ebp), %eax # 4-byte Reload ; X32-NEXT: movl %eax, 124(%ecx) Index: llvm/test/CodeGen/X86/peephole-na-phys-copy-folding.ll =================================================================== --- llvm/test/CodeGen/X86/peephole-na-phys-copy-folding.ll +++ llvm/test/CodeGen/X86/peephole-na-phys-copy-folding.ll @@ -219,19 +219,13 @@ ; CHECK32-NEXT: movl 24(%ebp), %ecx ; CHECK32-NEXT: movl 8(%ebp), %esi ; CHECK32-NEXT: lock cmpxchg8b (%esi) -; CHECK32-NEXT: pushl %eax -; CHECK32-NEXT: seto %al -; CHECK32-NEXT: lahf -; CHECK32-NEXT: movl %eax, %esi -; CHECK32-NEXT: popl %eax +; CHECK32-NEXT: setne %bl ; CHECK32-NEXT: subl $8, %esp ; CHECK32-NEXT: pushl %edx ; CHECK32-NEXT: pushl %eax ; CHECK32-NEXT: calll bar ; CHECK32-NEXT: addl $16, %esp -; CHECK32-NEXT: movl %esi, %eax -; CHECK32-NEXT: addb $127, %al -; CHECK32-NEXT: sahf +; CHECK32-NEXT: testb $-1, %bl ; CHECK32-NEXT: jne .LBB4_3 ; CHECK32-NEXT: # %bb.1: # %t ; CHECK32-NEXT: movl $42, %eax @@ -253,16 +247,10 @@ ; CHECK64-NEXT: pushq %rax ; CHECK64-NEXT: movq %rsi, %rax ; CHECK64-NEXT: lock cmpxchgq %rdx, (%rdi) -; CHECK64-NEXT: pushq %rax -; CHECK64-NEXT: seto %al -; CHECK64-NEXT: lahf -; CHECK64-NEXT: movq %rax, %rbx -; CHECK64-NEXT: popq %rax +; CHECK64-NEXT: setne %bl ; CHECK64-NEXT: movq %rax, %rdi ; CHECK64-NEXT: callq bar -; CHECK64-NEXT: movq %rbx, %rax -; CHECK64-NEXT: addb $127, %al -; CHECK64-NEXT: sahf +; CHECK64-NEXT: testb $-1, %bl ; CHECK64-NEXT: jne .LBB4_3 ; CHECK64-NEXT: # %bb.1: # %t ; CHECK64-NEXT: movl $42, %eax @@ -297,6 +285,7 @@ ; CHECK32-NEXT: pushl %ebx ; CHECK32-NEXT: pushl %edi ; CHECK32-NEXT: pushl %esi +; CHECK32-NEXT: pushl %eax ; CHECK32-NEXT: movl 44(%ebp), %edi ; CHECK32-NEXT: movl 12(%ebp), %eax ; CHECK32-NEXT: movl 16(%ebp), %edx @@ -304,21 +293,15 @@ ; CHECK32-NEXT: movl 24(%ebp), %ecx ; CHECK32-NEXT: movl 8(%ebp), %esi ; CHECK32-NEXT: lock cmpxchg8b (%esi) -; CHECK32-NEXT: seto %al -; CHECK32-NEXT: lahf -; CHECK32-NEXT: movl %eax, %esi +; CHECK32-NEXT: setne -13(%ebp) # 1-byte Folded Spill ; CHECK32-NEXT: movl 32(%ebp), %eax ; CHECK32-NEXT: movl 36(%ebp), %edx ; CHECK32-NEXT: movl %edi, %ecx ; CHECK32-NEXT: movl 40(%ebp), %ebx -; CHECK32-NEXT: movl 28(%ebp), %edi -; CHECK32-NEXT: lock cmpxchg8b (%edi) +; CHECK32-NEXT: movl 28(%ebp), %esi +; CHECK32-NEXT: lock cmpxchg8b (%esi) ; CHECK32-NEXT: sete %al -; CHECK32-NEXT: pushl %eax -; CHECK32-NEXT: movl %esi, %eax -; CHECK32-NEXT: addb $127, %al -; CHECK32-NEXT: sahf -; CHECK32-NEXT: popl %eax +; CHECK32-NEXT: testb $-1, -13(%ebp) # 1-byte Folded Reload ; CHECK32-NEXT: jne .LBB5_4 ; CHECK32-NEXT: # %bb.1: # %entry ; CHECK32-NEXT: testb %al, %al @@ -330,6 +313,7 @@ ; CHECK32-NEXT: xorl %eax, %eax ; CHECK32-NEXT: .LBB5_3: # %t ; CHECK32-NEXT: xorl %edx, %edx +; CHECK32-NEXT: addl $4, %esp ; CHECK32-NEXT: popl %esi ; CHECK32-NEXT: popl %edi ; CHECK32-NEXT: popl %ebx @@ -342,17 +326,11 @@ ; CHECK64-NEXT: movq %rsp, %rbp ; CHECK64-NEXT: movq %rsi, %rax ; CHECK64-NEXT: lock cmpxchgq %rdx, (%rdi) -; CHECK64-NEXT: seto %al -; CHECK64-NEXT: lahf -; CHECK64-NEXT: movq %rax, %rdx +; CHECK64-NEXT: setne %dl ; CHECK64-NEXT: movq %r8, %rax ; CHECK64-NEXT: lock cmpxchgq %r9, (%rcx) ; CHECK64-NEXT: sete %al -; CHECK64-NEXT: pushq %rax -; CHECK64-NEXT: movq %rdx, %rax -; CHECK64-NEXT: addb $127, %al -; CHECK64-NEXT: sahf -; CHECK64-NEXT: popq %rax +; CHECK64-NEXT: testb $-1, %dl ; CHECK64-NEXT: jne .LBB5_3 ; CHECK64-NEXT: # %bb.1: # %entry ; CHECK64-NEXT: testb %al, %al Index: llvm/test/CodeGen/X86/win64_frame.ll =================================================================== --- llvm/test/CodeGen/X86/win64_frame.ll +++ llvm/test/CodeGen/X86/win64_frame.ll @@ -224,71 +224,34 @@ declare i64 @dummy() define i64 @f10(i64* %foo, i64 %bar, i64 %baz) { -; PUSHF-LABEL: f10: -; PUSHF: # %bb.0: -; PUSHF-NEXT: pushq %rbp -; PUSHF-NEXT: .seh_pushreg 5 -; PUSHF-NEXT: pushq %rsi -; PUSHF-NEXT: .seh_pushreg 6 -; PUSHF-NEXT: pushq %rdi -; PUSHF-NEXT: .seh_pushreg 7 -; PUSHF-NEXT: subq $32, %rsp -; PUSHF-NEXT: .seh_stackalloc 32 -; PUSHF-NEXT: leaq {{[0-9]+}}(%rsp), %rbp -; PUSHF-NEXT: .seh_setframe 5, 32 -; PUSHF-NEXT: .seh_endprologue -; PUSHF-NEXT: movq %rdx, %rsi -; PUSHF-NEXT: movq %rdx, %rax -; PUSHF-NEXT: lock cmpxchgq %r8, (%rcx) -; PUSHF-NEXT: pushfq -; PUSHF-NEXT: popq %rdi -; PUSHF-NEXT: callq dummy -; PUSHF-NEXT: pushq %rdi -; PUSHF-NEXT: popfq -; PUSHF-NEXT: cmovneq %rsi, %rax -; PUSHF-NEXT: addq $32, %rsp -; PUSHF-NEXT: popq %rdi -; PUSHF-NEXT: popq %rsi -; PUSHF-NEXT: popq %rbp -; PUSHF-NEXT: retq -; PUSHF-NEXT: .seh_handlerdata -; PUSHF-NEXT: .text -; PUSHF-NEXT: .seh_endproc -; -; SAHF-LABEL: f10: -; SAHF: # %bb.0: -; SAHF-NEXT: pushq %rbp -; SAHF-NEXT: .seh_pushreg 5 -; SAHF-NEXT: pushq %rsi -; SAHF-NEXT: .seh_pushreg 6 -; SAHF-NEXT: pushq %rdi -; SAHF-NEXT: .seh_pushreg 7 -; SAHF-NEXT: subq $32, %rsp -; SAHF-NEXT: .seh_stackalloc 32 -; SAHF-NEXT: leaq {{[0-9]+}}(%rsp), %rbp -; SAHF-NEXT: .seh_setframe 5, 32 -; SAHF-NEXT: .seh_endprologue -; SAHF-NEXT: movq %rdx, %rsi -; SAHF-NEXT: movq %rdx, %rax -; SAHF-NEXT: lock cmpxchgq %r8, (%rcx) -; SAHF-NEXT: seto %al -; SAHF-NEXT: lahf -; SAHF-NEXT: movq %rax, %rdi -; SAHF-NEXT: callq dummy -; SAHF-NEXT: pushq %rax -; SAHF-NEXT: movq %rdi, %rax -; SAHF-NEXT: addb $127, %al -; SAHF-NEXT: sahf -; SAHF-NEXT: popq %rax -; SAHF-NEXT: cmovneq %rsi, %rax -; SAHF-NEXT: addq $32, %rsp -; SAHF-NEXT: popq %rdi -; SAHF-NEXT: popq %rsi -; SAHF-NEXT: popq %rbp -; SAHF-NEXT: retq -; SAHF-NEXT: .seh_handlerdata -; SAHF-NEXT: .text -; SAHF-NEXT: .seh_endproc +; ALL-LABEL: f10: +; ALL: # %bb.0: +; ALL-NEXT: pushq %rbp +; ALL-NEXT: .seh_pushreg 5 +; ALL-NEXT: pushq %rsi +; ALL-NEXT: .seh_pushreg 6 +; ALL-NEXT: pushq %rbx +; ALL-NEXT: .seh_pushreg 3 +; ALL-NEXT: subq $32, %rsp +; ALL-NEXT: .seh_stackalloc 32 +; ALL-NEXT: leaq {{[0-9]+}}(%rsp), %rbp +; ALL-NEXT: .seh_setframe 5, 32 +; ALL-NEXT: .seh_endprologue +; ALL-NEXT: movq %rdx, %rsi +; ALL-NEXT: movq %rdx, %rax +; ALL-NEXT: lock cmpxchgq %r8, (%rcx) +; ALL-NEXT: sete %bl +; ALL-NEXT: callq dummy +; ALL-NEXT: testb $-1, %bl +; ALL-NEXT: cmoveq %rsi, %rax +; ALL-NEXT: addq $32, %rsp +; ALL-NEXT: popq %rbx +; ALL-NEXT: popq %rsi +; ALL-NEXT: popq %rbp +; ALL-NEXT: retq +; ALL-NEXT: .seh_handlerdata +; ALL-NEXT: .text +; ALL-NEXT: .seh_endproc %cx = cmpxchg i64* %foo, i64 %bar, i64 %baz seq_cst seq_cst %v = extractvalue { i64, i1 } %cx, 0 %p = extractvalue { i64, i1 } %cx, 1 Index: llvm/test/CodeGen/X86/x86-repmov-copy-eflags.ll =================================================================== --- llvm/test/CodeGen/X86/x86-repmov-copy-eflags.ll +++ llvm/test/CodeGen/X86/x86-repmov-copy-eflags.ll @@ -39,15 +39,12 @@ ; CHECK: leal 8(%esp), %esi ; CHECK: decl (%esp) -; CHECK: seto %al -; CHECK: lahf -; CHECK: movl %eax, %edi +; CHECK: setne %[[NE_REG:.*]] ; CHECK: pushl %esi ; CHECK: calll _g ; CHECK: addl $4, %esp -; CHECK: movl %edi, %eax -; CHECK: addb $127, %al -; CHECK: sahf +; CHECK: testb $-1, %[[NE_REG]] +; CHECK: jne attributes #0 = { nounwind optsize } attributes #1 = { argmemonly nounwind }