void PatmosSPMark::scanAndRewriteCalls(MachineFunction *MF, Worklist &W) {
DEBUG(dbgs() << "In function '" << MF->getName() << "':\n");
for (MachineFunction::iterator MBB = MF->begin(), MBBE = MF->end();
MBB != MBBE; ++MBB) {
for( MachineBasicBlock::iterator MI = MBB->begin(),
ME = MBB->getFirstTerminator();
MI != ME; ++MI) {
if (MI->isCall()) {
MachineFunction *MF = getCallTargetMF(MI);
if (!MF) {
dbgs() << "[Single-Path] WARNING: Cannot rewrite call in "
<< MBB->getParent()->getFunction()->getName()
<< " (indirect call?)\n";
continue;
};
const Function *Target = getCallTarget(MI);
PatmosMachineFunctionInfo *PMFI =
MF->getInfo<PatmosMachineFunctionInfo>();
if (!PMFI->isSinglePath()) {
// sp-reachable functions were already marked as single-path.
// Hence, we have _potential_ sp-maybe functions left; the call
// needs to be rewritten to point to the sp-maybe clone.
rewriteCall(MI);
// set _sp MF to single path in PMFI (MF has changed!)
MachineFunction *MF = getCallTargetMF(MI);
PatmosMachineFunctionInfo *PMFI =
MF->getInfo<PatmosMachineFunctionInfo>();
// we possibly have already marked the _sp variant as single-path
// in an earlier call, if not, then set this final decision.
if (!PMFI->isSinglePath()) {
PMFI->setSinglePath();
// add the new single-path function to the worklist
W.push_back(MF);
NumSPTotal++; // bump STATISTIC
NumSPMaybe++; // bump STATISTIC
}
}
}
}
}
}
bool FPRegKiller::runOnMachineFunction(MachineFunction &MF) {
// If we are emitting FP stack code, scan the basic block to determine if this
// block defines any FP values. If so, put an FP_REG_KILL instruction before
// the terminator of the block.
// Note that FP stack instructions are used in all modes for long double,
// so we always need to do this check.
// Also note that it's possible for an FP stack register to be live across
// an instruction that produces multiple basic blocks (SSE CMOV) so we
// must check all the generated basic blocks.
// Scan all of the machine instructions in these MBBs, checking for FP
// stores. (RFP32 and RFP64 will not exist in SSE mode, but RFP80 might.)
// Fast-path: If nothing is using the x87 registers, we don't need to do
// any scanning.
MachineRegisterInfo &MRI = MF.getRegInfo();
if (MRI.getRegClassVirtRegs(X86::RFP80RegisterClass).empty() &&
MRI.getRegClassVirtRegs(X86::RFP64RegisterClass).empty() &&
MRI.getRegClassVirtRegs(X86::RFP32RegisterClass).empty())
return false;
bool Changed = false;
const X86Subtarget &Subtarget = MF.getTarget().getSubtarget<X86Subtarget>();
MachineFunction::iterator MBBI = MF.begin();
MachineFunction::iterator EndMBB = MF.end();
for (; MBBI != EndMBB; ++MBBI) {
MachineBasicBlock *MBB = MBBI;
// If this block returns, ignore it. We don't want to insert an FP_REG_KILL
// before the return.
if (!MBB->empty()) {
MachineBasicBlock::iterator EndI = MBB->end();
--EndI;
if (EndI->getDesc().isReturn())
continue;
}
bool ContainsFPCode = false;
for (MachineBasicBlock::iterator I = MBB->begin(), E = MBB->end();
!ContainsFPCode && I != E; ++I) {
if (I->getNumOperands() != 0 && I->getOperand(0).isReg()) {
const TargetRegisterClass *clas;
for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op) {
if (I->getOperand(op).isReg() && I->getOperand(op).isDef() &&
TargetRegisterInfo::isVirtualRegister(I->getOperand(op).getReg()) &&
((clas = MRI.getRegClass(I->getOperand(op).getReg())) ==
X86::RFP32RegisterClass ||
clas == X86::RFP64RegisterClass ||
clas == X86::RFP80RegisterClass)) {
ContainsFPCode = true;
break;
}
}
}
}
// Check PHI nodes in successor blocks. These PHI's will be lowered to have
// a copy of the input value in this block. In SSE mode, we only care about
// 80-bit values.
if (!ContainsFPCode) {
// Final check, check LLVM BB's that are successors to the LLVM BB
// corresponding to BB for FP PHI nodes.
const BasicBlock *LLVMBB = MBB->getBasicBlock();
const PHINode *PN;
for (succ_const_iterator SI = succ_begin(LLVMBB), E = succ_end(LLVMBB);
!ContainsFPCode && SI != E; ++SI) {
for (BasicBlock::const_iterator II = SI->begin();
(PN = dyn_cast<PHINode>(II)); ++II) {
if (PN->getType()==Type::getX86_FP80Ty(LLVMBB->getContext()) ||
(!Subtarget.hasSSE1() && PN->getType()->isFloatingPointTy()) ||
(!Subtarget.hasSSE2() &&
PN->getType()==Type::getDoubleTy(LLVMBB->getContext()))) {
ContainsFPCode = true;
break;
}
}
}
}
// Finally, if we found any FP code, emit the FP_REG_KILL instruction.
if (ContainsFPCode) {
BuildMI(*MBB, MBBI->getFirstTerminator(), DebugLoc(),
MF.getTarget().getInstrInfo()->get(X86::FP_REG_KILL));
++NumFPKill;
Changed = true;
}
}
return Changed;
}
