Line data    Source code

       1             : //===-- MachineFunctionPass.h - Pass for MachineFunctions --------*-C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file defines the MachineFunctionPass class.  MachineFunctionPass's are
      11             : // just FunctionPass's, except they operate on machine code as part of a code
      12             : // generator.  Because they operate on machine code, not the LLVM
      13             : // representation, MachineFunctionPass's are not allowed to modify the LLVM
      14             : // representation.  Due to this limitation, the MachineFunctionPass class takes
      15             : // care of declaring that no LLVM passes are invalidated.
      16             : //
      17             : //===----------------------------------------------------------------------===//
      18             : 
      19             : #ifndef LLVM_CODEGEN_MACHINEFUNCTIONPASS_H
      20             : #define LLVM_CODEGEN_MACHINEFUNCTIONPASS_H
      21             : 
      22             : #include "llvm/CodeGen/MachineFunction.h"
      23             : #include "llvm/Pass.h"
      24             : 
      25             : namespace llvm {
      26             : 
      27             : /// MachineFunctionPass - This class adapts the FunctionPass interface to
      28             : /// allow convenient creation of passes that operate on the MachineFunction
      29             : /// representation. Instead of overriding runOnFunction, subclasses
      30             : /// override runOnMachineFunction.
      31             : class MachineFunctionPass : public FunctionPass {
      32             : public:
      33     2286234 :   bool doInitialization(Module&) override {
      34             :     // Cache the properties info at module-init time so we don't have to
      35             :     // construct them for every function.
      36     2286234 :     RequiredProperties = getRequiredProperties();
      37     2286225 :     SetProperties = getSetProperties();
      38     2286228 :     ClearedProperties = getClearedProperties();
      39     2286232 :     return false;
      40             :   }
      41             : protected:
      42     5492824 :   explicit MachineFunctionPass(char &ID) : FunctionPass(ID) {}
      43             : 
      44             :   /// runOnMachineFunction - This method must be overloaded to perform the
      45             :   /// desired machine code transformation or analysis.
      46             :   ///
      47             :   virtual bool runOnMachineFunction(MachineFunction &MF) = 0;
      48             : 
      49             :   /// getAnalysisUsage - Subclasses that override getAnalysisUsage
      50             :   /// must call this.
      51             :   ///
      52             :   /// For MachineFunctionPasses, calling AU.preservesCFG() indicates that
      53             :   /// the pass does not modify the MachineBasicBlock CFG.
      54             :   ///
      55             :   void getAnalysisUsage(AnalysisUsage &AU) const override;
      56             : 
      57     1901181 :   virtual MachineFunctionProperties getRequiredProperties() const {
      58     1901181 :     return MachineFunctionProperties();
      59             :   }
      60     2258590 :   virtual MachineFunctionProperties getSetProperties() const {
      61     2258590 :     return MachineFunctionProperties();
      62             :   }
      63     2286239 :   virtual MachineFunctionProperties getClearedProperties() const {
      64     2286239 :     return MachineFunctionProperties();
      65             :   }
      66             : 
      67             : private:
      68             :   MachineFunctionProperties RequiredProperties;
      69             :   MachineFunctionProperties SetProperties;
      70             :   MachineFunctionProperties ClearedProperties;
      71             : 
      72             :   /// createPrinterPass - Get a machine function printer pass.
      73             :   Pass *createPrinterPass(raw_ostream &O,
      74             :                           const std::string &Banner) const override;
      75             : 
      76             :   bool runOnFunction(Function &F) override;
      77             : };
      78             : 
      79             : } // End llvm namespace
      80             : 
      81             : #endif