reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

   57 class MachineFunction;

   30 class MachineFunction;

   53 class MachineFunction;

   23 class MachineFunction;

   20 class MachineFunction;

   42 class MachineFunction;

   21 class MachineFunction;

   46 class MachineFunction;

   42 class MachineFunction;

   25 class MachineFunction;

   21 class MachineFunction;

   44 class MachineFunction;

   37 class MachineFunction;

   30 class MachineFunction;

   25 class MachineFunction;

   31 class MachineFunction;

   47 class MachineFunction;

   39 class MachineFunction;

   36 class MachineFunction;

   26 class MachineFunction;

   24 class MachineFunction;

   20 class MachineFunction;

   38 class MachineFunction;

   27 class MachineFunction;

   24 class MachineFunction;

   60 class MachineFunction;

   44 class MachineFunction;

   30 class MachineFunction;

   51 class MachineFunction;

   19 class MachineFunction;

  107 class MachineFunction;

   23 class MachineFunction;

   61 class MachineFunction;

   23 class MachineFunction;

   39 class MachineFunction;

   34 class MachineFunction;

   36 class MachineFunction;

   40   class MachineFunction;

   31 class MachineFunction;

   31   class MachineFunction;

   29 class MachineFunction;

   24   class MachineFunction;

   81 class MachineFunction;

   38 class MachineFunction;

   28 class MachineFunction;

   20   class MachineFunction;

   30 class MachineFunction;

   49 class MachineFunction;

   59 class MachineFunction;

   21 class MachineFunction;

   21 class MachineFunction;

   26 class MachineFunction;

   27 class MachineFunction;

   29 class MachineFunction;

   40 class MachineFunction;

   15 class MachineFunction;

   21 class MachineFunction;

   25 class MachineFunction;

   24 class MachineFunction;

   34 class MachineFunction;

   40 class MachineFunction;

   23 class MachineFunction;

   21 class MachineFunction;

   33 class MachineFunction;

   26 class MachineFunction;

   20 class MachineFunction;

   17 class MachineFunction;

   29 class MachineFunction;

   30 class MachineFunction;

   21 class MachineFunction;

   23 class MachineFunction;

   25 class MachineFunction;

   25 class MachineFunction;

   33 class MachineFunction;

   22 class MachineFunction;

  251 class MachineFunction;

   24 class MachineFunction;

   33 class MachineFunction;

   18 class MachineFunction;

   23 class MachineFunction;

   19   class MachineFunction;

