include/llvm/CodeGen/Passes.h

   1 //===-- Passes.h - Target independent code generation passes ----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines interfaces to access the target independent code generation
  11 // passes provided by the LLVM backend.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CODEGEN_PASSES_H
  16 #define LLVM_CODEGEN_PASSES_H
  17
  18 #include <iosfwd>
  19 #include <string>
  20
  21 namespace llvm {
  22
  23   class FunctionPass;
  24   class PassInfo;
  25   class TargetMachine;
  26
  27   /// createUnreachableBlockEliminationPass - The LLVM code generator does not
  28   /// work well with unreachable basic blocks (what live ranges make sense for a
  29   /// block that cannot be reached?).  As such, a code generator should either
  30   /// not instruction select unreachable blocks, or it can run this pass as it's
  31   /// last LLVM modifying pass to clean up blocks that are not reachable from
  32   /// the entry block.
  33   FunctionPass *createUnreachableBlockEliminationPass();
  34
  35   /// MachineFunctionPrinter pass - This pass prints out the machine function to
  36   /// standard error, as a debugging tool.
  37   FunctionPass *createMachineFunctionPrinterPass(std::ostream *OS,
  38                                                  const std::string &Banner ="");
  39
  40   /// PHIElimination pass - This pass eliminates machine instruction PHI nodes
  41   /// by inserting copy instructions.  This destroys SSA information, but is the
  42   /// desired input for some register allocators.  This pass is "required" by
  43   /// these register allocator like this: AU.addRequiredID(PHIEliminationID);
  44   ///
  45   extern const PassInfo *PHIEliminationID;
  46
  47   /// TwoAddressInstruction pass - This pass reduces two-address instructions to
  48   /// use two operands. This destroys SSA information but it is desired by
  49   /// register allocators.
  50   extern const PassInfo *TwoAddressInstructionPassID;
  51
  52   /// Creates a register allocator as the user specified on the command line.
  53   ///
  54   FunctionPass *createRegisterAllocator();
  55
  56   /// SimpleRegisterAllocation Pass - This pass converts the input machine code
  57   /// from SSA form to use explicit registers by spilling every register.  Wow,
  58   /// great policy huh?
  59   ///
  60   FunctionPass *createSimpleRegisterAllocator();
  61
  62   /// LocalRegisterAllocation Pass - This pass register allocates the input code
  63   /// a basic block at a time, yielding code better than the simple register
  64   /// allocator, but not as good as a global allocator.
  65   ///
  66   FunctionPass *createLocalRegisterAllocator();
  67
  68   /// LinearScanRegisterAllocation Pass - This pass implements the linear scan
  69   /// register allocation algorithm, a global register allocator.
  70   ///
  71   FunctionPass *createLinearScanRegisterAllocator();
  72
  73   /// PriorityBasedGraphColoringRegisterAllocator Pass - This pass implements
  74   /// the priority-based graph coloring register allocator by Chow & Hennessey,
  75   /// a global register allocator.
  76   FunctionPass *createGraphColoringRegisterAllocator();
  77
  78   /// PrologEpilogCodeInserter Pass - This pass inserts prolog and epilog code,
  79   /// and eliminates abstract frame references.
  80   ///
  81   FunctionPass *createPrologEpilogCodeInserter();
  82
  83   /// BranchFolding Pass - This pass performs machine code CFG based
  84   /// optimizations to delete branches to branches, eliminate branches to
  85   /// successor blocks (creating fall throughs), and eliminating branches over
  86   /// branches.
  87   FunctionPass *createBranchFoldingPass();
  88
  89   /// DebugLabelFoldingPass - This pass prunes out redundant debug labels.  This
  90   /// allows a debug emitter to determine if the range of two labels is empty,
  91   /// by seeing if the labels map to the same reduced label.
  92   FunctionPass *createDebugLabelFoldingPass();
  93
  94   /// MachineCodeDeletion Pass - This pass deletes all of the machine code for
  95   /// the current function, which should happen after the function has been
  96   /// emitted to a .s file or to memory.
  97   FunctionPass *createMachineCodeDeleter();
  98
  99   /// getRegisterAllocator - This creates an instance of the register allocator
 100   /// for the Sparc.
 101   FunctionPass *getRegisterAllocator(TargetMachine &T);
 102
 103   //createModuloSchedulingPass - Creates the Swing Modulo Scheduling Pass
 104   FunctionPass *createModuloSchedulingPass(TargetMachine & targ);
 105
 106   //createModuloSchedulingPass - Creates the Swing Modulo Scheduling Pass
 107   FunctionPass *createModuloSchedulingSBPass(TargetMachine & targ);
 108
 109 } // End llvm namespace
 110
 111 #endif