bool Success = translate(*CV, VReg);
if (!Success) {
if (!TPC->isGlobalISelAbortEnabled()) {
- MIRBuilder.getMF().getProperties().set(
+ MF->getProperties().set(
MachineFunctionProperties::Property::FailedISel);
return VReg;
}
if (FrameIndices.find(&AI) != FrameIndices.end())
return FrameIndices[&AI];
- MachineFunction &MF = MIRBuilder.getMF();
unsigned ElementSize = DL->getTypeStoreSize(AI.getAllocatedType());
unsigned Size =
ElementSize * cast<ConstantInt>(AI.getArraySize())->getZExtValue();
Alignment = DL->getABITypeAlignment(AI.getAllocatedType());
int &FI = FrameIndices[&AI];
- FI = MF.getFrameInfo().CreateStackObject(Size, Alignment, false, &AI);
+ FI = MF->getFrameInfo().CreateStackObject(Size, Alignment, false, &AI);
return FI;
}
Alignment = LI->getAlignment();
ValTy = LI->getType();
} else if (!TPC->isGlobalISelAbortEnabled()) {
- MIRBuilder.getMF().getProperties().set(
+ MF->getProperties().set(
MachineFunctionProperties::Property::FailedISel);
return 1;
} else
MachineBasicBlock &IRTranslator::getOrCreateBB(const BasicBlock &BB) {
MachineBasicBlock *&MBB = BBToMBB[&BB];
if (!MBB) {
- MachineFunction &MF = MIRBuilder.getMF();
- MBB = MF.CreateMachineBasicBlock();
- MF.push_back(MBB);
+ MBB = MF->CreateMachineBasicBlock();
+ MF->push_back(MBB);
}
return *MBB;
}
: MachineMemOperand::MONone;
Flags |= MachineMemOperand::MOLoad;
- MachineFunction &MF = MIRBuilder.getMF();
unsigned Res = getOrCreateVReg(LI);
unsigned Addr = getOrCreateVReg(*LI.getPointerOperand());
LLT VTy{*LI.getType(), *DL}, PTy{*LI.getPointerOperand()->getType(), *DL};
MIRBuilder.buildLoad(
Res, Addr,
- *MF.getMachineMemOperand(MachinePointerInfo(LI.getPointerOperand()),
- Flags, DL->getTypeStoreSize(LI.getType()),
- getMemOpAlignment(LI)));
+ *MF->getMachineMemOperand(MachinePointerInfo(LI.getPointerOperand()),
+ Flags, DL->getTypeStoreSize(LI.getType()),
+ getMemOpAlignment(LI)));
return true;
}
: MachineMemOperand::MONone;
Flags |= MachineMemOperand::MOStore;
- MachineFunction &MF = MIRBuilder.getMF();
unsigned Val = getOrCreateVReg(*SI.getValueOperand());
unsigned Addr = getOrCreateVReg(*SI.getPointerOperand());
LLT VTy{*SI.getValueOperand()->getType(), *DL},
PTy{*SI.getPointerOperand()->getType(), *DL};
MIRBuilder.buildStore(
- Val, Addr, *MF.getMachineMemOperand(
- MachinePointerInfo(SI.getPointerOperand()), Flags,
- DL->getTypeStoreSize(SI.getValueOperand()->getType()),
- getMemOpAlignment(SI)));
+ Val, Addr,
+ *MF->getMachineMemOperand(
+ MachinePointerInfo(SI.getPointerOperand()), Flags,
+ DL->getTypeStoreSize(SI.getValueOperand()->getType()),
+ getMemOpAlignment(SI)));
return true;
}
auto MIB = MIRBuilder.buildInstr(TargetOpcode::LOAD_STACK_GUARD);
MIB.addDef(DstReg);
- auto &MF = MIRBuilder.getMF();
- auto &TLI = *MF.getSubtarget().getTargetLowering();
- Value *Global = TLI.getSDagStackGuard(*MF.getFunction()->getParent());
+ auto &TLI = *MF->getSubtarget().getTargetLowering();
+ Value *Global = TLI.getSDagStackGuard(*MF->getFunction()->getParent());
if (!Global)
return;
MachinePointerInfo MPInfo(Global);
- MachineInstr::mmo_iterator MemRefs = MF.allocateMemRefsArray(1);
+ MachineInstr::mmo_iterator MemRefs = MF->allocateMemRefsArray(1);
auto Flags = MachineMemOperand::MOLoad | MachineMemOperand::MOInvariant |
MachineMemOperand::MODereferenceable;
*MemRefs =
- MF.getMachineMemOperand(MPInfo, Flags, DL->getPointerSizeInBits() / 8,
- DL->getPointerABIAlignment());
+ MF->getMachineMemOperand(MPInfo, Flags, DL->getPointerSizeInBits() / 8,
+ DL->getPointerABIAlignment());
MIB.setMemRefs(MemRefs, MemRefs + 1);
}
case Intrinsic::eh_typeid_for: {
GlobalValue *GV = ExtractTypeInfo(CI.getArgOperand(0));
unsigned Reg = getOrCreateVReg(CI);
- unsigned TypeID = MIRBuilder.getMF().getTypeIDFor(GV);
+ unsigned TypeID = MF->getTypeIDFor(GV);
MIRBuilder.buildConstant(Reg, TypeID);
return true;
}
getStackGuard(getOrCreateVReg(CI));
return true;
case Intrinsic::stackprotector: {
- MachineFunction &MF = MIRBuilder.getMF();
LLT PtrTy{*CI.getArgOperand(0)->getType(), *DL};
unsigned GuardVal = MRI->createGenericVirtualRegister(PtrTy);
getStackGuard(GuardVal);
AllocaInst *Slot = cast<AllocaInst>(CI.getArgOperand(1));
MIRBuilder.buildStore(
GuardVal, getOrCreateVReg(*Slot),
- *MF.getMachineMemOperand(
- MachinePointerInfo::getFixedStack(MF, getOrCreateFrameIndex(*Slot)),
+ *MF->getMachineMemOperand(
+ MachinePointerInfo::getFixedStack(*MF,
+ getOrCreateFrameIndex(*Slot)),
MachineMemOperand::MOStore | MachineMemOperand::MOVolatile,
PtrTy.getSizeInBits() / 8, 8));
return true;
bool IRTranslator::translateCall(const User &U) {
const CallInst &CI = cast<CallInst>(U);
- auto TII = MIRBuilder.getMF().getTarget().getIntrinsicInfo();
+ auto TII = MF->getTarget().getIntrinsicInfo();
const Function *F = CI.getCalledFunction();
if (!F || !F->isIntrinsic()) {
bool IRTranslator::translateInvoke(const User &U) {
const InvokeInst &I = cast<InvokeInst>(U);
- MachineFunction &MF = MIRBuilder.getMF();
- MCContext &Context = MF.getContext();
+ MCContext &Context = MF->getContext();
const BasicBlock *ReturnBB = I.getSuccessor(0);
const BasicBlock *EHPadBB = I.getSuccessor(1);
// FIXME: track probabilities.
MachineBasicBlock &EHPadMBB = getOrCreateBB(*EHPadBB),
&ReturnMBB = getOrCreateBB(*ReturnBB);
- MF.addInvoke(&EHPadMBB, BeginSymbol, EndSymbol);
+ MF->addInvoke(&EHPadMBB, BeginSymbol, EndSymbol);
MIRBuilder.getMBB().addSuccessor(&ReturnMBB);
MIRBuilder.getMBB().addSuccessor(&EHPadMBB);
const LandingPadInst &LP = cast<LandingPadInst>(U);
MachineBasicBlock &MBB = MIRBuilder.getMBB();
- MachineFunction &MF = MIRBuilder.getMF();
addLandingPadInfo(LP, MBB);
MBB.setIsEHPad();
// If there aren't registers to copy the values into (e.g., during SjLj
// exceptions), then don't bother.
- auto &TLI = *MF.getSubtarget().getTargetLowering();
- const Constant *PersonalityFn = MF.getFunction()->getPersonalityFn();
+ auto &TLI = *MF->getSubtarget().getTargetLowering();
+ const Constant *PersonalityFn = MF->getFunction()->getPersonalityFn();
if (TLI.getExceptionPointerRegister(PersonalityFn) == 0 &&
TLI.getExceptionSelectorRegister(PersonalityFn) == 0)
return true;
// Add a label to mark the beginning of the landing pad. Deletion of the
// landing pad can thus be detected via the MachineModuleInfo.
MIRBuilder.buildInstr(TargetOpcode::EH_LABEL)
- .addSym(MF.addLandingPad(&MBB));
+ .addSym(MF->addLandingPad(&MBB));
// Mark exception register as live in.
SmallVector<unsigned, 2> Regs;
Constants.clear();
}
-bool IRTranslator::runOnMachineFunction(MachineFunction &MF) {
- const Function &F = *MF.getFunction();
+bool IRTranslator::runOnMachineFunction(MachineFunction &CurMF) {
+ MF = &CurMF;
+ const Function &F = *MF->getFunction();
if (F.empty())
return false;
- CLI = MF.getSubtarget().getCallLowering();
- MIRBuilder.setMF(MF);
- EntryBuilder.setMF(MF);
- MRI = &MF.getRegInfo();
+ CLI = MF->getSubtarget().getCallLowering();
+ MIRBuilder.setMF(*MF);
+ EntryBuilder.setMF(*MF);
+ MRI = &MF->getRegInfo();
DL = &F.getParent()->getDataLayout();
TPC = &getAnalysis<TargetPassConfig>();
// Setup a separate basic-block for the arguments and constants, falling
// through to the IR-level Function's entry block.
- MachineBasicBlock *EntryBB = MF.CreateMachineBasicBlock();
- MF.push_back(EntryBB);
+ MachineBasicBlock *EntryBB = MF->CreateMachineBasicBlock();
+ MF->push_back(EntryBB);
EntryBB->addSuccessor(&getOrCreateBB(F.front()));
EntryBuilder.setMBB(*EntryBB);
bool Succeeded = CLI->lowerFormalArguments(EntryBuilder, F, VRegArgs);
if (!Succeeded) {
if (!TPC->isGlobalISelAbortEnabled()) {
- MIRBuilder.getMF().getProperties().set(
+ MF->getProperties().set(
MachineFunctionProperties::Property::FailedISel);
finalizeFunction();
return false;
if (!Succeeded) {
if (TPC->isGlobalISelAbortEnabled())
reportTranslationError(Inst, "unable to translate instruction");
- MF.getProperties().set(MachineFunctionProperties::Property::FailedISel);
+ MF->getProperties().set(
+ MachineFunctionProperties::Property::FailedISel);
break;
}
}
// Now that the MachineFrameInfo has been configured, no further changes to
// the reserved registers are possible.
- MRI->freezeReservedRegs(MF);
+ MRI->freezeReservedRegs(*MF);
}
finalizeFunction();