References

  102   MachineFunction *MF = MBB->getParent();

  110 computeAvailableFunctionFeatures(const AArch64Subtarget *Subtarget, const MachineFunction *MF) const {
  884   const MachineFunction &MF = *MI.getParent()->getParent();
 1020   MachineFunction &MF = *I.getParent()->getParent();
44268                                  const MachineFunction *MF) const;

 5038   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
 5045       const MachineFunction &MF);
 6808 static inline unsigned GPR32AltOrderSelect(const MachineFunction &MF) { return 1; }
 6810 static ArrayRef<MCPhysReg> GPR32GetRawAllocationOrder(const MachineFunction &MF) {
 6822 static inline unsigned GPR32spAltOrderSelect(const MachineFunction &MF) { return 1; }
 6824 static ArrayRef<MCPhysReg> GPR32spGetRawAllocationOrder(const MachineFunction &MF) {
 6836 static inline unsigned GPR32commonAltOrderSelect(const MachineFunction &MF) { return 1; }
 6838 static ArrayRef<MCPhysReg> GPR32commonGetRawAllocationOrder(const MachineFunction &MF) {
 6850 static inline unsigned GPR64AltOrderSelect(const MachineFunction &MF) { return 1; }
 6852 static ArrayRef<MCPhysReg> GPR64GetRawAllocationOrder(const MachineFunction &MF) {
 6864 static inline unsigned GPR64spAltOrderSelect(const MachineFunction &MF) { return 1; }
 6866 static ArrayRef<MCPhysReg> GPR64spGetRawAllocationOrder(const MachineFunction &MF) {
 6878 static inline unsigned GPR64commonAltOrderSelect(const MachineFunction &MF) { return 1; }
 6880 static ArrayRef<MCPhysReg> GPR64commonGetRawAllocationOrder(const MachineFunction &MF) {
20237 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
20519 AArch64GenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

  177 computeAvailableFunctionFeatures(const AMDGPUSubtarget *Subtarget, const MachineFunction *MF) const {
  377   const MachineFunction &MF = *MI.getParent()->getParent();
  439   MachineFunction &MF = *I.getParent()->getParent();
20248                                  const MachineFunction *MF) const;

17311   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
17318       const MachineFunction &MF);
48322 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
48808 AMDGPUGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

 8798   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
 8805       const MachineFunction &MF);
12276 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
12383 R600GenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

  517   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
  524       const MachineFunction &MF);
  740 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
  864 ARCGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

  241 computeAvailableFunctionFeatures(const ARMSubtarget *Subtarget, const MachineFunction *MF) const {
  746   const MachineFunction &MF = *MI.getParent()->getParent();
  808   MachineFunction &MF = *I.getParent()->getParent();
30625                                  const MachineFunction *MF) const;

 3590   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
 3597       const MachineFunction &MF);
 5898 static inline unsigned HPRAltOrderSelect(const MachineFunction &MF) {
 5902 static ArrayRef<MCPhysReg> HPRGetRawAllocationOrder(const MachineFunction &MF) {
 5916 static inline unsigned SPRAltOrderSelect(const MachineFunction &MF) {
 5920 static ArrayRef<MCPhysReg> SPRGetRawAllocationOrder(const MachineFunction &MF) {
 5934 static inline unsigned GPRAltOrderSelect(const MachineFunction &MF) {
 5938 static ArrayRef<MCPhysReg> GPRGetRawAllocationOrder(const MachineFunction &MF) {
 5954 static inline unsigned GPRwithAPSRAltOrderSelect(const MachineFunction &MF) {
 5958 static ArrayRef<MCPhysReg> GPRwithAPSRGetRawAllocationOrder(const MachineFunction &MF) {
 5972 static inline unsigned GPRwithZRAltOrderSelect(const MachineFunction &MF) {
 5976 static ArrayRef<MCPhysReg> GPRwithZRGetRawAllocationOrder(const MachineFunction &MF) {
 5990 static inline unsigned GPRnopcAltOrderSelect(const MachineFunction &MF) {
 5994 static ArrayRef<MCPhysReg> GPRnopcGetRawAllocationOrder(const MachineFunction &MF) {
 6010 static inline unsigned GPRwithZRnospAltOrderSelect(const MachineFunction &MF) {
 6014 static ArrayRef<MCPhysReg> GPRwithZRnospGetRawAllocationOrder(const MachineFunction &MF) {
 6028 static inline unsigned rGPRAltOrderSelect(const MachineFunction &MF) {
 6032 static ArrayRef<MCPhysReg> rGPRGetRawAllocationOrder(const MachineFunction &MF) {
 6048 static inline unsigned tGPREvenAltOrderSelect(const MachineFunction &MF) {
 6052 static ArrayRef<MCPhysReg> tGPREvenGetRawAllocationOrder(const MachineFunction &MF) {
 6064 static inline unsigned tGPROddAltOrderSelect(const MachineFunction &MF) {
 6068 static ArrayRef<MCPhysReg> tGPROddGetRawAllocationOrder(const MachineFunction &MF) {
 6080 static inline unsigned tcGPRAltOrderSelect(const MachineFunction &MF) {
 6084 static ArrayRef<MCPhysReg> tcGPRGetRawAllocationOrder(const MachineFunction &MF) {
 6096 static inline unsigned tGPR_and_tGPREvenAltOrderSelect(const MachineFunction &MF) {
 6100 static ArrayRef<MCPhysReg> tGPR_and_tGPREvenGetRawAllocationOrder(const MachineFunction &MF) {
 6112 static inline unsigned tGPR_and_tGPROddAltOrderSelect(const MachineFunction &MF) {
 6116 static ArrayRef<MCPhysReg> tGPR_and_tGPROddGetRawAllocationOrder(const MachineFunction &MF) {
 6128 static inline unsigned tGPR_and_tcGPRAltOrderSelect(const MachineFunction &MF) {
 6132 static ArrayRef<MCPhysReg> tGPR_and_tcGPRGetRawAllocationOrder(const MachineFunction &MF) {
 6144 static inline unsigned tGPREven_and_tcGPRAltOrderSelect(const MachineFunction &MF) {
 6148 static ArrayRef<MCPhysReg> tGPREven_and_tcGPRGetRawAllocationOrder(const MachineFunction &MF) {
 6160 static inline unsigned hGPR_and_tGPROddAltOrderSelect(const MachineFunction &MF) {
 6164 static ArrayRef<MCPhysReg> hGPR_and_tGPROddGetRawAllocationOrder(const MachineFunction &MF) {
 6175 static inline unsigned tGPREven_and_tGPR_and_tcGPRAltOrderSelect(const MachineFunction &MF) {
 6179 static ArrayRef<MCPhysReg> tGPREven_and_tGPR_and_tcGPRGetRawAllocationOrder(const MachineFunction &MF) {
 6191 static inline unsigned tGPROdd_and_tcGPRAltOrderSelect(const MachineFunction &MF) {
 6195 static ArrayRef<MCPhysReg> tGPROdd_and_tcGPRGetRawAllocationOrder(const MachineFunction &MF) {
 6207 static inline unsigned hGPR_and_tcGPRAltOrderSelect(const MachineFunction &MF) {
 6211 static ArrayRef<MCPhysReg> hGPR_and_tcGPRGetRawAllocationOrder(const MachineFunction &MF) {
 6222 static inline unsigned DPRAltOrderSelect(const MachineFunction &MF) {
 6226 static ArrayRef<MCPhysReg> DPRGetRawAllocationOrder(const MachineFunction &MF) {
 6240 static inline unsigned DPairAltOrderSelect(const MachineFunction &MF) {
 6244 static ArrayRef<MCPhysReg> DPairGetRawAllocationOrder(const MachineFunction &MF) {
 6258 static inline unsigned DPair_with_ssub_0AltOrderSelect(const MachineFunction &MF) {
 6262 static ArrayRef<MCPhysReg> DPair_with_ssub_0GetRawAllocationOrder(const MachineFunction &MF) {
 6276 static inline unsigned QPRAltOrderSelect(const MachineFunction &MF) {
 6280 static ArrayRef<MCPhysReg> QPRGetRawAllocationOrder(const MachineFunction &MF) {
 6294 static inline unsigned DPair_with_ssub_2AltOrderSelect(const MachineFunction &MF) {
 6298 static ArrayRef<MCPhysReg> DPair_with_ssub_2GetRawAllocationOrder(const MachineFunction &MF) {
 6312 static inline unsigned DPair_with_dsub_0_in_DPR_8AltOrderSelect(const MachineFunction &MF) {
 6316 static ArrayRef<MCPhysReg> DPair_with_dsub_0_in_DPR_8GetRawAllocationOrder(const MachineFunction &MF) {
 6330 static inline unsigned DPair_with_dsub_1_in_DPR_8AltOrderSelect(const MachineFunction &MF) {
 6334 static ArrayRef<MCPhysReg> DPair_with_dsub_1_in_DPR_8GetRawAllocationOrder(const MachineFunction &MF) {
 6348 static inline unsigned QQPRAltOrderSelect(const MachineFunction &MF) { return 1; }
 6350 static ArrayRef<MCPhysReg> QQPRGetRawAllocationOrder(const MachineFunction &MF) {
 6362 static inline unsigned DQuad_with_qsub_0_in_MQPRAltOrderSelect(const MachineFunction &MF) { return 1; }
 6364 static ArrayRef<MCPhysReg> DQuad_with_qsub_0_in_MQPRGetRawAllocationOrder(const MachineFunction &MF) {
 6376 static inline unsigned DQuad_with_qsub_1_in_MQPRAltOrderSelect(const MachineFunction &MF) { return 1; }
 6378 static ArrayRef<MCPhysReg> DQuad_with_qsub_1_in_MQPRGetRawAllocationOrder(const MachineFunction &MF) {
 6390 static inline unsigned DQuad_with_qsub_0_in_QPR_8AltOrderSelect(const MachineFunction &MF) { return 1; }
 6392 static ArrayRef<MCPhysReg> DQuad_with_qsub_0_in_QPR_8GetRawAllocationOrder(const MachineFunction &MF) {
 6404 static inline unsigned DQuad_with_qsub_1_in_QPR_8AltOrderSelect(const MachineFunction &MF) { return 1; }
 6406 static ArrayRef<MCPhysReg> DQuad_with_qsub_1_in_QPR_8GetRawAllocationOrder(const MachineFunction &MF) {
 6418 static inline unsigned QQQQPRAltOrderSelect(const MachineFunction &MF) { return 1; }
 6420 static ArrayRef<MCPhysReg> QQQQPRGetRawAllocationOrder(const MachineFunction &MF) {
 6432 static inline unsigned QQQQPR_with_ssub_0AltOrderSelect(const MachineFunction &MF) { return 1; }
 6434 static ArrayRef<MCPhysReg> QQQQPR_with_ssub_0GetRawAllocationOrder(const MachineFunction &MF) {
 6446 static inline unsigned QQQQPR_with_ssub_4AltOrderSelect(const MachineFunction &MF) { return 1; }
 6448 static ArrayRef<MCPhysReg> QQQQPR_with_ssub_4GetRawAllocationOrder(const MachineFunction &MF) {
 6460 static inline unsigned QQQQPR_with_ssub_8AltOrderSelect(const MachineFunction &MF) { return 1; }
 6462 static ArrayRef<MCPhysReg> QQQQPR_with_ssub_8GetRawAllocationOrder(const MachineFunction &MF) {
 6474 static inline unsigned QQQQPR_with_ssub_12AltOrderSelect(const MachineFunction &MF) { return 1; }
 6476 static ArrayRef<MCPhysReg> QQQQPR_with_ssub_12GetRawAllocationOrder(const MachineFunction &MF) {
 6488 static inline unsigned QQQQPR_with_dsub_0_in_DPR_8AltOrderSelect(const MachineFunction &MF) { return 1; }
 6490 static ArrayRef<MCPhysReg> QQQQPR_with_dsub_0_in_DPR_8GetRawAllocationOrder(const MachineFunction &MF) {
 6502 static inline unsigned QQQQPR_with_dsub_2_in_DPR_8AltOrderSelect(const MachineFunction &MF) { return 1; }
 6504 static ArrayRef<MCPhysReg> QQQQPR_with_dsub_2_in_DPR_8GetRawAllocationOrder(const MachineFunction &MF) {
 6516 static inline unsigned QQQQPR_with_dsub_4_in_DPR_8AltOrderSelect(const MachineFunction &MF) { return 1; }
 6518 static ArrayRef<MCPhysReg> QQQQPR_with_dsub_4_in_DPR_8GetRawAllocationOrder(const MachineFunction &MF) {
 6530 static inline unsigned QQQQPR_with_dsub_6_in_DPR_8AltOrderSelect(const MachineFunction &MF) { return 1; }
 6532 static ArrayRef<MCPhysReg> QQQQPR_with_dsub_6_in_DPR_8GetRawAllocationOrder(const MachineFunction &MF) {
15842 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
16086 ARMGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

  865   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
  872       const MachineFunction &MF);
 1629 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
 1768 AVRGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

  395   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
  402       const MachineFunction &MF);
  629 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
  750 BPFGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

 2280   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
 2287       const MachineFunction &MF);
 3595 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
 3727 HexagonGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

  576   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
  583       const MachineFunction &MF);
  854 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
  976 LanaiGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

  320   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
  327       const MachineFunction &MF);
  562 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
  634 MSP430GenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

  177 computeAvailableFunctionFeatures(const MipsSubtarget *Subtarget, const MachineFunction *MF) const {
  611   const MachineFunction &MF = *MI.getParent()->getParent();
  633   MachineFunction &MF = *I.getParent()->getParent();
22478                                  const MachineFunction *MF) const;

 3818   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
 3825       const MachineFunction &MF);
 4760 static inline unsigned FGR32AltOrderSelect(const MachineFunction &MF) {
 4765 static ArrayRef<MCPhysReg> FGR32GetRawAllocationOrder(const MachineFunction &MF) {
 4777 static inline unsigned FGR64AltOrderSelect(const MachineFunction &MF) {
 4782 static ArrayRef<MCPhysReg> FGR64GetRawAllocationOrder(const MachineFunction &MF) {
 7268 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
 7459 MipsGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

  763   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
  770       const MachineFunction &MF);
 1239 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
 1335 NVPTXGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

 3852   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
 3859       const MachineFunction &MF);
 4272 static inline unsigned GPRCAltOrderSelect(const MachineFunction &MF) {
 4276 static ArrayRef<MCPhysReg> GPRCGetRawAllocationOrder(const MachineFunction &MF) {
 4288 static inline unsigned GPRC_NOR0AltOrderSelect(const MachineFunction &MF) {
 4292 static ArrayRef<MCPhysReg> GPRC_NOR0GetRawAllocationOrder(const MachineFunction &MF) {
 4304 static inline unsigned GPRC_and_GPRC_NOR0AltOrderSelect(const MachineFunction &MF) {
 4308 static ArrayRef<MCPhysReg> GPRC_and_GPRC_NOR0GetRawAllocationOrder(const MachineFunction &MF) {
 4320 static inline unsigned G8RCAltOrderSelect(const MachineFunction &MF) {
 4324 static ArrayRef<MCPhysReg> G8RCGetRawAllocationOrder(const MachineFunction &MF) {
 4336 static inline unsigned G8RC_NOX0AltOrderSelect(const MachineFunction &MF) {
 4340 static ArrayRef<MCPhysReg> G8RC_NOX0GetRawAllocationOrder(const MachineFunction &MF) {
 4352 static inline unsigned G8RC_and_G8RC_NOX0AltOrderSelect(const MachineFunction &MF) {
 4356 static ArrayRef<MCPhysReg> G8RC_and_G8RC_NOX0GetRawAllocationOrder(const MachineFunction &MF) {
 5588 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
 5885 PPCGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

   63 computeAvailableFunctionFeatures(const RISCVSubtarget *Subtarget, const MachineFunction *MF) const {
  257   const MachineFunction &MF = *MI.getParent()->getParent();
  279   MachineFunction &MF = *I.getParent()->getParent();
12504                                  const MachineFunction *MF) const;

 1123   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
 1130       const MachineFunction &MF);
 1749 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
 1903 RISCVGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

 1896   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
 1903       const MachineFunction &MF);
 2716 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
 2848 SparcGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

 1790   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
 1797       const MachineFunction &MF);
 2883 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
 3022 SystemZGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

  262   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
  269       const MachineFunction &MF);
  506 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
  588 WebAssemblyGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

  375 computeAvailableFunctionFeatures(const X86Subtarget *Subtarget, const MachineFunction *MF) const {
  750   const MachineFunction &MF = *MI.getParent()->getParent();
  772   MachineFunction &MF = *I.getParent()->getParent();
17094                                  const MachineFunction *MF) const;

 4320   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
 4327       const MachineFunction &MF);
 6250 static inline unsigned GR8AltOrderSelect(const MachineFunction &MF) {
 6254 static ArrayRef<MCPhysReg> GR8GetRawAllocationOrder(const MachineFunction &MF) {
 6266 static inline unsigned GR8_NOREXAltOrderSelect(const MachineFunction &MF) {
 6270 static ArrayRef<MCPhysReg> GR8_NOREXGetRawAllocationOrder(const MachineFunction &MF) {
 9782 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
10165 X86GenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

  338   unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
  345       const MachineFunction &MF);
  501 getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
  614 XCoreGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {

   87   template <class... Args> void emplace(Args &&... args) {
  237   template <typename... ArgTypes> void emplace(ArgTypes &&... Args) {

  244   static yes& test(Inner *I, decltype(I->rbegin()) * = nullptr);
  250   static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);

  266   const ParentTy *getNodeParent() const {
  278         getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
  292         getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));

  554   using FunctionT = MachineFunction;

  146 getEHScopeMembership(const MachineFunction &MF);

   97   MachineFunction *MF = nullptr;
  232   void emitInitialRawDwarfLocDirective(const MachineFunction &MF);
  300   bool runOnMachineFunction(MachineFunction &MF) override {
  312   virtual void SetupMachineFunction(MachineFunction &MF);
  321   void emitStackSizeSection(const MachineFunction &MF);

   45   virtual void beginFunction(const MachineFunction *MF) = 0;
   54   virtual void endFunction(const MachineFunction *MF) = 0;

   51     MachineFunction &MF;
   60     VirtRegAuxInfo(MachineFunction &mf, LiveIntervals &lis,
   98   void calculateSpillWeightsAndHints(LiveIntervals &LIS, MachineFunction &MF,

  196   MachineFunction &MF;
  258   CCState(CallingConv::ID CC, bool isVarArg, MachineFunction &MF,
  266   MachineFunction &getMachineFunction() const { return MF; }
  534                                 CallingConv::ID CallerCC, MachineFunction &MF,

  145   MachineFunction &MF;
  160   VLIWPacketizerList(MachineFunction &MF, MachineLoopInfo &MLI,

  121 void calculateDbgEntityHistory(const MachineFunction *MF,

  109   virtual void beginFunctionImpl(const MachineFunction *MF) = 0;
  110   virtual void endFunctionImpl(const MachineFunction *MF) = 0;
  118   void beginFunction(const MachineFunction *MF) override;
  119   void endFunction(const MachineFunction *MF) override;

   26   const MachineFunction *MF;
   51   const MachineFunction *getMachineFunction() const { return MF; }
   57   bool runOnMachineFunction(MachineFunction&) override;

  112   MachineFunction *MF;
  139   bool runOnMachineFunction(MachineFunction &MF) override;

  204   MachineFunction *MF;

   56   MachineFunction *MF;
  189   void set(const Function &Fn, MachineFunction &MF, SelectionDAG *DAG);

   78   MachineFunction *MF = nullptr;
  121   void setMF(MachineFunction &MF);
  150   void analyze(MachineFunction &MF);
  202   MachineFunction *MF = nullptr;
  212   void setMF(MachineFunction &MFunc) { MF = &MFunc; }
  232   bool runOnMachineFunction(MachineFunction &MF) override;

   92   using MachineIRBuilder::MachineIRBuilder;

  238   bool resultsCompatible(CallLoweringInfo &Info, MachineFunction &MF,

   34   bool combineMachineInstrs(MachineFunction &MF, GISelCSEInfo *CSEInfo);

   22   using MachineIRBuilder::MachineIRBuilder;

   65 class GISelObserverWrapper : public MachineFunction::Delegate,
  108   MachineFunction &MF;
  109   MachineFunction::Delegate *Delegate;
  112   RAIIDelegateInstaller(MachineFunction &MF, MachineFunction::Delegate *Del);
  112   RAIIDelegateInstaller(MachineFunction &MF, MachineFunction::Delegate *Del);

   30   MachineFunction &MF;
   36   GISelKnownBits(MachineFunction &MF);
   38   void setMF(MachineFunction &MF);
   67                                          const MachineFunction &MF);
  100   GISelKnownBits &get(MachineFunction &MF) {
  106   bool runOnMachineFunction(MachineFunction &MF) override;

  308                               MachineFunction::iterator BBI,
  502   MachineFunction *MF;
  634   bool runOnMachineFunction(MachineFunction &MF) override;

   48   bool runOnMachineFunction(MachineFunction &MF) override;

  391   MachineFunction *MF = nullptr;
  394   virtual void setupMF(MachineFunction &mf,

  549         MachineFunction *MF = State.MIs[InsnID]->getParent()->getParent();

   37   void init(MachineFunction &MF);
   65   bool runOnMachineFunction(MachineFunction &MF) override;

   51   LegalizerHelper(MachineFunction &MF, GISelChangeObserver &Observer,
   53   LegalizerHelper(MachineFunction &MF, const LegalizerInfo &LI,

 1350 const MachineInstr *machineFunctionIsIllegal(const MachineFunction &MF);

   62   void init(MachineFunction &MF);
   67   bool localizeInterBlock(MachineFunction &MF,
   87   bool runOnMachineFunction(MachineFunction &MF) override;

   40   MachineFunction *MF;
  238   MachineIRBuilder(MachineFunction &MF) { setMF(MF); }
  253   MachineFunction &getMF() {
  258   const MachineFunction &getMF() const {
  305   void setMF(MachineFunction &MF);

  520   void init(MachineFunction &MF);
  664   bool runOnMachineFunction(MachineFunction &MF) override;

   57 unsigned constrainOperandRegClass(const MachineFunction &MF,
   75 unsigned constrainOperandRegClass(const MachineFunction &MF,
  102 void reportGISelFailure(MachineFunction &MF, const TargetPassConfig &TPC,
  106 void reportGISelFailure(MachineFunction &MF, const TargetPassConfig &TPC,

   49   MachineFunction *MF = nullptr;
   70   bool runOnMachineFunction(MachineFunction &F) override;

  147   void initialize(const MachineFunction &);
  229   const MachineFunction *MF = nullptr;

   55     MachineFunction* MF;
  290     bool runOnMachineFunction(MachineFunction&) override;

  164   void addPristines(const MachineFunction &MF);

   45   const MachineFunction *MF = nullptr;
  193   void reset(const MachineFunction *mf, SlotIndexes *SI,

  139                 MachineFunction &MF, LiveIntervals &lis, VirtRegMap *vrm,
  251   void calculateRegClassAndHint(MachineFunction &, const MachineLoopInfo &,

   62   bool runOnMachineFunction(MachineFunction &) override;

  160   void addPristines(const MachineFunction &MF);

   94   bool runOnMachineFunction(MachineFunction &) override;

  126   MachineFunction *MF;
  175   void analyzePHINodes(const MachineFunction& Fn);
  182   bool runOnMachineFunction(MachineFunction &MF) override;

  106   TraversalOrder traverse(MachineFunction &MF);

  161   MachineFunction &MF;
  174   PerFunctionMIParsingState(MachineFunction &MF, SourceMgr &SM,

   30 void printMIR(raw_ostream &OS, const MachineFunction &MF);

   66     : public ilist_node_with_parent<MachineBasicBlock, MachineFunction> {
   86   MachineFunction *xParent;
  139   explicit MachineBasicBlock(MachineFunction &MF, const BasicBlock *BB);
  173   const MachineFunction *getParent() const { return xParent; }
  174   MachineFunction *getParent() { return xParent; }

   41   explicit MachineBlockFrequencyInfo(MachineFunction &F,
   48   bool runOnMachineFunction(MachineFunction &F) override;
   51   void calculate(const MachineFunction &F,
   69   const MachineFunction *getFunction() const;

  101   bool runOnMachineFunction(MachineFunction &F) override;

   84   explicit MachineDominatorTree(MachineFunction &MF) : MachineFunctionPass(ID) {
  115   bool runOnMachineFunction(MachineFunction &F) override;
  117   void calculate(MachineFunction &F);

  556   unsigned estimateStackSize(const MachineFunction &MF) const;
  616   void computeMaxCallFrameSize(const MachineFunction &MF);
  802   BitVector getPristineRegs(const MachineFunction &MF) const;
  806   void print(const MachineFunction &MF, raw_ostream &OS) const;
  809   void dump(const MachineFunction &MF) const;

  102   static Ty *create(BumpPtrAllocator &Allocator, MachineFunction &MF) {
  427   MachineFunction(const MachineFunction &) = delete;
  428   MachineFunction &operator=(const MachineFunction &) = delete;
  428   MachineFunction &operator=(const MachineFunction &) = delete;
  641     return &MachineFunction::BasicBlocks;
 1025   static NodeRef getEntryNode(MachineFunction *F) { return &F->front(); }
 1028   using nodes_iterator = pointer_iterator<MachineFunction::iterator>;
 1038   static unsigned       size       (MachineFunction *F) { return F->size(); }
 1042   static NodeRef getEntryNode(const MachineFunction *F) { return &F->front(); }
 1045   using nodes_iterator = pointer_iterator<MachineFunction::const_iterator>;
 1055   static unsigned       size       (const MachineFunction *F)  {
 1067   static NodeRef getEntryNode(Inverse<MachineFunction *> G) {
 1073   static NodeRef getEntryNode(Inverse<const MachineFunction *> G) {

   46   virtual bool runOnMachineFunction(MachineFunction &MF) = 0;

  254   MachineInstr(MachineFunction &, const MachineInstr &);
  259   MachineInstr(MachineFunction &, const MCInstrDesc &tid, DebugLoc dl,
  279   const MachineFunction *getMF() const;
  280   MachineFunction *getMF() {
 1503   void copyImplicitOps(MachineFunction &MF, const MachineInstr &MI);
 1548   void addOperand(MachineFunction &MF, const MachineOperand &Op);
 1576   void dropMemRefs(MachineFunction &MF);
 1582   void setMemRefs(MachineFunction &MF, ArrayRef<MachineMemOperand *> MemRefs);
 1587   void addMemOperand(MachineFunction &MF, MachineMemOperand *MO);
 1596   void cloneMemRefs(MachineFunction &MF, const MachineInstr &MI);
 1605   void cloneMergedMemRefs(MachineFunction &MF,
 1613   void setPreInstrSymbol(MachineFunction &MF, MCSymbol *Symbol);
 1620   void setPostInstrSymbol(MachineFunction &MF, MCSymbol *Symbol);
 1624   void cloneInstrSymbols(MachineFunction &MF, const MachineInstr &MI);
 1630   void setHeapAllocMarker(MachineFunction &MF, MDNode *MD);
 1652   void addImplicitDefUseOperands(MachineFunction &MF);
 1695   void setExtraInfo(MachineFunction &MF, ArrayRef<MachineMemOperand *> MMOs,

   61   MachineFunction *MF = nullptr;
   69   MachineInstrBuilder(MachineFunction &F, MachineInstr *I) : MF(&F), MI(I) {}
   70   MachineInstrBuilder(MachineFunction &F, MachineBasicBlock::iterator I)
  316 inline MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
  323 inline MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
  336   MachineFunction &MF = *BB.getParent();
  352   MachineFunction &MF = *BB.getParent();
  381   MachineFunction &MF = *BB.getParent();
  391   MachineFunction &MF = *BB.getParent();
  432 MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,
  439 MachineInstrBuilder BuildMI(MachineFunction &MF, const DebugLoc &DL,

   41 bool finalizeBundles(MachineFunction &MF);

  140   bool runOnMachineFunction(MachineFunction &F) override;

   96   static MachinePointerInfo getConstantPool(MachineFunction &MF);
  100   static MachinePointerInfo getFixedStack(MachineFunction &MF, int FI,
  104   static MachinePointerInfo getJumpTable(MachineFunction &MF);
  107   static MachinePointerInfo getGOT(MachineFunction &MF);
  110   static MachinePointerInfo getStack(MachineFunction &MF, int64_t Offset,
  114   static MachinePointerInfo getUnknownStack(MachineFunction &MF);

  141   DenseMap<const Function*, std::unique_ptr<MachineFunction>> MachineFunctions;
  145   MachineFunction *LastResult = nullptr; ///< Used for shortcut/cache.
  168   MachineFunction &getOrCreateMachineFunction(const Function &F);
  172   MachineFunction *getMachineFunction(const Function &F) const;

  146   MachineOptimizationRemarkEmitter(MachineFunction &MF,
  186   MachineFunction &MF;
  214   bool runOnMachineFunction(MachineFunction &MF) override;

  108   MachineFunction *getMF() const { return MBB->getParent(); }
  170   MachineFunction *MF = nullptr;

   61   MachineFunction *MF = nullptr;
   90   bool runOnMachineFunction(MachineFunction &MF) override;
  508   SMSchedule(MachineFunction *mf)

   85   bool runOnMachineFunction(MachineFunction &MF) override;

   31   using FuncT = MachineFunction;
   49 class MachineRegionNode : public RegionNodeBase<RegionTraits<MachineFunction>> {
   61 class MachineRegion : public RegionBase<RegionTraits<MachineFunction>> {
   73 class MachineRegionInfo : public RegionInfoBase<RegionTraits<MachineFunction>> {
   81   void recalculate(MachineFunction &F, MachineDominatorTree *DT,
  100   bool runOnMachineFunction(MachineFunction &F) override;

   64   MachineFunction *MF;
  149   explicit MachineRegisterInfo(MachineFunction *MF);
  868   void freezeReservedRegs(const MachineFunction&);

   57   explicit MachineSSAUpdater(MachineFunction &MF,

  120   MachineFunction *MF = nullptr;
  922                  const MachineFunction &MF);

   27 bool shouldOptimizeForSize(const MachineFunction *MF, ProfileSummaryInfo *PSI,

   88   const MachineFunction *MF = nullptr;
  106   bool runOnMachineFunction(MachineFunction&) override;

  105   ModuloSchedule(MachineFunction &MF, MachineLoop *Loop,
  163   MachineFunction &MF;
  255   ModuloScheduleExpander(MachineFunction &MF, ModuloSchedule &S,
  275   MachineFunction &MF;
  304   PeelingModuloScheduleExpander(MachineFunction &MF, ModuloSchedule &S,
  354   MachineFunction &MF;
  358   ModuloScheduleTestAnnotater(MachineFunction &MF, ModuloSchedule &S)

  245       std::function<bool(const MachineFunction &)> Ftor);
  360   createUnpackMachineBundles(std::function<bool(const MachineFunction &)> Ftor);

   37   MachineFunction *MF;
   85   bool runOnMachineFunction(MachineFunction &MF) override;

  137   GraphMetadata(MachineFunction &MF,
  142   MachineFunction &MF;

   53   const MachineFunction *MF = nullptr;
   85   void runOnMachineFunction(const MachineFunction &MF);

  359   const MachineFunction *MF = nullptr;
  403   void init(const MachineFunction *mf, const RegisterClassInfo *rci,

  235 void scavengeFrameVirtualRegs(MachineFunction &MF, RegScavenger &RS);

  560     MachineFunction &MF;                ///< Machine function
  572     explicit ScheduleDAG(MachineFunction &mf);

  255     explicit ScheduleDAGInstrs(MachineFunction &mf,

  226   MachineFunction *MF;
  270   using CallSiteInfo = MachineFunction::CallSiteInfo;
  271   using CallSiteInfoImpl = MachineFunction::CallSiteInfoImpl;
  402   void init(MachineFunction &NewMF, OptimizationRemarkEmitter &NewORE,
  414   MachineFunction &getMachineFunction() const { return *MF; }

   51   MachineFunction *MF;
   77   bool runOnMachineFunction(MachineFunction &MF) override;

  322     MachineFunction *mf;
  362     bool runOnMachineFunction(MachineFunction &fn) override;
  607       MachineFunction::iterator nextMBB =
  626       MachineFunction::iterator prevMBB(mbb);

   38   MachineFunction *MF;
   70   void setFunction(MachineFunction &MF);

   42   MachineFunction *MF;
   66   void initMF(MachineFunction &MF, bool PreRegAlloc,

  111   virtual unsigned getStackAlignmentSkew(const MachineFunction &MF) const;
  130   assignCalleeSavedSpillSlots(MachineFunction &MF,
  159   virtual bool enableShrinkWrapping(const MachineFunction &MF) const {
  166   virtual bool enableStackSlotScavenging(const MachineFunction &MF) const {
  172   virtual bool enableCalleeSaveSkip(const MachineFunction &MF) const;
  176   virtual void emitPrologue(MachineFunction &MF,
  178   virtual void emitEpilogue(MachineFunction &MF,
  182   virtual void inlineStackProbe(MachineFunction &MF,
  187   virtual void adjustForSegmentedStacks(MachineFunction &MF,
  192   virtual void adjustForHiPEPrologue(MachineFunction &MF,
  221   virtual bool keepFramePointer(const MachineFunction &MF) const {
  228   virtual bool hasFP(const MachineFunction &MF) const = 0;
  235   virtual bool hasReservedCallFrame(const MachineFunction &MF) const {
  246   virtual bool canSimplifyCallFramePseudos(const MachineFunction &MF) const {
  253   virtual bool needsFrameIndexResolution(const MachineFunction &MF) const;
  258   virtual int getFrameIndexReference(const MachineFunction &MF, int FI,
  267   virtual int getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI,
  277   virtual int getNonLocalFrameIndexReference(const MachineFunction &MF,
  287   virtual void getCalleeSaves(const MachineFunction &MF,
  300   virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
  308   virtual void processFunctionBeforeFrameFinalized(MachineFunction &MF,
  312   virtual unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const {
  338   orderFrameObjects(const MachineFunction &MF,
  387   virtual int getInitialCFAOffset(const MachineFunction &MF) const;
  391   virtual unsigned getInitialCFARegister(const MachineFunction &MF) const;

   91                                          const MachineFunction &MF) const;
  324                                  const MachineFunction &MF) const;
  376   virtual MachineInstr *convertToThreeAddress(MachineFunction::iterator &MFI,
  784   virtual unsigned extraSizeToPredicateInstructions(const MachineFunction &MF,
 1092   foldMemoryOperandImpl(MachineFunction &MF, MachineInstr &MI,
 1106       MachineFunction &MF, MachineInstr &MI, ArrayRef<unsigned> Ops,
 1167   unfoldMemoryOperand(MachineFunction &MF, MachineInstr &MI, unsigned Reg,
 1328                                     const MachineFunction &MF) const;
 1357   CreateTargetPostRAHazardRecognizer(const MachineFunction &MF) const {
 1745   virtual void buildOutlinedFrame(MachineBasicBlock &MBB, MachineFunction &MF,
 1766   virtual bool isFunctionSafeToOutlineFrom(MachineFunction &MF,
 1773   virtual bool shouldOutlineFromFunctionByDefault(MachineFunction &MF) const {

  208   virtual void markLibCallAttributes(MachineFunction *MF, unsigned CC,
  357   int getRecipEstimateSqrtEnabled(EVT VT, MachineFunction &MF) const;
  363   int getRecipEstimateDivEnabled(EVT VT, MachineFunction &MF) const;
  369   int getSqrtRefinementSteps(EVT VT, MachineFunction &MF) const;
  375   int getDivRefinementSteps(EVT VT, MachineFunction &MF) const;
  707   virtual bool requiresUniformRegister(MachineFunction &MF,
  854                                   MachineFunction &,
 1663   virtual StringRef getStackProbeSymbolName(MachineFunction &MF) const {
 2658   virtual void finalizeLowering(MachineFunction &MF) const;
 3013   getPICJumpTableRelocBaseExpr(const MachineFunction *MF,
 3381   virtual bool supportSplitCSR(MachineFunction *MF) const {
 3654                               MachineFunction &/*MF*/, bool /*isVarArg*/,
 3700                                      const MachineFunction &MF) const {

   64   ArrayRef<MCPhysReg> (*OrderFunc)(const MachineFunction&);
  196   ArrayRef<MCPhysReg> getRawAllocationOrder(const MachineFunction &MF) const {
  322   BitVector getAllocatableSet(const MachineFunction &MF,
  419   getCalleeSavedRegs(const MachineFunction *MF) const = 0;
  439   virtual const uint32_t *getCallPreservedMask(const MachineFunction &MF,
  454   getIntraCallClobberedRegs(const MachineFunction *MF) const {
  476   virtual BitVector getReservedRegs(const MachineFunction &MF) const = 0;
  480   virtual bool isAsmClobberable(const MachineFunction &MF,
  500                                         const MachineFunction &MF) const {
  507                                     const MachineFunction &MF) const;
  691   getPointerRegClass(const MachineFunction &MF, unsigned Kind=0) const {
  710                             const MachineFunction &) const {
  723                                        MachineFunction &MF) const {
  731   virtual unsigned getRegPressureSetScore(const MachineFunction &MF,
  754   virtual unsigned getRegPressureSetLimit(const MachineFunction &MF,
  783                                      const MachineFunction &MF,
  794                                   MachineFunction &MF) const {
  816   virtual bool requiresRegisterScavenging(const MachineFunction &MF) const {
  822   virtual bool useFPForScavengingIndex(const MachineFunction &MF) const {
  828   virtual bool requiresFrameIndexScavenging(const MachineFunction &MF) const {
  835       const MachineFunction &MF) const {
  841   virtual bool requiresVirtualBaseRegisters(const MachineFunction &MF) const {
  851   virtual bool hasReservedSpillSlot(const MachineFunction &MF, unsigned Reg,
  857   virtual bool trackLivenessAfterRegAlloc(const MachineFunction &MF) const {
  862   virtual bool canRealignStack(const MachineFunction &MF) const;
  868   bool needsStackRealignment(const MachineFunction &MF) const;
  960   virtual Register getFrameRegister(const MachineFunction &MF) const = 0;

  297   virtual void mirFileLoaded(MachineFunction &MF) const;
  302   virtual bool ignoreCSRForAllocationOrder(const MachineFunction &MF,

   45     MachineFunction *MF;
   77     bool runOnMachineFunction(MachineFunction &MF) override;
   84     MachineFunction &getMachineFunction() const {

  563     auto *Parent = DT.Parent;

  133   convertFuncInfoToYAML(const MachineFunction &MF) const {

  131     bool DisableFramePointerElim(const MachineFunction &MF) const;

   36 bool shouldFuncOptimizeForSizeImpl(const FuncT *F, ProfileSummaryInfo *PSI,

  126     MachineFunction &MFi, const RegisterClassInfo &RCI,

  118     MachineFunction &MF;
  132     AggressiveAntiDepBreaker(MachineFunction &MFi,

   34   const MachineFunction &MF = VRM.getMachineFunction();

  727 llvm::getEHScopeMembership(const MachineFunction &MF) {

   38 void ARMException::beginFunction(const MachineFunction *MF) {
   60 void ARMException::endFunction(const MachineFunction *MF) {
   95   const MachineFunction *MF = Asm->MF;

  234 void AsmPrinter::emitInitialRawDwarfLocDirective(const MachineFunction &MF) {
  765   const MachineFunction *MF = MI.getMF();
  983 void AsmPrinter::emitStackSizeSection(const MachineFunction &MF) {
 1008 static bool needFuncLabelsForEHOrDebugInfo(const MachineFunction &MF,
 1654 void AsmPrinter::SetupMachineFunction(MachineFunction &MF) {

  496                                         const MachineFunction *MF) {
 1144   const MachineFunction &MF = *Asm->MF;
 1149   for (const MachineFunction::VariableDbgInfo &VI : MF.getVariableDbgInfo()) {
 1328 void CodeViewDebug::beginFunctionImpl(const MachineFunction *MF) {
 2830 void CodeViewDebug::endFunctionImpl(const MachineFunction *MF) {

  281   void maybeRecordLocation(const DebugLoc &DL, const MachineFunction *MF);
  450   void beginFunctionImpl(const MachineFunction *MF) override;
  453   void endFunctionImpl(const MachineFunction *) override;

  231 void llvm::calculateDbgEntityHistory(const MachineFunction *MF,

  172                          const MachineFunction *MF) {
  185 void DebugHandlerBase::beginFunction(const MachineFunction *MF) {
  337 void DebugHandlerBase::endFunction(const MachineFunction *MF) {

   43     MachineFunction *NonConstMF = const_cast<MachineFunction*>(Asm->MF);
   87 void DwarfCFIException::beginFunction(const MachineFunction *MF) {
  166 void DwarfCFIException::endFunction(const MachineFunction *MF) {

  691                                             const MachineFunction &MF) {
 1726 static DebugLoc findPrologueEndLoc(const MachineFunction *MF) {
 1759 DebugLoc DwarfDebug::emitInitialLocDirective(const MachineFunction &MF,
 1779 void DwarfDebug::beginFunctionImpl(const MachineFunction *MF) {
 1815 void DwarfDebug::endFunctionImpl(const MachineFunction *MF) {

  322   const MachineFunction *CurFn = nullptr;
  442                                   DIE &ScopeDIE, const MachineFunction &MF);
  587   void beginFunctionImpl(const MachineFunction *MF) override;
  590   void endFunctionImpl(const MachineFunction *MF) override;
  610   DebugLoc emitInitialLocDirective(const MachineFunction &MF, unsigned CUID);
  734   const MachineFunction *getCurrentFunction() const { return CurFn; }

   62   void beginFunction(const MachineFunction *MF) override;
   65   void endFunction(const MachineFunction *) override;
   87   void beginFunction(const MachineFunction *MF) override;
   90   void endFunction(const MachineFunction *) override;

  350   const MachineFunction *MF = Asm->MF;
  614   const MachineFunction *MF = Asm->MF;

   37     auto *NonConstMF = const_cast<MachineFunction *>(Asm->MF);
   44 void WasmException::endFunction(const MachineFunction *MF) {
   81   MachineFunction &MF = *Asm->MF;

   27   void beginFunction(const MachineFunction *MF) override {}
   29   void endFunction(const MachineFunction *MF) override;

   33 void WinCFGuard::endFunction(const MachineFunction *MF) {

   40   void beginFunction(const MachineFunction *MF) override {}
   45   void endFunction(const MachineFunction *MF) override;

   59 void WinException::beginFunction(const MachineFunction *MF) {
  120 void WinException::endFunction(const MachineFunction *MF) {
  133     MachineFunction *NonConstMF = const_cast<MachineFunction*>(MF);
  178   const MachineFunction *MF = MBB->getParent();
  253   const MachineFunction *MF = Asm->MF;
  388                             MachineFunction::const_iterator MFI,
  401   range(const WinEHFuncInfo &EHInfo, MachineFunction::const_iterator Begin,
  441   MachineFunction::const_iterator MFI;
  442   MachineFunction::const_iterator MFE;
  549 void WinException::emitCSpecificHandlerTable(const MachineFunction *MF) {
  597   MachineFunction::const_iterator End = MF->end();
  598   MachineFunction::const_iterator Stop = std::next(MF->begin());
  658 void WinException::emitCXXFrameHandler3Table(const MachineFunction *MF) {
  885     const MachineFunction *MF, const WinEHFuncInfo &FuncInfo,
  888   for (MachineFunction::const_iterator FuncletStart = MF->begin(),
  966 void WinException::emitExceptHandlerTable(const MachineFunction *MF) {
 1089 void WinException::emitCLRExceptionTable(const MachineFunction *MF) {
 1152   for (MachineFunction::const_iterator FuncletStart = MF->begin(),

   49   void emitCSpecificHandlerTable(const MachineFunction *MF);
   57   void emitCXXFrameHandler3Table(const MachineFunction *MF);
   62   void emitExceptHandlerTable(const MachineFunction *MF);
   64   void emitCLRExceptionTable(const MachineFunction *MF);
   67       const MachineFunction *MF, const WinEHFuncInfo &FuncInfo,
  101   void beginFunction(const MachineFunction *MF) override;
  106   void endFunction(const MachineFunction *) override;

  100     bool runOnMachineFunction(MachineFunction &MF) override;
  119 bool BranchFolderPass::runOnMachineFunction(MachineFunction &MF) {
  157   MachineFunction *MF = MBB->getParent();
  177 bool BranchFolder::OptimizeFunction(MachineFunction &MF,
  456   MachineFunction &MF = *CurMBB.getParent();
  459   MachineFunction::iterator MBBI = CurMBB.getIterator();
  517   MachineFunction *MF = CurMBB->getParent();
  518   MachineFunction::iterator I = std::next(MachineFunction::iterator(CurMBB));
  701       MachineFunction::iterator I(MBB);
  702       MachineFunction *MF = MBB->getParent();
  729   MachineFunction *MF = MBB1->getParent();
 1077 bool BranchFolder::TailMergeBlocks(MachineFunction &MF) {
 1121   for (MachineFunction::iterator I = std::next(MF.begin()), E = MF.end();
 1271 bool BranchFolder::OptimizeBranches(MachineFunction &MF) {
 1279   for (MachineFunction::iterator I = std::next(MF.begin()), E = MF.end();
 1392   MachineFunction &MF = *MBB->getParent();
 1395   MachineFunction::iterator FallThrough = MBB->getIterator();
 1782         MachineFunction::iterator SuccPrev = --SuccBB->getIterator();
 1831 bool BranchFolder::HoistCommonCode(MachineFunction &MF) {
 1833   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ) {

   49     bool OptimizeFunction(MachineFunction &MF, const TargetInstrInfo *tii,
  158     bool TailMergeBlocks(MachineFunction &MF);
  205     bool OptimizeBranches(MachineFunction &MF);
  217     bool HoistCommonCode(MachineFunction &MF);

   86   MachineFunction *MF;
  112   bool runOnMachineFunction(MachineFunction &MF) override;
  483   for (MachineFunction::iterator I = MF->begin(); I != MF->end(); ++I) {
  541 bool BranchRelaxation::runOnMachineFunction(MachineFunction &mf) {

   35   MachineFunction *MF;
   61   bool runOnMachineFunction(MachineFunction &MF) override;
  263 bool BreakFalseDeps::runOnMachineFunction(MachineFunction &mf) {

   48   bool runOnMachineFunction(MachineFunction &MF) override;
   60 bool CFGuardLongjmp::runOnMachineFunction(MachineFunction &MF) {

   50   bool runOnMachineFunction(MachineFunction &MF) override {
   90   void calculateCFAInfo(MachineFunction &MF);
  103   bool insertCFIInstrs(MachineFunction &MF);
  116   unsigned verify(MachineFunction &MF);
  126 void CFIInstrInserter::calculateCFAInfo(MachineFunction &MF) {
  245 bool CFIInstrInserter::insertCFIInstrs(MachineFunction &MF) {
  310 unsigned CFIInstrInserter::verify(MachineFunction &MF) {

   32                            MachineFunction &MF,

   29 CCState::CCState(CallingConv::ID CC, bool isVarArg, MachineFunction &mf,
  260                                 CallingConv::ID CallerCC, MachineFunction &MF,

   44 CriticalAntiDepBreaker::CriticalAntiDepBreaker(MachineFunction &MFi,

   37     MachineFunction& MF;
   74     CriticalAntiDepBreaker(MachineFunction& MFi, const RegisterClassInfo &RCI);

  158   DefaultVLIWScheduler(MachineFunction &MF, MachineLoopInfo &MLI,
  175 DefaultVLIWScheduler::DefaultVLIWScheduler(MachineFunction &MF,
  194 VLIWPacketizerList::VLIWPacketizerList(MachineFunction &mf,

   30     bool runOnMachineFunction(MachineFunction &MF) override;
   97 bool DeadMachineInstructionElim::runOnMachineFunction(MachineFunction &MF) {

   59   bool runOnMachineFunction(MachineFunction &MF) override;
   99   bool runOnce(MachineFunction &MF);
  493 bool DetectDeadLanes::runOnce(MachineFunction &MF) {
  570 bool DetectDeadLanes::runOnMachineFunction(MachineFunction &MF) {

  167   void runOnMachineFunction(MachineFunction &MF) {
  715   bool runOnMachineFunction(MachineFunction &MF) override;
  898 bool EarlyIfConverter::runOnMachineFunction(MachineFunction &MF) {
  950   bool runOnMachineFunction(MachineFunction &MF) override;
 1033 bool EarlyIfPredicator::runOnMachineFunction(MachineFunction &MF) {

   39 bool EdgeBundles::runOnMachineFunction(MachineFunction &mf) {
   77   const MachineFunction *MF = G.getMachineFunction();

  413 bool ExecutionDomainFix::runOnMachineFunction(MachineFunction &mf) {

   47   bool runOnMachineFunction(MachineFunction&) override;
  181 bool ExpandPostRA::runOnMachineFunction(MachineFunction &MF) {
  190   for (MachineFunction::iterator mbbi = MF.begin(), mbbe = MF.end();

   32   bool runOnMachineFunction(MachineFunction &F) override;
   36 bool FEntryInserter::runOnMachineFunction(MachineFunction &MF) {

   34     bool runOnMachineFunction(MachineFunction &MF) override;
   47 bool FinalizeISel::runOnMachineFunction(MachineFunction &MF) {
   52   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {

   29   bool runOnMachineFunction(MachineFunction &F) override;
   42 bool FuncletLayout::runOnMachineFunction(MachineFunction &F) {

   62   void FindSafePoints(MachineFunction &MF);
   67   void FindStackOffsets(MachineFunction &MF);
   75   bool runOnMachineFunction(MachineFunction &MF) override;
  274 void GCMachineCodeAnalysis::FindSafePoints(MachineFunction &MF) {
  289 void GCMachineCodeAnalysis::FindStackOffsets(MachineFunction &MF) {
  307 bool GCMachineCodeAnalysis::runOnMachineFunction(MachineFunction &MF) {

   78 void GISelCSEInfo::setMF(MachineFunction &MF) {
  230 void GISelCSEInfo::analyze(MachineFunction &MF) {
  378 bool GISelCSEAnalysisWrapperPass::runOnMachineFunction(MachineFunction &MF) {

  170   MachineFunction &MF = MIRBuilder.getMF();
  182   MachineFunction &MF = MIRBuilder.getMF();
  397                                      MachineFunction &MF,

   98 bool Combiner::combineMachineInstrs(MachineFunction &MF,

  557   auto &MF = *MI.getParent()->getParent();
  624   auto &MF = *MI.getParent()->getParent();
  803 static bool shouldLowerMemFuncForSize(const MachineFunction &MF) {
  922   auto &MF = *MI.getParent()->getParent();
 1036   auto &MF = *MI.getParent()->getParent();
 1144   auto &MF = *MI.getParent()->getParent();

   32 RAIIDelegateInstaller::RAIIDelegateInstaller(MachineFunction &MF,
   33                                              MachineFunction::Delegate *Del)

   32 GISelKnownBits::GISelKnownBits(MachineFunction &MF)
   37                                                 const MachineFunction &MF) {
  381 bool GISelKnownBitsAnalysis::runOnMachineFunction(MachineFunction &MF) {

   95 static void reportTranslationError(MachineFunction &MF,
  647                                           MachineFunction::iterator BBI,
  653   MachineFunction *CurMF = SwitchMBB->getParent();
  754   MachineFunction *CurMF = FuncInfo.MF;
  756   MachineFunction::iterator BBI(W.MBB);
 2213 bool IRTranslator::runOnMachineFunction(MachineFunction &CurMF) {

   66 bool InstructionSelect::runOnMachineFunction(MachineFunction &MF) {

   41   MachineFunction &MF = *MBB.getParent();

   63 void Legalizer::init(MachineFunction &MF) {
  142 bool Legalizer::runOnMachineFunction(MachineFunction &MF) {
  160   ReversePostOrderTraversal<MachineFunction *> RPOT(&MF);

   66 LegalizerHelper::LegalizerHelper(MachineFunction &MF,
   75 LegalizerHelper::LegalizerHelper(MachineFunction &MF, const LegalizerInfo &LI,
 2070         MachineFunction &MF = MIRBuilder.getMF();
 2161     MachineFunction &MF = MIRBuilder.getMF();
 2903     MachineFunction &MF = MIRBuilder.getMF();
 4167   const auto &MF = *MI.getMF();

  737 const MachineInstr *llvm::machineFunctionIsIllegal(const MachineFunction &MF) {

   33 void Localizer::init(MachineFunction &MF) {
  107 bool Localizer::localizeInterBlock(MachineFunction &MF,
  208 bool Localizer::runOnMachineFunction(MachineFunction &MF) {

   26 void MachineIRBuilder::setMF(MachineFunction &MF) {

   81 void RegBankSelect::init(MachineFunction &MF) {
  651 bool RegBankSelect::runOnMachineFunction(MachineFunction &MF) {
  679   ReversePostOrderTraversal<MachineFunction*> RPOT(&MF);

  165   const MachineFunction &MF = *MI.getMF();
  599   const MachineFunction &MF = *MI.getMF();

   41     const MachineFunction &MF, const TargetRegisterInfo &TRI,
   71     const MachineFunction &MF, const TargetRegisterInfo &TRI,
  118   MachineFunction &MF = *MBB.getParent();
  178 void llvm::reportGISelFailure(MachineFunction &MF, const TargetPassConfig &TPC,
  194 void llvm::reportGISelFailure(MachineFunction &MF, const TargetPassConfig &TPC,

  201     std::function<bool(const MachineFunction &)> PredicateFtor;
  206     IfConverter(std::function<bool(const MachineFunction &)> Ftor = nullptr)
  217     bool runOnMachineFunction(MachineFunction &MF) override;
  257     void AnalyzeBlocks(MachineFunction &MF,
  291       const MachineFunction &MF = *TBBInfo.BB->getParent();
  437 bool IfConverter::runOnMachineFunction(MachineFunction &MF) {
  636   MachineFunction::iterator I = MBB.getIterator();
  637   MachineFunction::iterator E = MBB.getParent()->end();
  705     MachineFunction::iterator I = TrueBBI.BB->getIterator();
 1426     MachineFunction &MF, std::vector<std::unique_ptr<IfcvtToken>> &Tokens) {
 1437   MachineFunction::iterator PI = MBB.getIterator();
 1438   MachineFunction::iterator I = std::next(PI);
 1439   MachineFunction::iterator TI = ToMBB.getIterator();
 1440   MachineFunction::iterator E = MBB.getParent()->end();
 2174   MachineFunction &MF = *ToBBI.BB->getParent();
 2358 llvm::createIfConverter(std::function<bool(const MachineFunction &)> Ftor) {

  216   bool runOnMachineFunction(MachineFunction &MF) override;
  296 bool ImplicitNullChecks::runOnMachineFunction(MachineFunction &MF) {

   86   MachineFunction &MF;
  139   HoistSpillHelper(MachineFunctionPass &pass, MachineFunction &mf,
  159   MachineFunction &MF;
  196   InlineSpiller(MachineFunctionPass &pass, MachineFunction &mf, VirtRegMap &vrm)
  242                                    MachineFunction &mf,

   54 void InterferenceCache::init(MachineFunction *mf,
  107                                      const MachineFunction *MF) {
  158   MachineFunction::const_iterator MFI =

   57     MachineFunction *MF;
  103     void clear(MachineFunction *mf, SlotIndexes *indexes, LiveIntervals *lis) {
  126                const MachineFunction *MF);
  143   MachineFunction *MF = nullptr;
  171   void init(MachineFunction *mf, LiveIntervalUnion *liuarray,

   93     MachineFunction &F) {

   50 void LexicalScopes::initialize(const MachineFunction &Fn) {

  281     MachineInstr *BuildDbgValue(MachineFunction &MF) const {
  448   bool isSpillInstruction(const MachineInstr &MI, MachineFunction *MF);
  456   bool isLocationSpill(const MachineInstr &MI, MachineFunction *MF,
  462                                                   MachineFunction *MF,
  505   bool ExtendRanges(MachineFunction &MF);
  523   void printVarLocInMBB(const MachineFunction &MF, const VarLocInMBB &V,
  528   bool runOnMachineFunction(MachineFunction &MF) override;
  630 void LiveDebugValues::printVarLocInMBB(const MachineFunction &MF,
  807   MachineFunction *MF = MI.getMF();
  846                                          MachineFunction *MF) {
  859                                       MachineFunction *MF, unsigned &Reg) {
  900                                       MachineFunction *MF, unsigned &Reg) {
  924   MachineFunction *MF = MI.getMF();
 1254 bool LiveDebugValues::ExtendRanges(MachineFunction &MF) {
 1347   ReversePostOrderTraversal<MachineFunction *> RPOT(&MF);
 1422 bool LiveDebugValues::runOnMachineFunction(MachineFunction &MF) {

  314   void rewriteLocations(VirtRegMap &VRM, const MachineFunction &MF,
  388   MachineFunction *MF = nullptr;
  441   bool collectDebugValues(MachineFunction &mf);
  450   bool runOnMachineFunction(MachineFunction &mf);
  681 bool LDVImpl::collectDebugValues(MachineFunction &mf) {
  683   for (MachineFunction::iterator MFI = mf.begin(), MFE = mf.end(); MFI != MFE;
  956 bool LDVImpl::runOnMachineFunction(MachineFunction &mf) {
  971 static void removeDebugValues(MachineFunction &mf) {
  983 bool LiveDebugVariables::runOnMachineFunction(MachineFunction &mf) {
 1152 void UserValue::rewriteLocations(VirtRegMap &VRM, const MachineFunction &MF,
 1341   MachineFunction::iterator MFEnd = VRM->getMachineFunction().end();
 1353     MachineFunction::iterator MBB = LIS.getMBBFromIndex(Start)->getIterator();
 1381   MachineFunction::iterator MBB = LIS.getMBBFromIndex(loc)->getIterator();

   56   bool runOnMachineFunction(MachineFunction &) override;

  125 bool LiveIntervals::runOnMachineFunction(MachineFunction &fn) {

  177                                const MachineFunction &MF) {
  183 void LivePhysRegs::addPristines(const MachineFunction &MF) {
  224     const MachineFunction &MF = *MBB.getParent();
  235   const MachineFunction &MF = *MBB.getParent();
  241   const MachineFunction &MF = *MBB.getParent();
  248   const MachineFunction &MF = *MBB.getParent();
  259   const MachineFunction &MF = *MBB.getParent();
  280   const MachineFunction &MF = *MBB.getParent();

   51 void LiveRangeCalc::reset(const MachineFunction *mf,
  590   const MachineFunction &MF = *MBB->getParent();

  462 LiveRangeEdit::calculateRegClassAndHint(MachineFunction &MF,

   57   bool runOnMachineFunction(MachineFunction &MF) override;
  107 bool LiveRangeShrink::runOnMachineFunction(MachineFunction &MF) {

   54 bool LiveRegMatrix::runOnMachineFunction(MachineFunction &MF) {

   93                                const MachineFunction &MF) {
   99 void LiveRegUnits::addPristines(const MachineFunction &MF) {
  127   const MachineFunction &MF = *MBB.getParent();
  144   const MachineFunction &MF = *MBB.getParent();

   49 bool LiveStacks::runOnMachineFunction(MachineFunction &MF) {

  620 bool LiveVariables::runOnMachineFunction(MachineFunction &mf) {
  668   for(MachineFunction::iterator i = MF->begin(), e = MF->end(); i != e; ++i)
  708 void LiveVariables::analyzePHINodes(const MachineFunction& Fn) {

   86     void calculateFrameObjectOffsets(MachineFunction &Fn);
   87     bool insertFrameReferenceRegisters(MachineFunction &Fn);
   96     bool runOnMachineFunction(MachineFunction &MF) override;
  112 bool LocalStackSlotPass::runOnMachineFunction(MachineFunction &MF) {
  190 void LocalStackSlotPass::calculateFrameObjectOffsets(MachineFunction &Fn) {
  280 bool LocalStackSlotPass::insertFrameReferenceRegisters(MachineFunction &Fn) {
  412       const MachineFunction *MF = MI.getMF();

   71   bool runOnMachineFunction(MachineFunction &MF) override;
   86 static std::vector<MachineBasicBlock *> GetRPOList(MachineFunction &MF) {
  400   MachineFunction &MF = *MBB->getParent();
  451 bool MIRCanonicalizer::runOnMachineFunction(MachineFunction &MF) {

   51   bool runOnMachineFunction(MachineFunction &MF) override {

  318 PerFunctionMIParsingState::PerFunctionMIParsingState(MachineFunction &MF,
  366   MachineFunction &MF;

  108                                  MachineFunction &MF);
  156   void computeFunctionProperties(MachineFunction &MF);
  299   MachineFunction &MF = MMI.getOrCreateMachineFunction(*F);
  306 static bool isSSA(const MachineFunction &MF) {
  316 void MIRParserImpl::computeFunctionProperties(MachineFunction &MF) {
  345   MachineFunction &MF = PFS.MF;
  367     MachineFunction::CallSiteInfo CSInfo;
  386                                          MachineFunction &MF) {
  495   MachineFunction &MF = PFS.MF;
  576   MachineFunction &MF = PFS.MF;
  628   MachineFunction &MF = PFS.MF;
  812   const MachineFunction &MF = PFS.MF;

  120   void print(const MachineFunction &MF);
  131                            const MachineFunction &MF, ModuleSlotTracker &MST);
  133                               const MachineFunction &MF,
  137   void initRegisterMaskIds(const MachineFunction &MF);
  195 void MIRPrinter::print(const MachineFunction &MF) {
  272 printStackObjectDbgInfo(const MachineFunction::VariableDbgInfo &DebugVar,
  358                                      const MachineFunction &MF,
  451   for (const MachineFunction::VariableDbgInfo &DebugVar :
  468                                         const MachineFunction &MF,
  542 void MIRPrinter::initRegisterMaskIds(const MachineFunction &MF) {
  592     const MachineFunction &MF = *MBB.getParent();
  593     MachineFunction::const_iterator NextI = std::next(MBB.getIterator());
  706   const auto *MF = MI.getMF();
  875 void llvm::printMIR(raw_ostream &OS, const MachineFunction &MF) {

   42   bool runOnMachineFunction(MachineFunction &MF) override {

   86   const MachineFunction &MF = *MBB->getParent();
  257   MachineFunction &MF = *MBB->getParent();

   48 MachineBasicBlock::MachineBasicBlock(MachineFunction &MF, const BasicBlock *B)
   61     const MachineFunction *MF = getParent();
   92   MachineFunction &MF = *N->getParent();
  116   MachineFunction *MF = Parent->getParent();
  127   if (MachineFunction *MF = N->getMF()) {
  277   const MachineFunction *MF = getParent();
  293   const MachineFunction *MF = getParent();
  822   MachineFunction::const_iterator I(this);
  827   MachineFunction::iterator Fallthrough = getIterator();
  879   MachineFunction *MF = getParent();
 1112   const MachineFunction *MF = getParent();

   90   using nodes_iterator = pointer_iterator<MachineFunction::const_iterator>;
  118   const MachineFunction *CurFunc = nullptr;
  129       const MachineFunction *F = Node->getParent();
  176       MachineFunction &F,
  192     const MachineFunction &F, const MachineBranchProbabilityInfo &MBPI,
  209 bool MachineBlockFrequencyInfo::runOnMachineFunction(MachineFunction &F) {
  249 const MachineFunction *MachineBlockFrequencyInfo::getFunction() const {

  340   MachineFunction *F;
  423       MachineFunction::iterator &PrevUnplacedBlockIt);
  427       MachineFunction::iterator &PrevUnplacedBlockIt,
  441       MachineFunction::iterator &PrevUnplacedBlockIt,
  527   bool runOnMachineFunction(MachineFunction &F) override;
 1652     MachineFunction::iterator &PrevUnplacedBlockIt,
 1654   for (MachineFunction::iterator I = PrevUnplacedBlockIt, E = F->end(); I != E;
 1707   MachineFunction::iterator PrevUnplacedBlockIt = F->begin();
 2561   for (MachineFunction::iterator FI = F->begin(), FE = F->end(); FI != FE;
 2574       MachineFunction::iterator NextFI = std::next(FI);
 2635   MachineFunction::iterator InsertPos = F->begin();
 2827     MachineFunction::iterator &PrevUnplacedBlockIt) {
 2888     MachineFunction::iterator &PrevUnplacedBlockIt,
 2975 bool MachineBlockPlacement::runOnMachineFunction(MachineFunction &MF) {
 3111   bool runOnMachineFunction(MachineFunction &F) override;
 3134 bool MachineBlockPlacementStats::runOnMachineFunction(MachineFunction &F) {

   79     bool runOnMachineFunction(MachineFunction &MF) override;
  258                                             const MachineFunction &MF,
  881 bool MachineCSE::runOnMachineFunction(MachineFunction &MF) {

   81   bool runOnMachineFunction(MachineFunction &MF) override;
  619         MachineFunction *MF = MBB->getParent();
  632 bool MachineCombiner::runOnMachineFunction(MachineFunction &MF) {

  200   bool runOnMachineFunction(MachineFunction &MF) override;
  640 bool MachineCopyPropagation::runOnMachineFunction(MachineFunction &MF) {

   39 bool MachineDominanceFrontier::runOnMachineFunction(MachineFunction &) {

   51 bool MachineDominatorTree::runOnMachineFunction(MachineFunction &F) {
   56 void MachineDominatorTree::calculate(MachineFunction &F) {

  114 BitVector MachineFrameInfo::getPristineRegs(const MachineFunction &MF) const {
  136 unsigned MachineFrameInfo::estimateStackSize(const MachineFunction &MF) const {
  189 void MachineFrameInfo::computeMaxCallFrameSize(const MachineFunction &MF) {
  214 void MachineFrameInfo::print(const MachineFunction &MF, raw_ostream &OS) const{
  255 LLVM_DUMP_METHOD void MachineFrameInfo::dump(const MachineFunction &MF) const {

  290   MachineFunction::iterator MBBI, E = end();
  529     static std::string getGraphName(const MachineFunction *F) {
  534                              const MachineFunction *Graph) {

   45   MachineFunction &MF = MMI.getOrCreateMachineFunction(F);

   45   bool runOnMachineFunction(MachineFunction &MF) override {

   79 static const MachineFunction *getMFIfAvailable(const MachineInstr &MI) {
   81     if (const MachineFunction *MF = MBB->getParent())
   94   if (const MachineFunction *MF = getMFIfAvailable(MI)) {
  102 void MachineInstr::addImplicitDefUseOperands(MachineFunction &MF) {
  116 MachineInstr::MachineInstr(MachineFunction &MF, const MCInstrDesc &tid,
  134 MachineInstr::MachineInstr(MachineFunction &MF, const MachineInstr &MI)
  179   MachineFunction *MF = MBB->getParent();
  199 void MachineInstr::addOperand(MachineFunction &MF, const MachineOperand &Op) {
  319 void MachineInstr::setExtraInfo(MachineFunction &MF,
  355 void MachineInstr::dropMemRefs(MachineFunction &MF) {
  363 void MachineInstr::setMemRefs(MachineFunction &MF,
  374 void MachineInstr::addMemOperand(MachineFunction &MF,
  382 void MachineInstr::cloneMemRefs(MachineFunction &MF, const MachineInstr &MI) {
  416 void MachineInstr::cloneMergedMemRefs(MachineFunction &MF,
  467 void MachineInstr::setPreInstrSymbol(MachineFunction &MF, MCSymbol *Symbol) {
  482 void MachineInstr::setPostInstrSymbol(MachineFunction &MF, MCSymbol *Symbol) {
  497 void MachineInstr::setHeapAllocMarker(MachineFunction &MF, MDNode *Marker) {
  506 void MachineInstr::cloneInstrSymbols(MachineFunction &MF,
  655 const MachineFunction *MachineInstr::getMF() const {
  677   MachineFunction *MF = MBB->getParent();
  836   const MachineFunction &MF = *getMF();
 1193   const MachineFunction *MF = getMF();
 1398 void MachineInstr::copyImplicitOps(MachineFunction &MF,
 1459   if (const MachineFunction *MF = getMFIfAvailable(*this)) {
 1476   const MachineFunction *MF = nullptr;
 1726     if (const MachineFunction *MF = getMFIfAvailable(*this)) {
 2008     if (const MachineFunction *MF = MBB->getParent())
 2013 MachineInstrBuilder llvm::BuildMI(MachineFunction &MF, const DebugLoc &DL,
 2029 MachineInstrBuilder llvm::BuildMI(MachineFunction &MF, const DebugLoc &DL,
 2053   MachineFunction &MF = *BB.getParent();
 2064   MachineFunction &MF = *BB.getParent();

   27         std::function<bool(const MachineFunction &)> Ftor = nullptr)
   32     bool runOnMachineFunction(MachineFunction &MF) override;
   35     std::function<bool(const MachineFunction &)> PredicateFtor;
   44 bool UnpackMachineBundles::runOnMachineFunction(MachineFunction &MF) {
   49   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
   82     std::function<bool(const MachineFunction &)> Ftor) {
   94     bool runOnMachineFunction(MachineFunction &MF) override;
  103 bool FinalizeMachineBundles::runOnMachineFunction(MachineFunction &MF) {
  130   MachineFunction &MF = *MBB.getParent();
  256 bool llvm::finalizeBundles(MachineFunction &MF) {
  258   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {

  149     bool runOnMachineFunction(MachineFunction &MF) override;
  304 bool MachineLICMBase::runOnMachineFunction(MachineFunction &MF) {
  955   const MachineFunction *MF = MI.getMF();
 1303   MachineFunction &MF = *MI->getMF();

   38 bool MachineLoopInfo::runOnMachineFunction(MachineFunction &) {
   56   MachineFunction::iterator Begin = TopMBB->getParent()->begin();
   71   MachineFunction::iterator End = BotMBB->getParent()->end();

   30   MachineFunction &MF = *Loop->getParent();

  264 MachineFunction *
  270 MachineFunction &
  279   MachineFunction *MF;
  283     MF = new MachineFunction(F, TM, STI, NextFnNum++, *this);

   40 static const MachineFunction *getMFIfAvailable(const MachineOperand &MO) {
   43       if (const MachineFunction *MF = MBB->getParent())
   47 static MachineFunction *getMFIfAvailable(MachineOperand &MO) {
   62   if (MachineFunction *MF = getMFIfAvailable(*this)) {
  105   if (MachineFunction *MF = getMFIfAvailable(*this)) {
  146   if (MachineFunction *MF = getMFIfAvailable(*this))
  237   if (MachineFunction *MF = getMFIfAvailable(*this))
  314     if (const MachineFunction *MF = getMFIfAvailable(*this)) {
  397   if (const MachineFunction *MF = getMFIfAvailable(MO)) {
  403 static const char *getTargetIndexName(const MachineFunction &MF, int Index) {
  538   const MachineFunction *MF = getMFIfAvailable(Op);
  774       if (const MachineFunction *MF = getMFIfAvailable(*this)) {
  789       if (const MachineFunction *MF = getMFIfAvailable(*this)) {
  821     if (const MachineFunction *MF = getMFIfAvailable(*this))
  833     if (const MachineFunction *MF = getMFIfAvailable(*this))
  919     if (const MachineFunction *MF = getMFIfAvailable(*this))
  988 MachinePointerInfo MachinePointerInfo::getConstantPool(MachineFunction &MF) {
  994 MachinePointerInfo MachinePointerInfo::getFixedStack(MachineFunction &MF,
  999 MachinePointerInfo MachinePointerInfo::getJumpTable(MachineFunction &MF) {
 1003 MachinePointerInfo MachinePointerInfo::getGOT(MachineFunction &MF) {
 1007 MachinePointerInfo MachinePointerInfo::getStack(MachineFunction &MF,
 1012 MachinePointerInfo MachinePointerInfo::getUnknownStack(MachineFunction &MF) {

   71     MachineFunction &MF) {

  893   MachineFunction *createOutlinedFunction(Module &M, OutlinedFunction &OF,
 1090 MachineFunction *MachineOutliner::createOutlinedFunction(
 1130   MachineFunction &MF = MMI.getOrCreateMachineFunction(*F);
 1224     MachineFunction *MF = OF.MF;
 1310     MachineFunction *MF = MMI.getMachineFunction(F);
 1357     MachineFunction *MF = MMI.getMachineFunction(F);
 1374     MachineFunction *MF = MMI.getMachineFunction(F);

  195 bool MachinePipeliner::runOnMachineFunction(MachineFunction &mf) {
 1544 static void computeLiveOuts(MachineFunction &MF, RegPressureTracker &RPTracker,

   39 bool MachinePostDominatorTree::runOnMachineFunction(MachineFunction &F) {

   58 void MachineRegionInfo::recalculate(MachineFunction &F,
   66   MachineBasicBlock *Entry = GraphTraits<MachineFunction*>::getEntryNode(&F);
   83 bool MachineRegionInfoPass::runOnMachineFunction(MachineFunction &F) {

   44 MachineRegisterInfo::MachineRegisterInfo(MachineFunction *MF)
  513 void MachineRegisterInfo::freezeReservedRegs(const MachineFunction &MF) {
  576   const MachineFunction &MF = *MBB.getParent();

   43 MachineSSAUpdater::MachineSSAUpdater(MachineFunction &MF,

  170   bool runOnMachineFunction(MachineFunction&) override;
  185   bool runOnMachineFunction(MachineFunction&) override;
  360 bool MachineScheduler::runOnMachineFunction(MachineFunction &mf) {
  398 bool PostMachineScheduler::runOnMachineFunction(MachineFunction &mf) {
  470   MachineFunction *MF = MBB->getParent();
  515   for (MachineFunction::iterator MBB = MF->begin(), MBBEnd = MF->end();
 1486         const MachineFunction &MF =
 2748   const MachineFunction &MF = *Begin->getMF();
 2867                  const MachineFunction &MF) {

  118     bool runOnMachineFunction(MachineFunction &MF) override;
  300 bool MachineSinking::runOnMachineFunction(MachineFunction &MF) {
 1056   bool runOnMachineFunction(MachineFunction &MF) override;
 1082   bool tryToSinkCopy(MachineBasicBlock &BB, MachineFunction &MF,
 1166   MachineFunction &MF = *SuccBB->getParent();
 1222                                          MachineFunction &MF,
 1336 bool PostRAMachineSinking::runOnMachineFunction(MachineFunction &MF) {

   48     const MachineFunction *MF,
   64     const MachineFunction *MF,
   80   static bool isFunctionColdInCallGraph(const MachineFunction *MF,
   87       const MachineFunction *MF,
  108 bool llvm::shouldOptimizeForSize(const MachineFunction *MF,

   65 bool MachineTraceMetrics::runOnMachineFunction(MachineFunction &Func) {

   89     unsigned verify(MachineFunction &MF);
   93     const MachineFunction *MF;
  243     void report(const char *msg, const MachineFunction *MF);
  291     void verifyProperties(const MachineFunction &MF);
  309     bool runOnMachineFunction(MachineFunction &MF) override {
  330   MachineFunction &MF = const_cast<MachineFunction&>(*this);
  350 void MachineVerifier::verifyProperties(const MachineFunction &MF) {
  360 unsigned MachineVerifier::verify(MachineFunction &MF) {
  403   for (MachineFunction::const_iterator MFI = MF.begin(), MFE = MF.end();
  474 void MachineVerifier::report(const char *msg, const MachineFunction *MF) {
  680       MachineFunction::const_iterator MBBI = MBB->getIterator();
  731       MachineFunction::const_iterator MBBI = MBB->getIterator();
 2603   MachineFunction::const_iterator MFI = MBB->getIterator();
 2760   for (df_ext_iterator<const MachineFunction *,

 1669   MachineFunction &MF = *BB->getParent();
 1935   bool runOnMachineFunction(MachineFunction &MF) override;
 1936   void runOnLoop(MachineFunction &MF, MachineLoop &L);
 1955 bool ModuloScheduleTest::runOnMachineFunction(MachineFunction &MF) {
 1985 void ModuloScheduleTest::runOnLoop(MachineFunction &MF, MachineLoop &L) {

   47     bool runOnMachineFunction(MachineFunction &Fn) override;
   73 bool OptimizePHIs::runOnMachineFunction(MachineFunction &Fn) {
   85   for (MachineFunction::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I)

   79     bool runOnMachineFunction(MachineFunction &MF) override;
   85     bool EliminatePHINodes(MachineFunction &MF, MachineBasicBlock &MBB);
   95     void analyzePHINodes(const MachineFunction& MF);
   98     bool SplitPHIEdges(MachineFunction &MF, MachineBasicBlock &MBB,
  147 bool PHIElimination::runOnMachineFunction(MachineFunction &MF) {
  204 bool PHIElimination::EliminatePHINodes(MachineFunction &MF,
  255   MachineFunction &MF = *MBB.getParent();
  551 void PHIElimination::analyzePHINodes(const MachineFunction& MF) {
  562 bool PHIElimination::SplitPHIEdges(MachineFunction &MF,

   31   bool runOnMachineFunction(MachineFunction &F) override;
   56 bool PatchableFunction::runOnMachineFunction(MachineFunction &MF) {

  167     bool runOnMachineFunction(MachineFunction &MF) override;
 1593 bool PeepholeOptimizer::runOnMachineFunction(MachineFunction &MF) {

   56     bool runOnMachineFunction(MachineFunction &Fn) override;
   68 bool PostRAHazardRecognizer::runOnMachineFunction(MachineFunction &Fn) {

  103     bool runOnMachineFunction(MachineFunction &Fn) override;
  147         MachineFunction &MF, MachineLoopInfo &MLI, AliasAnalysis *AA,
  206     MachineFunction &MF, MachineLoopInfo &MLI, AliasAnalysis *AA,
  281 bool PostRAScheduler::runOnMachineFunction(MachineFunction &Fn) {

   46   bool runOnMachineFunction(MachineFunction &MF) override;
  132 bool ProcessImplicitDefs::runOnMachineFunction(MachineFunction &MF) {
  145   for (MachineFunction::iterator MFI = MF.begin(), MFE = MF.end();

   96   bool runOnMachineFunction(MachineFunction &MF) override;
  123   void calculateCallFrameInfo(MachineFunction &MF);
  124   void calculateSaveRestoreBlocks(MachineFunction &MF);
  125   void spillCalleeSavedRegs(MachineFunction &MF);
  127   void calculateFrameObjectOffsets(MachineFunction &MF);
  128   void replaceFrameIndices(MachineFunction &MF);
  129   void replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &MF,
  131   void insertPrologEpilogCode(MachineFunction &MF);
  214 bool PEI::runOnMachineFunction(MachineFunction &MF) {
  297 void PEI::calculateCallFrameInfo(MachineFunction &MF) {
  315   for (MachineFunction::iterator BB = MF.begin(), E = MF.end(); BB != E; ++BB)
  350 void PEI::calculateSaveRestoreBlocks(MachineFunction &MF) {
  380 static void assignCalleeSavedSpillSlots(MachineFunction &F,
  460 static void updateLiveness(MachineFunction &MF) {
  535   MachineFunction &MF = *SaveBlock.getParent();
  562   MachineFunction &MF = *RestoreBlock.getParent();
  589 void PEI::spillCalleeSavedRegs(MachineFunction &MF) {
  783 void PEI::calculateFrameObjectOffsets(MachineFunction &MF) {
 1092 void PEI::insertPrologEpilogCode(MachineFunction &MF) {
 1131 void PEI::replaceFrameIndices(MachineFunction &MF) {
 1174 void PEI::replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &MF,

  134 bool ReachingDefAnalysis::runOnMachineFunction(MachineFunction &mf) {

   64   MachineFunction *MF;
  107   bool runOnMachineFunction(MachineFunction &mf) override;
  305 bool RABasic::runOnMachineFunction(MachineFunction &mf) {

  181     bool runOnMachineFunction(MachineFunction &MF) override;
 1292 bool RegAllocFast::runOnMachineFunction(MachineFunction &MF) {

  159   MachineFunction *MF;
  430   bool runOnMachineFunction(MachineFunction &mf) override;
 3210 bool RAGreedy::runOnMachineFunction(MachineFunction &mf) {

  136   bool runOnMachineFunction(MachineFunction &MF) override;
  163   void findVRegIntervalsToAlloc(const MachineFunction &MF, LiveIntervals &LIS);
  170                  MachineFunction &MF, LiveIntervals &LIS, VirtRegMap &VRM,
  182   void finalizeAlloc(MachineFunction &MF, LiveIntervals &LIS,
  439     MachineFunction &MF = G.getMetadata().MF;
  555 void RegAllocPBQP::findVRegIntervalsToAlloc(const MachineFunction &MF,
  569                                    const MachineFunction &MF) {
  579   MachineFunction &MF = G.getMetadata().MF;
  678                              MachineFunction &MF, LiveIntervals &LIS,
  707   MachineFunction &MF = G.getMetadata().MF;
  742 void RegAllocPBQP::finalizeAlloc(MachineFunction &MF,
  789 bool RegAllocPBQP::runOnMachineFunction(MachineFunction &MF) {

   57   bool runOnMachineFunction(MachineFunction &MF) override;
   61   static void computeCalleeSavedRegs(BitVector &SavedRegs, MachineFunction &MF);
   85 static bool isCallableFunction(const MachineFunction &MF) {
  101 bool RegUsageInfoCollector::runOnMachineFunction(MachineFunction &MF) {
  196 computeCalleeSavedRegs(BitVector &SavedRegs, MachineFunction &MF) {

   53   bool runOnMachineFunction(MachineFunction &MF) override;
  101 bool RegUsageInfoPropagation::runOnMachineFunction(MachineFunction &MF) {

   43 void RegisterClassInfo::runOnMachineFunction(const MachineFunction &mf) {

  124     MachineFunction* MF;
  340     bool runOnMachineFunction(MachineFunction&) override;
 3641   for (MachineFunction::iterator I = MF->begin(), E = MF->end(); I != E; ++I) {
 3676 bool RegisterCoalescer::runOnMachineFunction(MachineFunction &fn) {

  263 void RegPressureTracker::init(const MachineFunction *mf,

   57   MachineFunction &MF = *MBB.getParent();
  465   const MachineFunction &MF = *Before->getMF();
  538   const MachineFunction &MF = *MI.getMF();
  584   const MachineFunction &MF = *MBB.getParent();
  751 void llvm::scavengeFrameVirtualRegs(MachineFunction &MF, RegScavenger &RS) {
  793   bool runOnMachineFunction(MachineFunction &MF) override {

   63   bool runOnMachineFunction(MachineFunction &MF) override;
  376 bool RenameIndependentSubregs::runOnMachineFunction(MachineFunction &MF) {

   53     bool runOnMachineFunction(MachineFunction &MF) override {

   53 ScheduleDAG::ScheduleDAG(MachineFunction &mf)

  110 ScheduleDAGInstrs::ScheduleDAGInstrs(MachineFunction &mf,

18214   MachineFunction &MF = DAG.getMachineFunction();
20276   MachineFunction &MF = DAG.getMachineFunction();
20415   MachineFunction &MF = DAG.getMachineFunction();

   81 void FunctionLoweringInfo::set(const Function &fn, MachineFunction &mf,

   29   MachineFunction *MF;

 1460   MachineFunction &MF = DAG.getMachineFunction();

 1488   auto &MF = DAG.getMachineFunction();
 2256   auto &MF = DAG.getMachineFunction();

   81   ScheduleDAGFast(MachineFunction &mf)
  645   ScheduleDAGLinearize(MachineFunction &mf) : ScheduleDAGSDNodes(mf) {}

  189   ScheduleDAGRRList(MachineFunction &mf, bool needlatency,
  314                           const MachineFunction &MF) {
 1735   MachineFunction &MF;
 1752   RegReductionPQBase(MachineFunction &mf,
 1876   RegReductionPriorityQueue(MachineFunction &mf,

   48 ScheduleDAGSDNodes::ScheduleDAGSDNodes(MachineFunction &mf)

   55     explicit ScheduleDAGSDNodes(MachineFunction &mf);

   70   ScheduleDAGVLIW(MachineFunction &mf, AAResults *aa,

 1005 void SelectionDAG::init(MachineFunction &NewMF,
 5736 static bool shouldLowerMemFuncForSize(const MachineFunction &MF) {
 5789   MachineFunction &MF = DAG.getMachineFunction();
 5972   MachineFunction &MF = DAG.getMachineFunction();
 6078   MachineFunction &MF = DAG.getMachineFunction();
 6574   MachineFunction &MF = getMachineFunction();
 6712   MachineFunction &MF = getMachineFunction();
 6833   MachineFunction &MF = getMachineFunction();
 6885   MachineFunction &MF = getMachineFunction();

 2117   MachineFunction::iterator BBI(CurBB);
 2118   MachineFunction &MF = DAG.getMachineFunction();
 2479   MachineFunction &MF = DAG.getMachineFunction();
 4568   MachineFunction &MF = DAG.getMachineFunction();
 4619   MachineFunction &MF = DAG.getMachineFunction();
 4733   MachineFunction &MF = DAG.getMachineFunction();
 5493   MachineFunction &MF = DAG.getMachineFunction();
 6368     MachineFunction &MF = DAG.getMachineFunction();
 6388     MachineFunction &MF = DAG.getMachineFunction();
 6434     MachineFunction &MF = DAG.getMachineFunction();
 6640     MachineFunction &MF = DAG.getMachineFunction();
 6667     MachineFunction &MF = DAG.getMachineFunction();
 7026   MachineFunction &MF = DAG.getMachineFunction();
 7862   MachineFunction &MF = DAG.getMachineFunction();
 7887   MachineFunction &MF = DAG.getMachineFunction();
 9030     MachineFunction &MF = CLI.DAG.getMachineFunction();
 9765     MachineFunction& MF = SDB->DAG.getMachineFunction();
 9907   MachineFunction::VariableDbgInfoMapTy &DbgDeclareInfo = MF->getVariableDbgInfo();
 9909     for (MachineFunction::VariableDbgInfo &VI : DbgDeclareInfo) {
10011     MachineFunction *MF = ParentMBB->getParent();
10012     MachineFunction::iterator BBI(ParentMBB);
10023   MachineFunction::iterator I(MBB);
10045   MachineFunction *CurMF = FuncInfo.MF;
10047   MachineFunction::iterator BBI(W.MBB);
10377   MachineFunction::iterator BBI(W.MBB);
10470   MachineFunction::iterator BBI(SwitchMBB);

  467                             const MachineFunction *MF, const Module *M,
  480     const MachineFunction *MF = &G->getMachineFunction();

  411 bool SelectionDAGISel::runOnMachineFunction(MachineFunction &mf) {
  699 static void reportFastISelFailure(MachineFunction &MF,
 1198   MachineFunction *MF = MBB->getParent();
 1294   MachineFunction *MF = FuncInfo->MF;

  350 static MachineMemOperand* getMachineMemOperand(MachineFunction &MF,
  393     auto &MF = Builder.DAG.getMachineFunction();
  440     auto &MF = Builder.DAG.getMachineFunction();
  594       auto &MF = Builder.DAG.getMachineFunction();
 1027   auto &MF = DAG.getMachineFunction();

  437 TargetLowering::getPICJumpTableRelocBaseExpr(const MachineFunction *MF,
 6469   auto &MF = DAG.getMachineFunction();
 6624   auto &MF = DAG.getMachineFunction();

  157   MachineFunction *MachineFunc;
  187   void init(MachineFunction &MF) {
  214   static bool isShrinkWrapEnabled(const MachineFunction &MF);
  242   bool runOnMachineFunction(MachineFunction &MF) override;
  462 bool ShrinkWrap::runOnMachineFunction(MachineFunction &MF) {
  591 bool ShrinkWrap::isShrinkWrapEnabled(const MachineFunction &MF) {

   39 bool SlotIndexes::runOnMachineFunction(MachineFunction &fn) {

  196 bool SpillPlacement::runOnMachineFunction(MachineFunction &mf) {

   45   const MachineFunction *MF;
  157   bool runOnMachineFunction(MachineFunction &mf) override;

   38                                MachineFunction &mf,

  225   MachineFunction::iterator MFI =
  325   MachineFunction::const_iterator MFI =
 1174       MachineFunction::iterator MBB = LIS.getMBBFromIndex(Start)->getIterator();

   97   const MachineFunction &MF;

  382   MachineFunction *MF;
  447   bool runOnMachineFunction(MachineFunction &Func) override;
 1135 bool StackColoring::runOnMachineFunction(MachineFunction &Func) {

   69   bool runOnMachineFunction(MachineFunction &MF) override;
   73   bool calculateLiveness(MachineFunction &MF);
   76   void addLiveOutSetToMI(MachineFunction &MF, MachineInstr &MI);
   80   uint32_t *createRegisterMask(MachineFunction &MF) const;
  104 bool StackMapLiveness::runOnMachineFunction(MachineFunction &MF) {
  122 bool StackMapLiveness::calculateLiveness(MachineFunction &MF) {
  151 void StackMapLiveness::addLiveOutSetToMI(MachineFunction &MF,
  160 uint32_t *StackMapLiveness::createRegisterMask(MachineFunction &MF) const {

  114     bool runOnMachineFunction(MachineFunction &MF) override;
  118     void ScanForSpillSlotRefs(MachineFunction &MF);
  121     bool ColorSlots(MachineFunction &MF);
  123                             MachineFunction &MF);
  155 void StackSlotColoring::ScanForSpillSlotRefs(MachineFunction &MF) {
  159   for (MachineFunction::iterator MBBI = MF.begin(), E = MF.end();
  322 bool StackSlotColoring::ColorSlots(MachineFunction &MF) {
  397                                            MachineFunction &MF) {
  482 bool StackSlotColoring::runOnMachineFunction(MachineFunction &MF) {

   79 void SwiftErrorValueTracking::setFunction(MachineFunction &mf) {
  157   ReversePostOrderTraversal<MachineFunction *> RPOT(MF);

  231   MachineFunction *CurMF = FuncInfo.MF;

   36   bool runOnMachineFunction(MachineFunction &MF) override;
   72 bool TailDuplicateBase::runOnMachineFunction(MachineFunction &MF) {

   78 void TailDuplicator::initMF(MachineFunction &MFin, bool PreRegAlloc,
   95 static void VerifyPHIs(MachineFunction &MF, bool CheckExtra) {
   96   for (MachineFunction::iterator I = ++MF.begin(), E = MF.end(); I != E; ++I) {
  268   for (MachineFunction::iterator I = ++MF->begin(), E = MF->end(); I != E;) {

   33 bool TargetFrameLowering::enableCalleeSaveSkip(const MachineFunction &MF) const {
   44 int TargetFrameLowering::getFrameIndexReference(const MachineFunction &MF,
   59     const MachineFunction &MF) const {
   63 void TargetFrameLowering::getCalleeSaves(const MachineFunction &MF,
   76 void TargetFrameLowering::determineCalleeSaves(MachineFunction &MF,
  128     const MachineFunction &MF) const {
  149 int TargetFrameLowering::getInitialCFAOffset(const MachineFunction &MF) const {
  153 unsigned TargetFrameLowering::getInitialCFARegister(const MachineFunction &MF)

   47                              const MachineFunction &MF) const {
  210     MachineFunction &MF = *MI.getMF();
  381                                         const MachineFunction &MF) const {
  427   MachineFunction &MF = *MBB.getParent();
  468 static MachineInstr *foldPatchpoint(MachineFunction &MF, MachineInstr &MI,
  542   MachineFunction &MF = *MBB->getParent();
  630   MachineFunction &MF = *MBB.getParent();
  777   MachineFunction *MF = Root.getMF();
  884   const MachineFunction &MF = *MI.getMF();
  963   const MachineFunction *MF = MI.getMF();
  988                                            const MachineFunction &MF) const {
 1125   const MachineFunction *MF = MI.getMF();

 1022   MachineFunction &MF = *MI->getMF();
 1104   auto &MF = *MI.getMF();
 1119   auto &MF = *MI.getMF();
 1823 static StringRef getRecipEstimateForFunc(MachineFunction &MF) {
 1982                                                     MachineFunction &MF) const {
 1987                                                    MachineFunction &MF) const {
 1992                                                MachineFunction &MF) const {
 1997                                               MachineFunction &MF) const {
 2001 void TargetLoweringBase::finalizeLowering(MachineFunction &MF) const {

   24 bool TargetOptions::DisableFramePointerElim(const MachineFunction &MF) const {

  209 static void getAllocatableSetForRC(const MachineFunction &MF,
  217 BitVector TargetRegisterInfo::getAllocatableSet(const MachineFunction &MF,
  386                                           const MachineFunction &MF,
  429     unsigned PhysReg, const MachineFunction &MF) const {
  442 bool TargetRegisterInfo::canRealignStack(const MachineFunction &MF) const {
  447     const MachineFunction &MF) const {

  304   const MachineFunction &MF = *DefMI->getMF();

   93   MachineFunction *MF;
  195   bool runOnMachineFunction(MachineFunction&) override;
  734   MachineFunction::iterator MFI = MBB->getIterator();
 1666 bool TwoAddressInstructionPass::runOnMachineFunction(MachineFunction &Func) {
 1694   for (MachineFunction::iterator MBBI = MF->begin(), MBBE = MF->end();

   81     bool runOnMachineFunction(MachineFunction &F) override;
  102 bool UnreachableMachineBlockElim::runOnMachineFunction(MachineFunction &F) {
  118   for (MachineFunction::iterator I = F.begin(), E = F.end(); I != E; ++I) {
  160   for (MachineFunction::iterator I = F.begin(), E = F.end(); I != E; ++I) {

   62 bool VirtRegMap::runOnMachineFunction(MachineFunction &mf) {
  176   MachineFunction *MF;
  199   bool runOnMachineFunction(MachineFunction&) override;
  235 bool VirtRegRewriter::runOnMachineFunction(MachineFunction &fn) {
  499   for (MachineFunction::iterator MBBI = MF->begin(), MBBE = MF->end();

   59   bool runOnMachineFunction(MachineFunction &MF) override;
   68   void replaceRetWithPatchableRet(MachineFunction &MF,
   80   void prependRetWithPatchableExit(MachineFunction &MF,
   88     MachineFunction &MF, const TargetInstrInfo *TII,
  124     MachineFunction &MF, const TargetInstrInfo *TII,
  144 bool XRayInstrumentation::runOnMachineFunction(MachineFunction &MF) {

   88   bool runOnMachineFunction(MachineFunction &F) override;
  117 AArch64A53Fix835769::runOnMachineFunction(MachineFunction &F) {
  133   MachineFunction::iterator MBBI(MBB);

  120   bool runOnMachineFunction(MachineFunction &F) override;
  309 bool AArch64A57FPLoadBalancing::runOnMachineFunction(MachineFunction &F) {

   89   bool runOnMachineFunction(MachineFunction &F) override;
  391 bool AArch64AdvSIMDScalar::runOnMachineFunction(MachineFunction &mf) {
  402   for (MachineFunction::iterator I = mf.begin(), E = mf.end(); I != E; ++I)

  121   bool runOnMachineFunction(MachineFunction &MF) override {

   37   bool runOnMachineFunction(MachineFunction &MF) override;
   59 bool AArch64BranchTargets::runOnMachineFunction(MachineFunction &MF) {

  143     MachineFunction &MF = MIRBuilder.getMF();
  266     MachineFunction &MF = MIRBuilder.getMF();
  379   MachineFunction &MF = MIRBuilder.getMF();
  419   MachineFunction &MF = MIRBuilder.getMF();
  522     CallLoweringInfo &Info, MachineFunction &MF,
  562     CallLoweringInfo &Info, MachineFunction &MF,
  670   MachineFunction &MF = MIRBuilder.getMF();
  781   MachineFunction &MF = MIRBuilder.getMF();
  923   MachineFunction &MF = MIRBuilder.getMF();

   72                                       MachineFunction &MF,
   76   areCalleeOutgoingArgsTailCallable(CallLoweringInfo &Info, MachineFunction &MF,

   43   bool runOnMachineFunction(MachineFunction &MF) override {
   99     MachineFunction *MF = I.getParent()->getParent();
  117     MachineFunction *MF = I.getParent()->getParent();

  138   bool runOnMachineFunction(MachineFunction &MF) override;
  502 bool AArch64CollectLOH::runOnMachineFunction(MachineFunction &MF) {

   36   MachineFunction *MF;
   50   bool runOnMachineFunction(MachineFunction &MF) override;
  137 bool AArch64CompressJumpTables::runOnMachineFunction(MachineFunction &MFIn) {

   59   bool runOnMachineFunction(MachineFunction &MF) override;
  291 bool AArch64CondBrTuning::runOnMachineFunction(MachineFunction &MF) {

  115   bool runOnMachineFunction(MachineFunction &MF) override;
  328 bool AArch64ConditionOptimizer::runOnMachineFunction(MachineFunction &MF) {

  138   MachineFunction *MF;
  190   void runOnMachineFunction(MachineFunction &MF,
  781   bool runOnMachineFunction(MachineFunction &MF) override;
  928 bool AArch64ConditionalCompares::runOnMachineFunction(MachineFunction &MF) {

   49   bool runOnMachineFunction(MachineFunction &F) override;
  118   const MachineFunction &MF = *MBB.getParent();
  187 bool AArch64DeadRegisterDefinitions::runOnMachineFunction(MachineFunction &MF) {

   60   bool runOnMachineFunction(MachineFunction &Fn) override;
  186   MachineFunction *MF = MBB.getParent();
  268   MachineFunction *MF = MBB.getParent();
  351   MachineFunction *MF = MBB.getParent();
  477     MachineFunction *MF = MBB.getParent();
  498       MachineFunction &MF = *MI.getParent()->getParent();
  597     MachineFunction *MF = MBB.getParent();
  666      MachineFunction &MF = *MBB.getParent();
  725 bool AArch64ExpandPseudo::runOnMachineFunction(MachineFunction &MF) {

  189   bool runOnMachineFunction(MachineFunction &Fn) override;
  203   void runOnLoop(MachineLoop &L, MachineFunction &Fn);
  676 void FalkorHWPFFix::runOnLoop(MachineLoop &L, MachineFunction &Fn) {
  814 bool FalkorHWPFFix::runOnMachineFunction(MachineFunction &Fn) {

  184 static unsigned estimateRSStackSizeLimit(MachineFunction &MF) {
  210 static StackOffset getSVEStackSize(const MachineFunction &MF) {
  215 bool AArch64FrameLowering::canUseRedZone(const MachineFunction &MF) const {
  233 bool AArch64FrameLowering::hasFP(const MachineFunction &MF) const {
  269 AArch64FrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
  319 static bool ShouldSignReturnAddress(MachineFunction &MF) {
  346   MachineFunction &MF = *MBB.getParent();
  383   MachineFunction *MF = MBB->getParent();
  413   const MachineFunction *MF = MBB.getParent();
  426 static bool windowsRequiresStackProbe(MachineFunction &MF,
  444     MachineFunction &MF, unsigned StackBumpBytes) const {
  488   MachineFunction &MF = *MBB->getParent();
  816 static bool ShouldSignWithAKey(MachineFunction &MF) {
  827 static bool needsWinCFI(const MachineFunction &MF) {
  833 static bool isTargetDarwin(const MachineFunction &MF) {
  837 void AArch64FrameLowering::emitPrologue(MachineFunction &MF,
 1281 static void InsertReturnAddressAuth(MachineFunction &MF,
 1321 void AArch64FrameLowering::emitEpilogue(MachineFunction &MF,
 1569 int AArch64FrameLowering::getFrameIndexReference(const MachineFunction &MF,
 1581   const MachineFunction &MF, int FI) const {
 1585 static StackOffset getFPOffset(const MachineFunction &MF, int ObjectOffset) {
 1596 static StackOffset getStackOffset(const MachineFunction &MF, int ObjectOffset) {
 1601 int AArch64FrameLowering::getSEHFrameIndexOffset(const MachineFunction &MF,
 1612     const MachineFunction &MF, int FI, unsigned &FrameReg, bool PreferFP,
 1623     const MachineFunction &MF, int ObjectOffset, bool isFixed, bool isSVE,
 1757 static unsigned getPrologueDeath(MachineFunction &MF, unsigned Reg) {
 1767 static bool produceCompactUnwindFrame(MachineFunction &MF) {
 1826     MachineFunction &MF, const std::vector<CalleeSavedInfo> &CSI,
 1949   MachineFunction &MF = *MBB.getParent();
 2076   MachineFunction &MF = *MBB.getParent();
 2173 void AArch64FrameLowering::determineCalleeSaves(MachineFunction &MF,
 2319     const MachineFunction &MF) const {
 2342     MachineFunction &MF, RegScavenger *RS) const {
 2389     const MachineFunction &MF, int FI, unsigned &FrameReg,
 2401     const MachineFunction &MF) const {
 2408     const MachineFunction &MF) const {

   36   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   37   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   41   int getFrameIndexReference(const MachineFunction &MF, int FI,
   43   StackOffset resolveFrameIndexReference(const MachineFunction &MF, int FI,
   46   StackOffset resolveFrameOffsetReference(const MachineFunction &MF,
   61   bool canUseRedZone(const MachineFunction &MF) const;
   63   bool hasFP(const MachineFunction &MF) const override;
   64   bool hasReservedCallFrame(const MachineFunction &MF) const override;
   66   void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
   70   bool enableShrinkWrapping(const MachineFunction &MF) const override {
   74   bool enableStackSlotScavenging(const MachineFunction &MF) const override;
   76   void processFunctionBeforeFrameFinalized(MachineFunction &MF,
   79   unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const override;
   81   unsigned getWinEHFuncletFrameSize(const MachineFunction &MF) const;
   83   int getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI,
   86   int getNonLocalFrameIndexReference(const MachineFunction &MF,
   88   int getSEHFrameIndexOffset(const MachineFunction &MF, int FI) const;
  102   bool shouldCombineCSRLocalStackBump(MachineFunction &MF,

   54   bool runOnMachineFunction(MachineFunction &MF) override {

 1336   MachineFunction *MF = MBB->getParent();
 1340   MachineFunction::iterator It = ++MBB->getIterator();
 2869     const auto &MF = DAG.getMachineFunction();
 3138   MachineFunction &MF = DAG.getMachineFunction();
 3395   MachineFunction &MF = DAG.getMachineFunction();
 3566   MachineFunction &MF = DAG.getMachineFunction();
 3729   MachineFunction &MF = DAG.getMachineFunction();
 3730   MachineFunction::CallSiteInfo CSInfo;
 4149     CallingConv::ID CallConv, MachineFunction &MF, bool isVarArg,
 4165   auto &MF = DAG.getMachineFunction();
 4684   MachineFunction &MF = DAG.getMachineFunction();
 5346   MachineFunction &MF = DAG.getMachineFunction();
 5413   MachineFunction &MF = DAG.getMachineFunction();
 5543 getRegisterByName(const char* RegName, EVT VT, const MachineFunction &MF) const {
 5573   MachineFunction &MF = DAG.getMachineFunction();
 8362                                                MachineFunction &MF,
11398   MachineFunction &MF = DAG.getMachineFunction();
12445 void AArch64TargetLowering::finalizeLowering(MachineFunction &MF) const {

  340                           MachineFunction &MF,
  535   bool supportSplitCSR(MachineFunction *MF) const override {
  620   bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,
  717                              const MachineFunction &MF) const override;
  762   void finalizeLowering(MachineFunction &MF) const override;

   77   const MachineFunction *MF = MBB.getParent();
  965                                             const MachineFunction &MF) const {
 1050   MachineFunction *MF = MBB->getParent();
 2809   MachineFunction &MF = *MBB.getParent();
 2940   MachineFunction &MF = *MBB.getParent();
 3178     MachineFunction &MF, MachineInstr &MI, ArrayRef<unsigned> Ops,
 3983 genFusedMultiply(MachineFunction &MF, MachineRegisterInfo &MRI,
 4062 static MachineInstr *genMaddR(MachineFunction &MF, MachineRegisterInfo &MRI,
 4105   MachineFunction &MF = *MBB.getParent();
 4784   MachineFunction *MF = MBB->getParent();
 5021   MachineFunction *MF = C.getMF();
 5280     MachineFunction &MF, bool OutlineFromLinkOnceODRs) const {
 5343   MachineFunction *MF = MBB.getParent();
 5376   MachineFunction *MF = MBB->getParent();
 5463     MachineFunction *CalleeMF = MF->getMMI().getMachineFunction(*Callee);
 5532     MachineBasicBlock &MBB, MachineFunction &MF,
 5701   MachineFunction &MF) const {

  162   foldMemoryOperandImpl(MachineFunction &MF, MachineInstr &MI,
  197                             const MachineFunction &MF) const override;
  246   bool isFunctionSafeToOutlineFrom(MachineFunction &MF,
  254   void buildOutlinedFrame(MachineBasicBlock &MBB, MachineFunction &MF,
  260   bool shouldOutlineFromFunctionByDefault(MachineFunction &MF) const override;

   57   void setupMF(MachineFunction &MF, GISelKnownBits &KB,
   85   bool selectVaStartAAPCS(MachineInstr &I, MachineFunction &MF,
   87   bool selectVaStartDarwin(MachineInstr &I, MachineFunction &MF,
   90   bool selectCompareBranch(MachineInstr &I, MachineFunction &MF,
  133   unsigned emitConstantPoolEntry(Constant *CPVal, MachineFunction &MF) const;
  953     MachineInstr &I, MachineFunction &MF, MachineRegisterInfo &MRI) const {
 1084     MachineInstr &I, MachineFunction &MF, MachineRegisterInfo &MRI) const {
 1089     MachineInstr &I, MachineFunction &MF, MachineRegisterInfo &MRI) const {
 1118   MachineFunction &MF = *MBB.getParent();
 1156   MachineFunction &MF = *MBB.getParent();
 1280   MachineFunction &MF = *MBB.getParent();
 1321   MachineFunction &MF = *MBB.getParent();
 2373   MachineFunction &MF = *I.getParent()->getParent();
 3066                                                   MachineFunction &MF) const {
 3659   MachineFunction &MF = *MBB.getParent();

  726   MachineFunction &MF = MIRBuilder.getMF();

  175   bool runOnMachineFunction(MachineFunction &Fn) override;
 1814 bool AArch64LoadStoreOpt::runOnMachineFunction(MachineFunction &Fn) {

  126   explicit AArch64FunctionInfo(MachineFunction &MF) {

  327   const MachineFunction &MF = G.getMetadata().MF;

  117   bool runOnMachineFunction(MachineFunction &MF) override;
  143 bool AArch64PreLegalizerCombiner::runOnMachineFunction(MachineFunction &MF) {

   97   bool runOnMachineFunction(MachineFunction &MF) override;
  471     MachineFunction &MF) {

  270   const MachineFunction &MF = *MI.getParent()->getParent();
  421   const MachineFunction &MF = *MI.getParent()->getParent();
  522   const MachineFunction &MF = *MI.getParent()->getParent();

   44 AArch64RegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
   75     const MachineFunction *MF) const {
   84     MachineFunction &MF) const {
  114 AArch64RegisterInfo::getCallPreservedMask(const MachineFunction &MF,
  151 void AArch64RegisterInfo::UpdateCustomCallPreservedMask(MachineFunction &MF,
  176 AArch64RegisterInfo::getThisReturnPreservedMask(const MachineFunction &MF,
  194 AArch64RegisterInfo::getReservedRegs(const MachineFunction &MF) const {
  221 bool AArch64RegisterInfo::isReservedReg(const MachineFunction &MF,
  226 bool AArch64RegisterInfo::isAnyArgRegReserved(const MachineFunction &MF) const {
  233     const MachineFunction &MF) const {
  239 bool AArch64RegisterInfo::isAsmClobberable(const MachineFunction &MF,
  249 AArch64RegisterInfo::getPointerRegClass(const MachineFunction &MF,
  263 bool AArch64RegisterInfo::hasBasePointer(const MachineFunction &MF) const {
  291 AArch64RegisterInfo::getFrameRegister(const MachineFunction &MF) const {
  297     const MachineFunction &MF) const {
  302     const MachineFunction &MF) const {
  307 AArch64RegisterInfo::useFPForScavengingIndex(const MachineFunction &MF) const {
  318     const MachineFunction &MF) const {
  323 AArch64RegisterInfo::cannotEliminateFrame(const MachineFunction &MF) const {
  357   MachineFunction &MF = *MI->getParent()->getParent();
  413   const MachineFunction &MF = *MBB->getParent();
  438   const MachineFunction *MF = MI.getParent()->getParent();
  453   MachineFunction &MF = *MBB.getParent();
  539                                                   MachineFunction &MF) const {
  578   const MachineFunction &MF) const {

   37   bool isReservedReg(const MachineFunction &MF, unsigned Reg) const;
   38   bool isAnyArgRegReserved(const MachineFunction &MF) const;
   39   void emitReservedArgRegCallError(const MachineFunction &MF) const;
   41   void UpdateCustomCalleeSavedRegs(MachineFunction &MF) const;
   42   void UpdateCustomCallPreservedMask(MachineFunction &MF,
   46   const MCPhysReg *getCalleeSavedRegs(const MachineFunction *MF) const override;
   48   getCalleeSavedRegsViaCopy(const MachineFunction *MF) const;
   49   const uint32_t *getCallPreservedMask(const MachineFunction &MF,
   78   const uint32_t *getThisReturnPreservedMask(const MachineFunction &MF,
   84   BitVector getReservedRegs(const MachineFunction &MF) const override;
   85   bool isAsmClobberable(const MachineFunction &MF,
   89   getPointerRegClass(const MachineFunction &MF,
   94   bool requiresRegisterScavenging(const MachineFunction &MF) const override;
   95   bool useFPForScavengingIndex(const MachineFunction &MF) const override;
   96   bool requiresFrameIndexScavenging(const MachineFunction &MF) const override;
  109   bool cannotEliminateFrame(const MachineFunction &MF) const;
  111   bool requiresVirtualBaseRegisters(const MachineFunction &MF) const override;
  112   bool hasBasePointer(const MachineFunction &MF) const;
  116   Register getFrameRegister(const MachineFunction &MF) const override;
  119                                MachineFunction &MF) const override;
  121   bool trackLivenessAfterRegAlloc(const MachineFunction&) const override {
  125   unsigned getLocalAddressRegister(const MachineFunction &MF) const;

  160   bool shouldReplaceInst(MachineFunction *MF, const MCInstrDesc *InstDesc,
  167   bool shouldExitEarly(MachineFunction *MF, Subpass SP);
  199   bool runOnMachineFunction(MachineFunction &Fn) override;
  218 shouldReplaceInst(MachineFunction *MF, const MCInstrDesc *InstDesc,
  273 bool AArch64SIMDInstrOpt::shouldExitEarly(MachineFunction *MF, Subpass SP) {
  691 bool AArch64SIMDInstrOpt::runOnMachineFunction(MachineFunction &MF) {

   66   MachineFunction &MF = DAG.getMachineFunction();
  118   MachineFunction &MF = DAG.getMachineFunction();

  136   bool runOnMachineFunction(MachineFunction &Fn) override;
  149   bool functionUsesHardeningRegister(MachineFunction &MF) const;
  412     MachineFunction &MF) const {
  652 bool AArch64SpeculationHardening::runOnMachineFunction(MachineFunction &MF) {

   56   MachineFunction *MF;
   75   bool runOnMachineFunction(MachineFunction &Func) override;
  174 bool AArch64StackTaggingPreRA::runOnMachineFunction(MachineFunction &Func) {

   46   bool runOnMachineFunction(MachineFunction &F) override;
  121 bool AArch64StorePairSuppress::runOnMachineFunction(MachineFunction &MF) {

  297 void AArch64Subtarget::mirFileLoaded(MachineFunction &MF) const {

  494   void mirFileLoaded(MachineFunction &MF) const override;

   72 static uint32_t getFPMode(const MachineFunction &F) {
  365     const MachineFunction &MF) const {
  402     const MachineFunction &MF,
  420 bool AMDGPUAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
  570 uint64_t AMDGPUAsmPrinter::getFunctionCodeSize(const MachineFunction &MF) const {
  614   const MachineFunction &MF) const {
  918                                         const MachineFunction &MF) {
 1122 void AMDGPUAsmPrinter::EmitProgramInfoSI(const MachineFunction &MF,
 1169 void AMDGPUAsmPrinter::EmitPALMetadata(const MachineFunction &MF,
 1216                                         const MachineFunction &MF) const {

   65   uint64_t getFunctionCodeSize(const MachineFunction &MF) const;
   66   SIFunctionResourceInfo analyzeResourceUsage(const MachineFunction &MF) const;
   68   void getSIProgramInfo(SIProgramInfo &Out, const MachineFunction &MF);
   70                         const MachineFunction &MF) const;
   71   void findNumUsedRegistersSI(const MachineFunction &MF,
   77   void EmitProgramInfoSI(const MachineFunction &MF,
   79   void EmitPALMetadata(const MachineFunction &MF,
   90       const MachineFunction &MF) const;
   93       const MachineFunction &MF,
  107   bool runOnMachineFunction(MachineFunction &MF) override;

  225   MachineFunction &MF = B.getMF();
  267   auto &MF = B.getMF();
  295   MachineFunction &MF = B.getMF();
  344   MachineFunction &MF = B.getMF();
  368   MachineFunction &MF = B.getMF();
  388                                  MachineFunction &MF,
  440   MachineFunction &MF = B.getMF();
  564   MachineFunction &MF = B.getMF();

   34   unsigned getStackWidth(const MachineFunction &MF) const;

  211 MetadataStreamerV2::getHSACodeProps(const MachineFunction &MF,
  241 MetadataStreamerV2::getHSADebugProps(const MachineFunction &MF,
  465 void MetadataStreamerV2::emitKernel(const MachineFunction &MF,
  879 MetadataStreamerV3::getHSAKernelProps(const MachineFunction &MF,
  931 void MetadataStreamerV3::emitKernel(const MachineFunction &MF,

   48   virtual void emitKernel(const MachineFunction &MF,
   74   msgpack::MapDocNode getHSAKernelProps(const MachineFunction &MF,
  117   void emitKernel(const MachineFunction &MF,
  143       const MachineFunction &MF,
  146       const MachineFunction &MF,
  183   void emitKernel(const MachineFunction &MF,

  152   bool runOnMachineFunction(MachineFunction &MF) override;
  314   bool runOnMachineFunction(MachineFunction &MF) override;
  386 bool AMDGPUDAGToDAGISel::runOnMachineFunction(MachineFunction &MF) {
  616     MachineFunction &MF = CurDAG->getMachineFunction();
 1460   const MachineFunction &MF = CurDAG->getMachineFunction();
 1485   MachineFunction &MF = CurDAG->getMachineFunction();
 1556   MachineFunction &MF = CurDAG->getMachineFunction();
 1785   const MachineFunction &MF = CurDAG->getMachineFunction();
 2732 bool R600DAGToDAGISel::runOnMachineFunction(MachineFunction &MF) {

  911   const MachineFunction &MF = State.getMachineFunction();
 4091   MachineFunction &MF = DAG.getMachineFunction();
 4126   MachineFunction &MF = DAG.getMachineFunction();
 4143   MachineFunction &MF = DAG.getMachineFunction();
 4174     const MachineFunction &MF, const ImplicitParameter Param) const {

  321   uint32_t getImplicitParameterOffset(const MachineFunction &MF,

   66 void AMDGPUInstructionSelector::setupMF(MachineFunction &MF, GISelKnownBits &KB,
  301   MachineFunction *MF = BB->getParent();
  398   MachineFunction *MF = BB->getParent();
  981   MachineFunction &MF = B.getMF();
 1370   MachineFunction *MF = MBB->getParent();
 2004   MachineFunction *MF = MBB->getParent();
 2118   const MachineFunction *MF = MBB->getParent();

   57   void setupMF(MachineFunction &MF, GISelKnownBits &KB,

 1140   MachineFunction &MF = B.getMF();
 1213   MachineFunction &MF = B.getMF();
 1469   MachineFunction &MF = B.getMF();
 1642   MachineFunction &MF = B.getMF();
 1728   MachineFunction &MF = B.getMF();
 1889   const MachineFunction &MF = B.getMF();

  469   initializeMRT(MachineFunction &MF, const MachineRegionInfo *RegionInfo,
  472   static RegionMRT *buildMRT(MachineFunction &MF,
  623 MRT::initializeMRT(MachineFunction &MF, const MachineRegionInfo *RegionInfo,
  635 RegionMRT *MRT::buildMRT(MachineFunction &MF,
 1229   void initFallthroughMap(MachineFunction &MF);
 1241   bool runOnMachineFunction(MachineFunction &MF) override;
 1707 static MachineBasicBlock *getSingleExitNode(MachineFunction &MF) {
 1722 static bool hasOneExitNode(MachineFunction &MF) {
 1731   MachineFunction *MF = Region->getEntry()->getParent();
 1738     MachineFunction::iterator ExitIter = MF->end();
 1741     MachineFunction::iterator ExitIter = Exit->getIterator();
 1835   MachineFunction *MF = MergeBB->getParent();
 2297     MachineFunction *MF = MergeBB->getParent();
 2524   MachineFunction *MF = MBB->getParent();
 2802 void AMDGPUMachineCFGStructurizer::initFallthroughMap(MachineFunction &MF) {
 2857 static void checkRegOnlyPHIInputs(MachineFunction &MF) {
 2874 bool AMDGPUMachineCFGStructurizer::runOnMachineFunction(MachineFunction &MF) {

   16 AMDGPUMachineFunction::AMDGPUMachineFunction(const MachineFunction &MF) :

   44   AMDGPUMachineFunction(const MachineFunction &MF);

  341   const MachineFunction &MF = *MI.getParent()->getParent();
  671   MachineFunction *MF = &B.getMF();
  714   MachineFunction::iterator MBBI(MBB);
 1447     MachineFunction *MF = MI.getParent()->getParent();
 1467     MachineFunction *MF = MI.getParent()->getParent();
 1904   const MachineFunction &MF = *MI.getParent()->getParent();
 1923   const MachineFunction &MF = *MI.getParent()->getParent();
 1938   const MachineFunction &MF = *MI.getParent()->getParent();
 1974   const MachineFunction &MF = *MI.getParent()->getParent();
 2033   const MachineFunction &MF = *MI.getParent()->getParent();
 2113   const MachineFunction &MF = *MI.getParent()->getParent();

   96   const MachineFunction *MF) const {
  112 SIRegisterInfo::getCalleeSavedRegsViaCopy(const MachineFunction *MF) const {
  116 const uint32_t *SIRegisterInfo::getCallPreservedMask(const MachineFunction &MF,
  128 Register SIRegisterInfo::getFrameRegister(const MachineFunction &MF) const {

  338 AMDGPUSubtarget::getOccupancyWithLocalMemSize(const MachineFunction &MF) const {
  605 unsigned GCNSubtarget::getReservedNumSGPRs(const MachineFunction &MF) const {
  622 unsigned GCNSubtarget::computeOccupancy(const MachineFunction &MF,
  636 unsigned GCNSubtarget::getMaxNumSGPRs(const MachineFunction &MF) const {
  686 unsigned GCNSubtarget::getMaxNumVGPRs(const MachineFunction &MF) const {
  894 const AMDGPUSubtarget &AMDGPUSubtarget::get(const MachineFunction &MF) {

   85   static const AMDGPUSubtarget &get(const MachineFunction &MF);
  121   unsigned getOccupancyWithLocalMemSize(const MachineFunction &MF) const;
 1065   unsigned computeOccupancy(const MachineFunction &MF, unsigned LDSSize = 0,
 1113   unsigned getReservedNumSGPRs(const MachineFunction &MF) const;
 1123   unsigned getMaxNumSGPRs(const MachineFunction &MF) const;
 1165   unsigned getMaxNumVGPRs(const MachineFunction &MF) const;

 1008 GCNTargetMachine::convertFuncInfoToYAML(const MachineFunction &MF) const {
 1019   MachineFunction &MF = PFS.MF;

  116   convertFuncInfoToYAML(const MachineFunction &MF) const override;

  153   bool runOnMachineFunction(MachineFunction &MF) override {
  218   void orderBlocks(MachineFunction *MF);
  336   MachineFunction *FuncRep;
  493   MachineFunction *MF = MBB->getParent();
  505   MachineFunction *MF = blk->getParent();
  661   MachineFunction *Func = MBB->getParent();
  834         *GraphTraits<MachineFunction *>::nodes_begin(FuncRep);
  853   wrapup(*GraphTraits<MachineFunction *>::nodes_begin(FuncRep));
  876 void AMDGPUCFGStructurizer::orderBlocks(MachineFunction *MF) {
  879   for (scc_iterator<MachineFunction *> It = scc_begin(MF); !It.isAtEnd();

   99   bool runOnMachineFunction(MachineFunction &MF) override;
  554 bool GCNDPPCombine::runOnMachineFunction(MachineFunction &MF) {

   40 GCNHazardRecognizer::GCNHazardRecognizer(const MachineFunction &MF) :

   46   const MachineFunction &MF;
  101   GCNHazardRecognizer(const MachineFunction &MF);

   48   bool runOnMachineFunction(MachineFunction &MF) override;
  223 bool GCNNSAReassign::runOnMachineFunction(MachineFunction &MF) {

  123   bool runOnMachineFunction(MachineFunction &MF) override;
  206   unsigned collectCandidates(MachineFunction &MF, bool Collect = true);
  225   bool verifyCycles(MachineFunction &MF,
  682 unsigned GCNRegBankReassign::collectCandidates(MachineFunction &MF,
  718 bool GCNRegBankReassign::verifyCycles(MachineFunction &MF,
  727 bool GCNRegBankReassign::runOnMachineFunction(MachineFunction &MF) {

  293   const MachineFunction &MF = *MI.getMF();

   53   MachineFunction *MF;

   44 void R600AsmPrinter::EmitProgramInfoR600(const MachineFunction &MF) {
  103 bool R600AsmPrinter::runOnMachineFunction(MachineFunction &MF) {

   27   bool runOnMachineFunction(MachineFunction &MF) override;
   36   void EmitProgramInfoR600(const MachineFunction &MF);

   68   bool runOnMachineFunction(MachineFunction &MF) override;
  182 bool R600ClauseMergePass::runOnMachineFunction(MachineFunction &MF) {
  189   for (MachineFunction::iterator BB = MF.begin(), BB_E = MF.end();

  507   bool runOnMachineFunction(MachineFunction &MF) override {
  516     for (MachineFunction::iterator MB = MF.begin(), ME = MF.end(); MB != ME;

  316   bool runOnMachineFunction(MachineFunction &MF) override {
  320     for (MachineFunction::iterator BB = MF.begin(), BB_E = MF.end();

   51   bool runOnMachineFunction(MachineFunction &MF) override;
   82 bool R600ExpandSpecialInstrsPass::runOnMachineFunction(MachineFunction &MF) {
   88   for (MachineFunction::iterator BB = MF.begin(), BB_E = MF.end();

   21 int R600FrameLowering::getFrameIndexReference(const MachineFunction &MF,

   23   void emitPrologue(MachineFunction &MF,
   25   void emitEpilogue(MachineFunction &MF,
   27   int getFrameIndexReference(const MachineFunction &MF, int FI,
   30   bool hasFP(const MachineFunction &MF) const override {

  292   MachineFunction *MF = BB->getParent();
  474   MachineFunction &MF = DAG.getMachineFunction();
 1540   MachineFunction &MF = DAG.getMachineFunction();
 1585   MachineFunction &MF = DAG.getMachineFunction();

  204   const MachineFunction *MF = MI.getParent()->getParent();
  214   const MachineFunction *MF = MI.getParent()->getParent();
 1090                                              const MachineFunction &MF,
 1179 int R600InstrInfo::getIndirectIndexBegin(const MachineFunction &MF) const {
 1211 int R600InstrInfo::getIndirectIndexEnd(const MachineFunction &MF) const {

  216                                 const MachineFunction &MF,
  235   int getIndirectIndexBegin(const MachineFunction &MF) const;
  239   int getIndirectIndexEnd(const MachineFunction &MF) const;

   14 R600MachineFunctionInfo::R600MachineFunctionInfo(const MachineFunction &MF)

   21   R600MachineFunctionInfo(const MachineFunction &MF);

  137   bool runOnMachineFunction(MachineFunction &Fn) override;
  333 bool R600VectorRegMerger::runOnMachineFunction(MachineFunction &Fn) {
  341   for (MachineFunction::iterator MBB = Fn.begin(), MBBe = Fn.end();

   52   bool runOnMachineFunction(MachineFunction &Fn) override;
  147   R600PacketizerList(MachineFunction &MF, const R600Subtarget &ST,
  325 bool R600Packetizer::runOnMachineFunction(MachineFunction &Fn) {
  351   for (MachineFunction::iterator MBB = Fn.begin(), MBBe = Fn.end();
  369   for (MachineFunction::iterator MBB = Fn.begin(), MBBe = Fn.end();

   31 BitVector R600RegisterInfo::getReservedRegs(const MachineFunction &MF) const {
   66   const MachineFunction *) const {
   70 Register R600RegisterInfo::getFrameRegister(const MachineFunction &MF) const {

   27   BitVector getReservedRegs(const MachineFunction &MF) const override;
   28   const MCPhysReg *getCalleeSavedRegs(const MachineFunction *MF) const override;
   29   Register getFrameRegister(const MachineFunction &MF) const override;

   44   bool runOnMachineFunction(MachineFunction &MF) override;
   62 bool SIAddIMGInit::runOnMachineFunction(MachineFunction &MF) {
   69   for (MachineFunction::iterator BI = MF.begin(), BE = MF.end(); BI != BE;

  122   bool runOnMachineFunction(MachineFunction &MF) override;
  588 bool SIFixSGPRCopies::runOnMachineFunction(MachineFunction &MF) {
  597   for (MachineFunction::iterator BI = MF.begin(), BE = MF.end();

   35   bool runOnMachineFunction(MachineFunction &MF) override;
   48 bool SIFixVGPRCopies::runOnMachineFunction(MachineFunction &MF) {

   64   bool runOnMachineFunction(MachineFunction &MF) override;
  156                              MachineFunction &MF,
  219 bool SIFixupVectorISel::runOnMachineFunction(MachineFunction &MF) {

  114   bool runOnMachineFunction(MachineFunction &MF) override;
 1205   MachineFunction *MF = MI.getParent()->getParent();
 1442 bool SIFoldOperands::runOnMachineFunction(MachineFunction &MF) {

   50   bool runOnMachineFunction(MachineFunction &MF) override;
  304 bool SIFormMemoryClauses::runOnMachineFunction(MachineFunction &MF) {

   28                                          const MachineFunction &MF) {
   34                                        const MachineFunction &MF) {
   96   MachineFunction *MF = MBB.getParent();
  144   MachineFunction *MF = MBB.getParent();
  188                                           MachineFunction &MF,
  274   MachineFunction &MF) const {
  321     SIMachineFunctionInfo *MFI, MachineFunction &MF) const {
  392 void SIFrameLowering::emitEntryFunctionPrologue(MachineFunction &MF,
  534       MachineFunction &MF, MachineBasicBlock &MBB, SIMachineFunctionInfo *MFI,
  682 void SIFrameLowering::emitPrologue(MachineFunction &MF,
  828 void SIFrameLowering::emitEpilogue(MachineFunction &MF,
  943 int SIFrameLowering::getFrameIndexReference(const MachineFunction &MF, int FI,
  952   MachineFunction &MF,
  985 void SIFrameLowering::determineCalleeSaves(MachineFunction &MF,
 1060 void SIFrameLowering::determineCalleeSavesSGPR(MachineFunction &MF,
 1077     MachineFunction &MF, const TargetRegisterInfo *TRI,
 1131 bool SIFrameLowering::hasFP(const MachineFunction &MF) const {

   28   void emitEntryFunctionPrologue(MachineFunction &MF,
   30   void emitPrologue(MachineFunction &MF,
   32   void emitEpilogue(MachineFunction &MF,
   34   int getFrameIndexReference(const MachineFunction &MF, int FI,
   37   void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
   39   void determineCalleeSavesSGPR(MachineFunction &MF, BitVector &SavedRegs,
   42   assignCalleeSavedSpillSlots(MachineFunction &MF,
   49     MachineFunction &MF,
   59                            MachineFunction &MF,
   67     MachineFunction &MF) const;
   71       SIMachineFunctionInfo *MFI, MachineFunction &MF) const;
   74   void emitEntryFunctionScratchSetup(const GCNSubtarget &ST, MachineFunction &MF,
   80   bool hasFP(const MachineFunction &MF) const override;

  906                                           MachineFunction &MF,
 1402   MachineFunction &MF = DAG.getMachineFunction();
 1506   MachineFunction &MF = DAG.getMachineFunction();
 1614                                                       MachineFunction &MF,
 1668   MachineFunction &MF = CCInfo.getMachineFunction();
 1686   MachineFunction &MF = CCInfo.getMachineFunction();
 1700                                                  MachineFunction &MF,
 1722   MachineFunction &MF,
 1758                                             MachineFunction &MF,
 1813                                            MachineFunction &MF,
 1864                                      MachineFunction &MF,
 1973 bool SITargetLowering::supportSplitCSR(MachineFunction *MF) const {
 2023   MachineFunction &MF = DAG.getMachineFunction();
 2244   MachineFunction &MF, bool IsVarArg,
 2264   MachineFunction &MF = DAG.getMachineFunction();
 2592   MachineFunction &MF = DAG.getMachineFunction();
 2682   MachineFunction &MF = DAG.getMachineFunction();
 2983                                              const MachineFunction &MF) const {
 3043   MachineFunction *MF = BB->getParent();
 3064   MachineFunction *MF = MBB.getParent();
 3071   MachineFunction::iterator MBBI(MBB);
 3178   MachineFunction *MF = OrigBB.getParent();
 3278   MachineFunction *MF = MBB.getParent();
 3394   MachineFunction *MF = MBB.getParent();
 3485   MachineFunction *MF = MBB.getParent();
 3584   MachineFunction *MF = BB->getParent();
 4034     MachineFunction &MF = DAG.getMachineFunction();
 4541   MachineFunction &MF = DAG.getMachineFunction();
 4586   const MachineFunction &MF = DAG.getMachineFunction();
 4610   MachineFunction &MF = DAG.getMachineFunction();
 4631   MachineFunction &MF = DAG.getMachineFunction();
 4673   MachineFunction &MF = DAG.getMachineFunction();
 4751   const MachineFunction &MF = DAG.getMachineFunction();
 5319   MachineFunction &MF = DAG.getMachineFunction();
 5641   MachineFunction &MF = DAG.getMachineFunction();
 5706   MachineFunction &MF = DAG.getMachineFunction();
 6771   MachineFunction &MF = DAG.getMachineFunction();
 7388   MachineFunction &MF = DAG.getMachineFunction();
 7887   MachineFunction &MF = DAG.getMachineFunction();
 9078   const MachineFunction &MF = DAG.getMachineFunction();
 9217   const MachineFunction &MF = DAG.getMachineFunction();
 9914   const MachineFunction &MF = DCI.DAG.getMachineFunction();
10674 void SITargetLowering::finalizeLowering(MachineFunction &MF) const {
10832       const MachineFunction * MF = FLI->MF;
10898     const MachineFunction &MF = DAG.getMachineFunction();
10989 bool SITargetLowering::requiresUniformRegister(MachineFunction &MF,

  230                           MachineFunction &MF,
  284   bool supportSplitCSR(MachineFunction *MF) const override;
  297                       MachineFunction &MF, bool isVarArg,
  333                              const MachineFunction &MF) const override;
  378   void finalizeLowering(MachineFunction &MF) const override;
  401   virtual bool requiresUniformRegister(MachineFunction &MF,
  406                             MachineFunction &MF,
  411                            MachineFunction &MF,
  417                                       MachineFunction &MF,
  422     MachineFunction &MF,
  427                                  MachineFunction &MF,

   75   bool runOnMachineFunction(MachineFunction &MF) override;
  111   const MachineFunction *MF = From.getParent();
  113   for (MachineFunction::const_iterator MBBI(&From), ToI(&To), End = MF->end();
  151   MachineFunction *MF = MBB.getParent();
  274     const MachineFunction *MF = MI.getParent()->getParent();
  308   MachineFunction *MF = MBB.getParent();
  311   MachineFunction::iterator MBBI(MBB);
  429 bool SIInsertSkips::runOnMachineFunction(MachineFunction &MF) {
  441   MachineFunction::iterator NextBB;
  445   for (MachineFunction::iterator BI = MF.begin(), BE = MF.end();

  402   bool runOnMachineFunction(MachineFunction &MF) override;
  453   bool insertWaitcntInBlock(MachineFunction &MF, MachineBasicBlock &Block,
 1361 bool SIInsertWaitcnts::insertWaitcntInBlock(MachineFunction &MF,
 1444 bool SIInsertWaitcnts::runOnMachineFunction(MachineFunction &MF) {
 1543   for (MachineFunction::iterator BI = MF.begin(), BE = MF.end(); BI != BE;

  418   const MachineFunction &MF = *MI1.getParent()->getParent();
  513   MachineFunction *MF = MBB.getParent();
  819   MachineFunction *MF = MBB.getParent();
 1049   MachineFunction *MF = MBB.getParent();
 1177   MachineFunction *MF = MBB.getParent();
 1231   MachineFunction *MF = MBB.getParent();
 1504     MachineFunction &MF = *MBB.getParent();
 1569   MachineFunction *MF = MBB.getParent();
 1777   MachineFunction *MF = MBB.getParent();
 2596   const MachineFunction *MF = MO->getParent()->getParent()->getParent();
 2605 MachineInstr *SIInstrInfo::convertToThreeAddress(MachineFunction::iterator &MBB,
 2725                                        const MachineFunction &MF) const {
 2937   const MachineFunction *MF = MI.getParent()->getParent();
 3196   const MachineFunction *MF = MI.getParent()->getParent();
 3926     const MachineFunction *MF = MO.getParent()->getParent()->getParent();
 3951   const MachineFunction &MF = *MI.getParent()->getParent();
 4322   MachineFunction &MF = *OrigBB.getParent();
 4405   MachineFunction &MF = *MBB.getParent();
 4432   MachineFunction::iterator MBBI(MBB);
 4474   MachineFunction &MF = *MBB.getParent();
 4515   MachineFunction &MF = *MI.getParent()->getParent();
 6037     const MachineFunction *MF = MI.getParent()->getParent();
 6071   MachineFunction *MF = IfEntry->getParent();
 6097   MachineFunction *MF = LoopEnd->getParent();
 6159 SIInstrInfo::CreateTargetPostRAHazardRecognizer(const MachineFunction &MF) const {
 6244   MachineFunction *MF = MBB->getParent();

  323   MachineInstr *convertToThreeAddress(MachineFunction::iterator &MBB,
  329                             const MachineFunction &MF) const override;
  673     const MachineFunction &MF = *MI.getParent()->getParent();
  679     const MachineFunction &MF = *MI.getParent()->getParent();
  968   CreateTargetPostRAHazardRecognizer(const MachineFunction &MF) const override;
 1022                                          const MachineFunction &MF)

  263   bool runOnMachineFunction(MachineFunction &MF) override;
  625 static MachineMemOperand *combineKnownAdjacentMMOs(MachineFunction &MF,
 1829 bool SILoadStoreOptimizer::runOnMachineFunction(MachineFunction &MF) {

  113   bool runOnMachineFunction(MachineFunction &MF) override;
  494 bool SILowerControlFlow::runOnMachineFunction(MachineFunction &MF) {
  524   MachineFunction::iterator NextBB;
  525   for (MachineFunction::iterator BI = MF.begin(), BE = MF.end();

   43 static unsigned createLaneMaskReg(MachineFunction &MF);
   54   MachineFunction *MF = nullptr;
   76   bool runOnMachineFunction(MachineFunction &MF) override;
  427 static unsigned createLaneMaskReg(MachineFunction &MF) {
  435   MachineFunction &MF = *MBB.getParent();
  453 bool SILowerI1Copies::runOnMachineFunction(MachineFunction &TheMF) {

   63   void calculateSaveRestoreBlocks(MachineFunction &MF);
   64   bool spillCalleeSavedRegs(MachineFunction &MF);
   66   bool runOnMachineFunction(MachineFunction &MF) override;
   90   MachineFunction &MF = *SaveBlock.getParent();
  122   MachineFunction &MF = *RestoreBlock.getParent();
  154 void SILowerSGPRSpills::calculateSaveRestoreBlocks(MachineFunction &MF) {
  184 bool SILowerSGPRSpills::spillCalleeSavedRegs(MachineFunction &MF) {
  230 bool SILowerSGPRSpills::runOnMachineFunction(MachineFunction &MF) {

   29 SIMachineFunctionInfo::SIMachineFunctionInfo(const MachineFunction &MF)
  181 void SIMachineFunctionInfo::limitOccupancy(const MachineFunction &MF) {
  253 bool SIMachineFunctionInfo::haveFreeLanesForSGPRSpill(const MachineFunction &MF,
  261 bool SIMachineFunctionInfo::allocateSGPRSpillToVGPR(MachineFunction &MF,
  324 bool SIMachineFunctionInfo::allocateVGPRSpillToAGPR(MachineFunction &MF,

  482   SIMachineFunctionInfo(const MachineFunction &MF);
  514   bool haveFreeLanesForSGPRSpill(const MachineFunction &MF,
  516   bool allocateSGPRSpillToVGPR(MachineFunction &MF, int FI);
  517   bool allocateVGPRSpillToAGPR(MachineFunction &MF, int FI, bool isAGPRtoVGPR);
  911   void limitOccupancy(const MachineFunction &MF);
  918   void increaseOccupancy(const MachineFunction &MF, unsigned Limit) {

  228   SIMemOpAccess(MachineFunction &MF);
  439   bool runOnMachineFunction(MachineFunction &MF) override;
  512 SIMemOpAccess::SIMemOpAccess(MachineFunction &MF) {
 1284 bool SIMemoryLegalizer::runOnMachineFunction(MachineFunction &MF) {

  137   bool runOnMachineFunction(MachineFunction &MF) override;
  375 bool SIModeRegister::runOnMachineFunction(MachineFunction &MF) {

   34   bool runOnMachineFunction(MachineFunction &MF) override;
  267 bool SIOptimizeExecMasking::runOnMachineFunction(MachineFunction &MF) {

   56   bool runOnMachineFunction(MachineFunction &MF) override;
  293 bool SIOptimizeExecMaskingPreRA::runOnMachineFunction(MachineFunction &MF) {

   89   bool runOnMachineFunction(MachineFunction &MF) override;
 1204 bool SIPeepholeSDWA::runOnMachineFunction(MachineFunction &MF) {

   54   bool runOnMachineFunction(MachineFunction &MF) override;
   68   void rewriteRegs(MachineFunction &MF);
  120 void SIPreAllocateWWMRegs::rewriteRegs(MachineFunction &MF) {
  163 bool SIPreAllocateWWMRegs::runOnMachineFunction(MachineFunction &MF) {
  185   ReversePostOrderTraversal<MachineFunction*> RPOT(&MF);

  110   const MachineFunction &MF) const {
  134   const MachineFunction &MF) const {
  139 BitVector SIRegisterInfo::getReservedRegs(const MachineFunction &MF) const {
  263 bool SIRegisterInfo::canRealignStack(const MachineFunction &MF) const {
  276 bool SIRegisterInfo::requiresRegisterScavenging(const MachineFunction &Fn) const {
  288   const MachineFunction &MF) const {
  297   const MachineFunction &MF) const {
  303   const MachineFunction &) const {
  308 bool SIRegisterInfo::trackLivenessAfterRegAlloc(const MachineFunction &MF) const {
  352   MachineFunction *MF = MBB->getParent();
  397   MachineFunction *MF = MBB->getParent();
  425   const MachineFunction &MF, unsigned Kind) const {
  550   MachineFunction *MF = MI->getParent()->getParent();
  625   MachineFunction *MF = MI->getParent()->getParent();
  750   MachineFunction *MF = MBB->getParent();
  867   MachineFunction *MF = MI->getParent()->getParent();
  986   MachineFunction *MF = MI->getParent()->getParent();
 1507                                    const MachineFunction &MF) const {
 1734                                              MachineFunction &MF) const {
 1749 unsigned SIRegisterInfo::getRegPressureSetLimit(const MachineFunction &MF,
 1770 unsigned SIRegisterInfo::getReturnAddressReg(const MachineFunction &MF) const {

   51   unsigned reservedPrivateSegmentBufferReg(const MachineFunction &MF) const;
   56     const MachineFunction &MF) const;
   58   BitVector getReservedRegs(const MachineFunction &MF) const override;
   60   const MCPhysReg *getCalleeSavedRegs(const MachineFunction *MF) const override;
   61   const MCPhysReg *getCalleeSavedRegsViaCopy(const MachineFunction *MF) const;
   62   const uint32_t *getCallPreservedMask(const MachineFunction &MF,
   71   Register getFrameRegister(const MachineFunction &MF) const override;
   73   bool canRealignStack(const MachineFunction &MF) const override;
   74   bool requiresRegisterScavenging(const MachineFunction &Fn) const override;
   76   bool requiresFrameIndexScavenging(const MachineFunction &MF) const override;
   78     const MachineFunction &MF) const override;
   79   bool requiresVirtualBaseRegisters(const MachineFunction &Fn) const override;
   80   bool trackLivenessAfterRegAlloc(const MachineFunction &MF) const override;
  100     const MachineFunction &MF, unsigned Kind = 0) const override;
  196                               const MachineFunction &MF) const;
  240                                MachineFunction &MF) const override;
  242   unsigned getRegPressureSetLimit(const MachineFunction &MF,
  247   unsigned getReturnAddressReg(const MachineFunction &MF) const;

   47   bool runOnMachineFunction(MachineFunction &MF) override;
  170 static void copyExtraImplicitOps(MachineInstr &NewMI, MachineFunction &MF,
  226   MachineFunction *MF = MI.getParent()->getParent();
  549 bool SIShrinkInstructions::runOnMachineFunction(MachineFunction &MF) {
  560   for (MachineFunction::iterator BI = MF.begin(), BE = MF.end();

  166   char scanInstructions(MachineFunction &MF, std::vector<WorkItem> &Worklist);
  169   char analyzeFunction(MachineFunction &MF);
  198   bool runOnMachineFunction(MachineFunction &MF) override;
  310 char SIWholeQuadMode::scanInstructions(MachineFunction &MF,
  321   ReversePostOrderTraversal<MachineFunction *> RPOT(&MF);
  509 char SIWholeQuadMode::analyzeFunction(MachineFunction &MF) {
  876 bool SIWholeQuadMode::runOnMachineFunction(MachineFunction &MF) {

   49   bool runOnMachineFunction(MachineFunction &MF) override;
  142 bool ARCBranchFinalize::runOnMachineFunction(MachineFunction &MF) {

   32   bool runOnMachineFunction(MachineFunction &Fn) override;
   37   void ExpandStore(MachineFunction &, MachineBasicBlock::iterator);
   59 void ARCExpandPseudos::ExpandStore(MachineFunction &MF,
   76 bool ARCExpandPseudos::runOnMachineFunction(MachineFunction &MF) {

   89 void ARCFrameLowering::determineCalleeSaves(MachineFunction &MF,
  100   MachineFunction &MF = *MBB.getParent();
  116 void ARCFrameLowering::emitPrologue(MachineFunction &MF,
  240 void ARCFrameLowering::emitEpilogue(MachineFunction &MF,
  347     MachineFunction &MF, const TargetRegisterInfo *TRI,
  436     MachineFunction &MF, RegScavenger *RS) const {
  493 bool ARCFrameLowering::hasFP(const MachineFunction &MF) const {

   34   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   37   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   40   void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
   54   void processFunctionBeforeFrameFinalized(MachineFunction &MF,
   57   bool hasFP(const MachineFunction &MF) const override;
   64       llvm::MachineFunction &, const llvm::TargetRegisterInfo *,

  450   MachineFunction &MF = DAG.getMachineFunction();
  593     CallingConv::ID CallConv, MachineFunction &MF, bool IsVarArg,
  711   MachineFunction &MF = DAG.getMachineFunction();
  734   MachineFunction &MF = DAG.getMachineFunction();

  109   bool CanLowerReturn(CallingConv::ID CallConv, MachineFunction &MF,

  300   MachineFunction &MF = *MBB.getParent();
  328   MachineFunction &MF = *MBB.getParent();
  405     const MachineFunction *MF = MI.getParent()->getParent();

   34   explicit ARCFunctionInfo(MachineFunction &MF)

   55   bool runOnMachineFunction(MachineFunction &MF) override;
  486 bool ARCOptAddrMode::runOnMachineFunction(MachineFunction &MF) {

  130 bool ARCRegisterInfo::needsFrameMoves(const MachineFunction &MF) {
  135 ARCRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
  139 BitVector ARCRegisterInfo::getReservedRegs(const MachineFunction &MF) const {
  152     const MachineFunction &MF) const {
  157     const MachineFunction &MF) const {
  161 bool ARCRegisterInfo::useFPForScavengingIndex(const MachineFunction &MF) const {
  173   MachineFunction &MF = *MI.getParent()->getParent();
  226 Register ARCRegisterInfo::getFrameRegister(const MachineFunction &MF) const {
  232 ARCRegisterInfo::getCallPreservedMask(const MachineFunction &MF,

   31   const MCPhysReg *getCalleeSavedRegs(const MachineFunction *MF) const override;
   33   BitVector getReservedRegs(const MachineFunction &MF) const override;
   35   bool requiresRegisterScavenging(const MachineFunction &MF) const override;
   37   bool trackLivenessAfterRegAlloc(const MachineFunction &MF) const override;
   39   bool useFPForScavengingIndex(const MachineFunction &MF) const override;
   45   const uint32_t *getCallPreservedMask(const MachineFunction &MF,
   49   Register getFrameRegister(const MachineFunction &MF) const override;
   52   static bool needsFrameMoves(const MachineFunction &MF);

   52     bool runOnMachineFunction(MachineFunction &Fn) override;
  655 bool A15SDOptimizer::runOnMachineFunction(MachineFunction &Fn) {

  106 bool ARMAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
  210       const MachineFunction &MF = *MI->getParent()->getParent();
  420       const MachineFunction &MF = *MI->getParent()->getParent();
 1070   const MachineFunction &MF = *MI->getParent()->getParent();
 1243   const MachineFunction &MF = *MI->getParent()->getParent();

   91   bool runOnMachineFunction(MachineFunction &F) override;

  142     MachineFunction::iterator &MFI, MachineInstr &MI, LiveVariables *LV) const {
  148   MachineFunction &MF = *MI.getParent()->getParent();
  702   const MachineFunction *MF = MBB.getParent();
 1032   MachineFunction &MF = *MBB.getParent();
 1275   MachineFunction &MF = *MBB.getParent();
 1649 static unsigned duplicateCPV(MachineFunction &MF, unsigned &CPI) {
 1707     MachineFunction &MF = *MBB.getParent();
 1729       MachineFunction &MF = *MBB.getParent();
 1777     const MachineFunction *MF = MI0.getParent()->getParent();
 1951                                             const MachineFunction &MF) const {
 2083 ARMBaseInstrInfo::extraSizeToPredicateInstructions(const MachineFunction &MF,
 2399                                       MachineFunction &MF, MachineInstr *MI,
 4312       const MachineFunction *MF = DefMI.getParent()->getParent();

  117   MachineInstr *convertToThreeAddress(MachineFunction::iterator &MFI,
  263                             const MachineFunction &MF) const override;
  279   unsigned extraSizeToPredicateInstructions(const MachineFunction &MF,
  595                                 MachineFunction &MF, MachineInstr *MI,

   65 ARMBaseRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
  113     const MachineFunction *MF) const {
  122 ARMBaseRegisterInfo::getCallPreservedMask(const MachineFunction &MF,
  146 ARMBaseRegisterInfo::getTLSCallPreservedMask(const MachineFunction &MF) const {
  153 ARMBaseRegisterInfo::getSjLjDispatchPreservedMask(const MachineFunction &MF) const {
  162 ARMBaseRegisterInfo::getThisReturnPreservedMask(const MachineFunction &MF,
  181     const MachineFunction *MF) const {
  187 getReservedRegs(const MachineFunction &MF) const {
  223 isAsmClobberable(const MachineFunction &MF, unsigned PhysReg) const {
  229                                                const MachineFunction &MF) const {
  251 ARMBaseRegisterInfo::getPointerRegClass(const MachineFunction &MF, unsigned Kind)
  265                                          MachineFunction &MF) const {
  304                                            const MachineFunction &MF,
  356                                         MachineFunction &MF) const {
  379 bool ARMBaseRegisterInfo::hasBasePointer(const MachineFunction &MF) const {
  416 bool ARMBaseRegisterInfo::canRealignStack(const MachineFunction &MF) const {
  438 cannotEliminateFrame(const MachineFunction &MF) const {
  447 ARMBaseRegisterInfo::getFrameRegister(const MachineFunction &MF) const {
  462   MachineFunction &MF = *MBB.getParent();
  478 requiresRegisterScavenging(const MachineFunction &MF) const {
  483 trackLivenessAfterRegAlloc(const MachineFunction &MF) const {
  488 requiresFrameIndexScavenging(const MachineFunction &MF) const {
  493 requiresVirtualBaseRegisters(const MachineFunction &MF) const {
  582   MachineFunction &MF = *MI->getParent()->getParent();
  642   const MachineFunction &MF = *MBB->getParent();
  658   MachineFunction &MF = *MBB.getParent();
  754   MachineFunction &MF = *MBB.getParent();

  112   const MCPhysReg *getCalleeSavedRegs(const MachineFunction *MF) const override;
  114   getCalleeSavedRegsViaCopy(const MachineFunction *MF) const;
  115   const uint32_t *getCallPreservedMask(const MachineFunction &MF,
  118   const uint32_t *getTLSCallPreservedMask(const MachineFunction &MF) const;
  119   const uint32_t *getSjLjDispatchPreservedMask(const MachineFunction &MF) const;
  129   const uint32_t *getThisReturnPreservedMask(const MachineFunction &MF,
  133   getIntraCallClobberedRegs(const MachineFunction *MF) const override;
  135   BitVector getReservedRegs(const MachineFunction &MF) const override;
  136   bool isAsmClobberable(const MachineFunction &MF,
  140   getPointerRegClass(const MachineFunction &MF,
  147                             const MachineFunction &MF) const override;
  150                                MachineFunction &MF) const override;
  155                              const MachineFunction &MF,
  160                           MachineFunction &MF) const override;
  162   bool hasBasePointer(const MachineFunction &MF) const;
  164   bool canRealignStack(const MachineFunction &MF) const override;
  176   bool cannotEliminateFrame(const MachineFunction &MF) const;
  179   Register getFrameRegister(const MachineFunction &MF) const override;
  193   bool requiresRegisterScavenging(const MachineFunction &MF) const override;
  195   bool trackLivenessAfterRegAlloc(const MachineFunction &MF) const override;
  197   bool requiresFrameIndexScavenging(const MachineFunction &MF) const override;
  199   bool requiresVirtualBaseRegisters(const MachineFunction &MF) const override;

  112   MachineFunction &MF;
  118   ARMBasicBlockUtils(MachineFunction &MF) : MF(MF) {

  192                                         MachineFunction &MF) const {
  244   auto &MF = MIRBuilder.getMF();
  432   auto &MF = MIRBuilder.getMF();
  504   MachineFunction &MF = MIRBuilder.getMF();

   53                          MachineFunction &MF) const;

  213     MachineFunction *MF;
  229     bool runOnMachineFunction(MachineFunction &MF) override;
  346 bool ARMConstantIslands::runOnMachineFunction(MachineFunction &mf) {
  619   MachineFunction::iterator MBBI = MBB->getIterator();
  899   MachineFunction::iterator MBBI = ++OrigBB->getIterator();
 1028   MachineFunction::const_iterator NextBlock = Water->getIterator();
 2110   MachineFunction::iterator MBB = JTMI->getParent()->getIterator();
 2111   MachineFunction *MF = MBB->getParent();
 2403   MachineFunction::iterator BBi = BB->getIterator();
 2404   MachineFunction::iterator OldPrior = std::prev(BBi);
 2426   MachineFunction::iterator MBBI = ++JTBB->getIterator();

   49     bool runOnMachineFunction(MachineFunction &Fn) override;
  944   MachineFunction *MF = MBB.getParent();
 1069   MachineFunction *MF = MBB.getParent();
 1334       MachineFunction &MF = *MI.getParent()->getParent();
 1413         MachineFunction *MF = MBB.getParent();
 1970 bool ARMExpandPseudo::runOnMachineFunction(MachineFunction &MF) {

   82 bool ARMFrameLowering::keepFramePointer(const MachineFunction &MF) const {
   91 bool ARMFrameLowering::enableCalleeSaveSkip(const MachineFunction &MF) const {
  104 bool ARMFrameLowering::hasFP(const MachineFunction &MF) const {
  123 bool ARMFrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
  141 ARMFrameLowering::canSimplifyCallFramePseudos(const MachineFunction &MF) const {
  214 static bool WindowsRequiresStackProbe(const MachineFunction &MF,
  253     MachineFunction &MF = *MBB.getParent();
  279 static void emitAligningInstructions(MachineFunction &MF, ARMFunctionInfo *AFI,
  356 void ARMFrameLowering::emitPrologue(MachineFunction &MF,
  770 void ARMFrameLowering::emitEpilogue(MachineFunction &MF,
  882 ARMFrameLowering::getFrameIndexReference(const MachineFunction &MF, int FI,
  888 ARMFrameLowering::ResolveFrameIndexReference(const MachineFunction &MF,
  978   MachineFunction &MF = *MBB.getParent();
 1055   MachineFunction &MF = *MBB.getParent();
 1167   MachineFunction &MF = *MBB.getParent();
 1340   MachineFunction &MF = *MBB.getParent();
 1432   MachineFunction &MF = *MBB.getParent();
 1463   MachineFunction &MF = *MBB.getParent();
 1487 static unsigned EstimateFunctionSizeInBytes(const MachineFunction &MF,
 1505 static unsigned estimateRSStackSizeLimit(MachineFunction &MF,
 1590 checkNumAlignedDPRCS2Regs(MachineFunction &MF, BitVector &SavedRegs) {
 1633 void ARMFrameLowering::determineCalleeSaves(MachineFunction &MF,
 2133 void ARMFrameLowering::getCalleeSaves(const MachineFunction &MF,
 2246     MachineFunction &MF, MachineBasicBlock &PrologueMBB) const {

   31   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   32   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   44   bool keepFramePointer(const MachineFunction &MF) const override;
   46   bool enableCalleeSaveSkip(const MachineFunction &MF) const override;
   48   bool hasFP(const MachineFunction &MF) const override;
   49   bool hasReservedCallFrame(const MachineFunction &MF) const override;
   50   bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override;
   51   int getFrameIndexReference(const MachineFunction &MF, int FI,
   53   int ResolveFrameIndexReference(const MachineFunction &MF, int FI,
   56   void getCalleeSaves(const MachineFunction &MF,
   58   void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
   61   void adjustForSegmentedStacks(MachineFunction &MF,
   65   bool enableShrinkWrapping(const MachineFunction &MF) const override {

   46       const MachineFunction *MF = MI->getParent()->getParent();

   61   bool runOnMachineFunction(MachineFunction &MF) override {
 3016       MachineFunction& MF = CurDAG->getMachineFunction();

 2064   MachineFunction &MF = DAG.getMachineFunction();
 2065   MachineFunction::CallSiteInfo CSInfo;
 2558   MachineFunction &MF = DAG.getMachineFunction();
 2678                                   MachineFunction &MF, bool isVarArg,
 2688   const MachineFunction &MF = DAG.getMachineFunction();
 2740   MachineFunction &MF = DAG.getMachineFunction();
 3023   MachineFunction &MF = DAG.getMachineFunction();
 3097   MachineFunction &F = DAG.getMachineFunction();
 3182   MachineFunction &MF = DAG.getMachineFunction();
 3230     MachineFunction &MF = DAG.getMachineFunction();
 3369   MachineFunction &MF = DAG.getMachineFunction();
 3592       MachineFunction &MF = DAG.getMachineFunction();
 3679     MachineFunction &MF = DAG.getMachineFunction();
 3819   MachineFunction &MF = DAG.getMachineFunction();
 3837   MachineFunction &MF = DAG.getMachineFunction();
 3893   MachineFunction &MF = DAG.getMachineFunction();
 3936   MachineFunction &MF = DAG.getMachineFunction();
 3955   MachineFunction &MF = DAG.getMachineFunction();
 5527   MachineFunction &MF = DAG.getMachineFunction();
 5553   MachineFunction &MF = DAG.getMachineFunction();
 5571                                               const MachineFunction &MF) const {
 9344   MachineFunction *MF = MBB->getParent();
 9468   MachineFunction *MF = MBB->getParent();
 9480   for (MachineFunction::iterator BB = MF->begin(), E = MF->end(); BB != E;
10015   MachineFunction::iterator It = ++BB->getIterator();
10023   MachineFunction *MF = BB->getParent();
10333   MachineFunction *MF = MBB->getParent();
10482     MachineFunction::iterator It = ++BB->getIterator();
10491     MachineFunction *F = BB->getParent();
10615     MachineFunction::iterator BBI = ++BB->getIterator();
10616     MachineFunction *Fn = BB->getParent();
10695   MachineFunction *MF = MI.getParent()->getParent();
16242                                            MachineFunction &MF,
17136 void ARMTargetLowering::finalizeLowering(MachineFunction &MF) const {

  510                             MachineFunction &MF,
  617     void finalizeLowering(MachineFunction &MF) const override;
  736                                const MachineFunction &MF) const override;
  761     bool supportSplitCSR(MachineFunction *MF) const override {
  805                         MachineFunction &MF, bool isVarArg,

   93   MachineFunction &MF = *MI->getParent()->getParent();

  622   auto &MF = *MBB.getParent();
  841   auto &MF = *MBB.getParent();

  102     const MachineFunction *MF;
  117     bool runOnMachineFunction(MachineFunction &Fn) override;
 1996 bool ARMLoadStoreOpt::runOnMachineFunction(MachineFunction &Fn) {
 2012   for (MachineFunction::iterator MFI = Fn.begin(), E = Fn.end(); MFI != E;
 2042     MachineFunction *MF;
 2046     bool runOnMachineFunction(MachineFunction &Fn) override;
 2083 bool ARMPreAllocLoadStoreOpt::runOnMachineFunction(MachineFunction &Fn) {

   37     MachineFunction           *MF = nullptr;
   53     bool runOnMachineFunction(MachineFunction &MF) override;
   89 bool ARMLowOverheadLoops::runOnMachineFunction(MachineFunction &mf) {

   16 ARMFunctionInfo::ARMFunctionInfo(MachineFunction &MF)

  141   explicit ARMFunctionInfo(MachineFunction &MF);

   27   bool runOnMachineFunction(MachineFunction &Fn) override;
   50 bool ARMOptimizeBarriersPass::runOnMachineFunction(MachineFunction &MF) {

  224   const MachineFunction &MF = *MI.getParent()->getParent();

  423 unsigned ARMSubtarget::getGPRAllocationOrder(const MachineFunction &MF) const {
  454 bool ARMSubtarget::ignoreCSRForAllocationOrder(const MachineFunction &MF,

  781   bool splitFramePushPop(const MachineFunction &MF) const {
  870   bool ignoreCSRForAllocationOrder(const MachineFunction &MF,
  872   unsigned getGPRAllocationOrder(const MachineFunction &MF) const;

   43     bool runOnMachineFunction(MachineFunction &Fn) override;
  286   const MachineFunction &MF = *MI->getParent()->getParent();
  370 bool MLxExpansion::runOnMachineFunction(MachineFunction &Fn) {

   45     bool runOnMachineFunction(MachineFunction &Fn) override;
  255 bool MVEVPTBlock::runOnMachineFunction(MachineFunction &Fn) {

   53 bool Thumb1FrameLowering::hasReservedCallFrame(const MachineFunction &MF) const{
   81     MachineFunction &MF = *MBB.getParent();
  145 void Thumb1FrameLowering::emitPrologue(MachineFunction &MF,
  470 void Thumb1FrameLowering::emitEpilogue(MachineFunction &MF,
  566 bool Thumb1FrameLowering::needPopSpecialFixUp(const MachineFunction &MF) const {
  602   MachineFunction &MF = *MBB.getParent();
  817   MachineFunction &MF = *MBB.getParent();
  938   MachineFunction &MF = *MBB.getParent();

   25   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   26   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   37   bool hasReservedCallFrame(const MachineFunction &MF) const override;
   52   bool enableShrinkWrapping(const MachineFunction &MF) const override {
   73   bool needPopSpecialFixUp(const MachineFunction &MF) const;

   43   MachineFunction &MF = *MBB.getParent();
   91     MachineFunction &MF = *MBB.getParent();
  120     MachineFunction &MF = *MBB.getParent();
  135   MachineFunction &MF = *MI->getParent()->getParent();

   54     bool runOnMachineFunction(MachineFunction &Fn) override;
  285 bool Thumb2ITBlock::runOnMachineFunction(MachineFunction &Fn) {

  142   MachineFunction &MF = *MBB.getParent();
  182   MachineFunction &MF = *MBB.getParent();
  223   MachineFunction &MF = *MI->getParent()->getParent();
  473   MachineFunction &MF = *MI.getParent()->getParent();

  168     bool runOnMachineFunction(MachineFunction &MF) override;
 1119 bool Thumb2SizeReduce::runOnMachineFunction(MachineFunction &MF) {
 1138   ReversePostOrderTraversal<MachineFunction*> RPOT(&MF);
 1140   for (ReversePostOrderTraversal<MachineFunction*>::rpo_iterator

   44                                               const MachineFunction &MF) const {
   54 ThumbRegisterInfo::getPointerRegClass(const MachineFunction &MF,
   67   MachineFunction &MF = *MBB.getParent();
   87   MachineFunction &MF = *MBB.getParent();
  107   MachineFunction &MF = *MBB.getParent();
  129   MachineFunction &MF = *MBB.getParent();
  432   const MachineFunction &MF = *MI.getParent()->getParent();
  455   MachineFunction &MF = *MBB.getParent();
  567 ThumbRegisterInfo::useFPForScavengingIndex(const MachineFunction &MF) const {

   31                             const MachineFunction &MF) const override;
   34   getPointerRegClass(const MachineFunction &MF,
   57   bool useFPForScavengingIndex(const MachineFunction &MF) const override;

   42   bool runOnMachineFunction(MachineFunction &MF) override;
  110 bool AVRExpandPseudo::runOnMachineFunction(MachineFunction &MF) {

   37     const MachineFunction &MF) const {
   43 bool AVRFrameLowering::hasReservedCallFrame(const MachineFunction &MF) const {
   53 void AVRFrameLowering::emitPrologue(MachineFunction &MF,
  119   for (MachineFunction::iterator I = std::next(MF.begin()), E = MF.end();
  144 void AVRFrameLowering::emitEpilogue(MachineFunction &MF,
  228 bool AVRFrameLowering::hasFP(const MachineFunction &MF) const {
  245   MachineFunction &MF = *MBB.getParent();
  285   const MachineFunction &MF = *MBB.getParent();
  416 void AVRFrameLowering::determineCalleeSaves(MachineFunction &MF,
  433   bool runOnMachineFunction(MachineFunction &MF) {
  501   bool runOnMachineFunction(MachineFunction &MF) {

   22   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   23   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   24   bool hasFP(const MachineFunction &MF) const override;
   34   bool hasReservedCallFrame(const MachineFunction &MF) const override;
   35   bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override;
   36   void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,

   36   bool runOnMachineFunction(MachineFunction &MF) override;
   59 bool AVRDAGToDAGISel::runOnMachineFunction(MachineFunction &MF) {

  669   const MachineFunction &MF = DAG.getMachineFunction();
 1053   MachineFunction &MF = DAG.getMachineFunction();
 1158   MachineFunction &MF = DAG.getMachineFunction();
 1358                                   MachineFunction &MF, bool isVarArg,
 1388   MachineFunction &MF = DAG.getMachineFunction();
 1441   MachineFunction *F = BB->getParent();
 1495   MachineFunction::iterator I;
 1635   MachineFunction *MF = MBB->getParent();
 1649   MachineFunction::iterator I;
 2010                                               const MachineFunction &MF) const {

  129                              const MachineFunction &MF) const override;
  152                       MachineFunction &MF, bool isVarArg,

  126   MachineFunction &MF = *MBB.getParent();
  169   MachineFunction &MF = *MBB.getParent();
  492     const MachineFunction &MF = *MI.getParent()->getParent();

   46   explicit AVRMachineFunctionInfo(MachineFunction &MF)

   36 AVRRegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const {
   45 AVRRegisterInfo::getCallPreservedMask(const MachineFunction &MF,
   52 BitVector AVRRegisterInfo::getReservedRegs(const MachineFunction &MF) const {
   84                                            const MachineFunction &MF) const {
  136   const MachineFunction &MF = *MBB.getParent();
  248 Register AVRRegisterInfo::getFrameRegister(const MachineFunction &MF) const {
  259 AVRRegisterInfo::getPointerRegClass(const MachineFunction &MF,

   30   getCalleeSavedRegs(const MachineFunction *MF = 0) const override;
   31   const uint32_t *getCallPreservedMask(const MachineFunction &MF,
   33   BitVector getReservedRegs(const MachineFunction &MF) const override;
   37                             const MachineFunction &MF) const override;
   44   Register getFrameRegister(const MachineFunction &MF) const override;
   47   getPointerRegClass(const MachineFunction &MF,
   54   bool trackLivenessAfterRegAlloc(const MachineFunction &) const override {

   38   bool runOnMachineFunction(MachineFunction &MF) override;
   60 bool AVRRelaxMem::runOnMachineFunction(MachineFunction &MF) {

   23 bool BPFFrameLowering::hasFP(const MachineFunction &MF) const { return true; }
   25 void BPFFrameLowering::emitPrologue(MachineFunction &MF,
   28 void BPFFrameLowering::emitEpilogue(MachineFunction &MF,
   31 void BPFFrameLowering::determineCalleeSaves(MachineFunction &MF,

   26   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   27   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   29   bool hasFP(const MachineFunction &MF) const override;
   30   void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,

   54   bool runOnMachineFunction(MachineFunction &MF) override {

   40   MachineFunction &MF = DAG.getMachineFunction();
   47   MachineFunction &MF = DAG.getMachineFunction();
  218   MachineFunction &MF = DAG.getMachineFunction();
  286   MachineFunction &MF = DAG.getMachineFunction();
  416   MachineFunction &MF = DAG.getMachineFunction();
  459   MachineFunction &MF = DAG.getMachineFunction();
  569   MachineFunction *F = BB->getParent();
  589   MachineFunction *MF = MI.getParent()->getParent();
  653   MachineFunction::iterator I = ++BB->getIterator();
  661   MachineFunction *F = BB->getParent();

   33   MachineFunction *MF;
   42   void initialize(MachineFunction &MFParm);
   49   bool runOnMachineFunction(MachineFunction &MF) override {
   59 void BPFMIPreEmitChecking::initialize(MachineFunction &MFParm) {

   43   MachineFunction *MF;
   52   void initialize(MachineFunction &MFParm);
   60   bool runOnMachineFunction(MachineFunction &MF) override {
   71 void BPFMIPeephole::initialize(MachineFunction &MFParm) {
  203   MachineFunction *MF;
  212   void initialize(MachineFunction &MFParm);
  219   bool runOnMachineFunction(MachineFunction &MF) override {
  230 void BPFMIPreEmitPeephole::initialize(MachineFunction &MFParm) {
  299   MachineFunction *MF;
  308   void initialize(MachineFunction &MFParm);
  315   bool runOnMachineFunction(MachineFunction &MF) override {
  340 void BPFMIPeepholeTruncElim::initialize(MachineFunction &MFParm) {

   45   MachineFunction *MF;
   53   void initialize(MachineFunction &MFParm);
   59   bool runOnMachineFunction(MachineFunction &MF) override {
   68 void BPFMISimplifyPatchable::initialize(MachineFunction &MFParm) {