Members/tobaru/cbc/CbC_llvm: include/llvm/CodeGen/Passes.h comparison

comparison include/llvm/CodeGen/Passes.h @ 85:5e5d649e25d2

Update LLVM 3.7

author	Tatsuki IHA <e125716@ie.u-ryukyu.ac.jp>
date	Thu, 19 Feb 2015 15:19:25 +0900
parents	67baa08a3894 60c9769439b8
children	b0dd3743370f

comparison

equal deleted inserted replaced

-:e218c19a8176
+:5e5d649e25d2
 PassManagerBase *PM;
 AnalysisID StartAfter;
 AnalysisID StopAfter;
 bool Started;
 bool Stopped;
+bool AddingMachinePasses;
 protected:
 TargetMachine *TM;
 PassConfigImpl *Impl; // Internal data structures
 bool Initialized;     // Flagged after all passes are configured.
 IdentifyingPassPtr getPassSubstitution(AnalysisID StandardID) const;
 /// Return true if the optimized regalloc pipeline is enabled.
 bool getOptimizeRegAlloc() const;
+/// Return true if the default global register allocator is in use and
+/// has not be overriden on the command line with '-regalloc=...'
+bool usingDefaultRegAlloc() const;
 /// Add common target configurable passes that perform LLVM IR to IR
 /// transforms following machine independent optimization.
 virtual void addIRPasses();
 /// Add passes to lower exception handling for the code generator.
 /// MachineScheduler pass for this function and target at the current
 /// optimization level.
 ///
 /// This can also be used to plug a new MachineSchedStrategy into an instance
 /// of the standard ScheduleDAGMI:
-///   return new ScheduleDAGMI(C, new MyStrategy(C))
+///   return new ScheduleDAGMI(C, make_unique<MyStrategy>(C), /* IsPostRA= */false)
 ///
 /// Return NULL to select the default (generic) machine scheduler.
 virtual ScheduleDAGInstrs *
 createMachineScheduler(MachineSchedContext *C) const {
 return nullptr;
 /// MachineLoopInfo, and MachineTraceMetrics analyses.
 virtual bool addILPOpts() {
 return false;
 }
-/// addPreRegAlloc - This method may be implemented by targets that want to
+/// This method may be implemented by targets that want to run passes
-/// run passes immediately before register allocation. This should return
+/// immediately before register allocation.
-/// true if -print-machineinstrs should print after these passes.
+virtual void addPreRegAlloc() { }
-virtual bool addPreRegAlloc() {
-return false;
-}
 /// createTargetRegisterAllocator - Create the register allocator pass for
 /// this target at the current optimization level.
 virtual FunctionPass *createTargetRegisterAllocator(bool Optimized);
 /// all virtual registers.
 virtual bool addPreRewrite() {
 return false;
 }
-/// addPostRegAlloc - This method may be implemented by targets that want to
+/// This method may be implemented by targets that want to run passes after
-/// run passes after register allocation pass pipeline but before
+/// register allocation pass pipeline but before prolog-epilog insertion.
-/// prolog-epilog insertion.  This should return true if -print-machineinstrs
+virtual void addPostRegAlloc() { }
-/// should print after these passes.
-virtual bool addPostRegAlloc() {
-return false;
-}
 /// Add passes that optimize machine instructions after register allocation.
 virtual void addMachineLateOptimization();
-/// addPreSched2 - This method may be implemented by targets that want to
+/// This method may be implemented by targets that want to run passes after
-/// run passes after prolog-epilog insertion and before the second instruction
+/// prolog-epilog insertion and before the second instruction scheduling pass.
-/// scheduling pass.  This should return true if -print-machineinstrs should
+virtual void addPreSched2() { }
-/// print after these passes.
-virtual bool addPreSched2() {
-return false;
-}
 /// addGCPasses - Add late codegen passes that analyze code for garbage
 /// collection. This should return true if GC info should be printed after
 /// these passes.
 virtual bool addGCPasses();
 /// Add standard basic block placement passes.
 virtual void addBlockPlacement();
-/// addPreEmitPass - This pass may be implemented by targets that want to run
+/// This pass may be implemented by targets that want to run passes
-/// passes immediately before machine code is emitted.  This should return
+/// immediately before machine code is emitted.
-/// true if -print-machineinstrs should print out the code after the passes.
+virtual void addPreEmitPass() { }
-virtual bool addPreEmitPass() {
-return false;
-}
 /// Utilities for targets to add passes to the pass manager.
 ///
 /// Add a CodeGen pass at this point in the pipeline after checking overrides.
 /// Return the pass that was added, or zero if no pass was added.
-AnalysisID addPass(AnalysisID PassID);
+/// @p printAfter    if true and adding a machine function pass add an extra
+///                  machine printer pass afterwards
+/// @p verifyAfter   if true and adding a machine function pass add an extra
+///                  machine verification pass afterwards.
+AnalysisID addPass(AnalysisID PassID, bool verifyAfter = true,
+bool printAfter = true);
 /// Add a pass to the PassManager if that pass is supposed to be run, as
 /// determined by the StartAfter and StopAfter options. Takes ownership of the
 /// pass.
-void addPass(Pass *P);
+/// @p printAfter    if true and adding a machine function pass add an extra
+///                  machine printer pass afterwards
+/// @p verifyAfter   if true and adding a machine function pass add an extra
+///                  machine verification pass afterwards.
+void addPass(Pass *P, bool verifyAfter = true, bool printAfter = true);
 /// addMachinePasses helper to create the target-selected or overriden
 /// regalloc pass.
 FunctionPass *createRegAllocPass(bool Optimized);
 /// printAndVerify - Add a pass to dump then verify the machine function, if
 /// those steps are enabled.
 ///
-void printAndVerify(const char *Banner);
+void printAndVerify(const std::string &Banner);
+/// Add a pass to print the machine function if printing is enabled.
+void addPrintPass(const std::string &Banner);
+/// Add a pass to perform basic verification of the machine function if
+/// verification is enabled.
+void addVerifyPass(const std::string &Banner);
 };
 } // namespace llvm
 /// List of target independent CodeGen pass IDs.
 namespace llvm {
 FunctionPass *createAtomicExpandPass(const TargetMachine *TM);
-/// \brief Create a basic TargetTransformInfo analysis pass.
-///
-/// This pass implements the target transform info analysis using the target
-/// independent information available to the LLVM code generator.
-ImmutablePass *
-createBasicTargetTransformInfoPass(const TargetMachine *TM);
 /// createUnreachableBlockEliminationPass - The LLVM code generator does not
 /// work well with unreachable basic blocks (what live ranges make sense for a
 /// block that cannot be reached?).  As such, a code generator should either
 /// not instruction select unreachable blocks, or run this pass as its
 /// MachineBlockPlacementStats - This pass collects statistics about the
 /// basic block placement using branch probabilities and block frequency
 /// information.
 extern char &MachineBlockPlacementStatsID;
-/// GCLowering Pass - Performs target-independent LLVM IR transformations for
+/// GCLowering Pass - Used by gc.root to perform its default lowering
-/// highly portable strategies.
+/// operations.
-///
 FunctionPass *createGCLoweringPass();
+/// ShadowStackGCLowering - Implements the custom lowering mechanism
+/// used by the shadow stack GC.  Only runs on functions which opt in to
+/// the shadow stack collector.
+FunctionPass *createShadowStackGCLoweringPass();
 /// GCMachineCodeAnalysis - Target-independent pass to mark safe points
 /// in machine code. Must be added very late during code generation, just
 /// prior to output, and importantly after all CFG transformations (such as
 /// branch folding).
 FunctionPass *createStackProtectorPass(const TargetMachine *TM);
 /// createMachineVerifierPass - This pass verifies cenerated machine code
 /// instructions for correctness.
 ///
-FunctionPass *createMachineVerifierPass(const char *Banner = nullptr);
+FunctionPass *createMachineVerifierPass(const std::string& Banner);
 /// createDwarfEHPass - This pass mulches exception handling code into a form
 /// adapted to code generation.  Required if using dwarf exception handling.
 FunctionPass *createDwarfEHPass(const TargetMachine *TM);
+/// createWinEHPass - Prepares personality functions used by MSVC on Windows,
+/// in addition to the Itanium LSDA based personalities.
+FunctionPass *createWinEHPass(const TargetMachine *TM);
 /// createSjLjEHPreparePass - This pass adapts exception handling code to use
 /// the GCC-style builtin setjmp/longjmp (sjlj) to handling EH control flow.
 ///
 FunctionPass *createSjLjEHPreparePass(const TargetMachine *TM);
 /// the intrinsic for later emission to the StackMap.
 extern char &StackMapLivenessID;
 /// createJumpInstrTables - This pass creates jump-instruction tables.
 ModulePass *createJumpInstrTablesPass();
+/// createForwardControlFlowIntegrityPass - This pass adds control-flow
+/// integrity.
+ModulePass *createForwardControlFlowIntegrityPass();
 } // End llvm namespace
 /// This initializer registers TargetMachine constructor, so the pass being
 /// initialized can use target dependent interfaces. Please do not move this
 /// macro to be together with INITIALIZE_PASS, which is a complete target

Mercurial > hg > Members > tobaru > cbc > CbC_llvm

comparison include/llvm/CodeGen/Passes.h @ 85:5e5d649e25d2