From 89e9ed379569528f75a29f2367fccc06a39fe201 Mon Sep 17 00:00:00 2001 From: Devang Patel Date: Mon, 15 Sep 2008 21:13:42 +0000 Subject: [PATCH] Extract optimization pass selection code from llvm-gcc into a separate routine. This can be used by other stand alone tools, such as 'opt'. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@56229 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/PassManagerUtils.h | 36 +++++++++++ utils/PassManagerUtils.cpp | 108 ++++++++++++++++++++++++++++++++ 2 files changed, 144 insertions(+) create mode 100644 include/llvm/PassManagerUtils.h create mode 100644 utils/PassManagerUtils.cpp diff --git a/include/llvm/PassManagerUtils.h b/include/llvm/PassManagerUtils.h new file mode 100644 index 00000000000..8d34c358efd --- /dev/null +++ b/include/llvm/PassManagerUtils.h @@ -0,0 +1,36 @@ +//===-- llvm/Support/PassManagerUtils.h -------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file provides interface to pass manager utilities. +// +//===----------------------------------------------------------------------===// + +namespace llvm { + +class FunctionPassManager; +class PassManager; + +/// AddOptimizationPasses - This routine adds optimization passes +/// based on selected optimization level, OptLevel. This routine is +/// used by llvm-gcc and other tools. +/// +/// OptLevel - Optimization Level +/// EnableIPO - Enables IPO passes. llvm-gcc enables this when +/// flag_unit_at_a_time is set. +/// InlinerSelection - 1 : Add function inliner. +/// - 2 : Add AlwaysInliner. +/// OptLibCalls - Simplify lib calls, if set. +/// PruneEH - Add PruneEHPass, if set. +/// UnrollLoop - Unroll loops, if set. +void AddOptimizationPasses(FunctionPassManager &FPM, PassManager &MPM, + unsigned OptLevel, bool EnableIPO, + unsigned InlinerSelection, bool OptLibCalls, + bool PruneEH, bool UnrollLoop); + +} diff --git a/utils/PassManagerUtils.cpp b/utils/PassManagerUtils.cpp new file mode 100644 index 00000000000..76d38b9ae79 --- /dev/null +++ b/utils/PassManagerUtils.cpp @@ -0,0 +1,108 @@ +//===-- PassManagerUtils.cpp - --------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This file implements pass manager utiliy routines. +// +//===----------------------------------------------------------------------===// + +#include "llvm/PassManagerUtils.h" +#include "llvm/PassManagers.h" +#include "llvm/Transforms/Scalar.h" +#include "llvm/Transforms/IPO.h" +#include "llvm/Analysis/LoopPass.h" + +/// AddOptimizationPasses - This routine adds optimization passes +/// based on selected optimization level, OptLevel. This routine is +/// used by llvm-gcc and other tools. +/// +/// OptLevel - Optimization Level +/// EnableIPO - Enables IPO passes. llvm-gcc enables this when +/// flag_unit_at_a_time is set. +/// InlinerSelection - 1 : Add function inliner. +/// - 2 : Add AlwaysInliner. +/// OptLibCalls - Simplify lib calls, if set. +/// PruneEH - Add PruneEHPass, if set. +/// UnrollLoop - Unroll loops, if set. +void llvm::AddOptimizationPasses(FunctionPassManager &FPM, PassManager &MPM, + unsigned OptLevel, bool EnableIPO, + unsigned InlinerSelection, bool OptLibCalls, + bool PruneEH, bool UnrollLoop) { + if (OptLevel == 0) + return; + + FPM.add(createCFGSimplificationPass()); + if (OptLevel == 1) + FPM.add(createPromoteMemoryToRegisterPass()); + else + FPM.add(createScalarReplAggregatesPass()); + FPM.add(createInstructionCombiningPass()); + + if (EnableIPO) + MPM.add(createRaiseAllocationsPass()); // call %malloc -> malloc inst + MPM.add(createCFGSimplificationPass()); // Clean up disgusting code + MPM.add(createPromoteMemoryToRegisterPass()); // Kill useless allocas + if (EnableIPO) { + MPM.add(createGlobalOptimizerPass()); // OptLevel out global vars + MPM.add(createGlobalDCEPass()); // Remove unused fns and globs + MPM.add(createIPConstantPropagationPass()); // IP Constant Propagation + MPM.add(createDeadArgEliminationPass()); // Dead argument elimination + } + MPM.add(createInstructionCombiningPass()); // Clean up after IPCP & DAE + MPM.add(createCFGSimplificationPass()); // Clean up after IPCP & DAE + if (EnableIPO && PruneEH) + MPM.add(createPruneEHPass()); // Remove dead EH info + if (InlinerSelection == 1) // respect -fno-inline-functions + MPM.add(createFunctionInliningPass()); // Inline small functions + else if (InlinerSelection == 2) + MPM.add(createAlwaysInlinerPass()); // Inline always_inline functions + if (OptLevel > 2) + MPM.add(createArgumentPromotionPass()); // Scalarize uninlined fn args + if (OptLibCalls) + MPM.add(createSimplifyLibCallsPass()); // Library Call Optimizations + MPM.add(createInstructionCombiningPass()); // Cleanup for scalarrepl. + MPM.add(createJumpThreadingPass()); // Thread jumps. + MPM.add(createCFGSimplificationPass()); // Merge & remove BBs + MPM.add(createScalarReplAggregatesPass()); // Break up aggregate allocas + MPM.add(createInstructionCombiningPass()); // Combine silly seq's + MPM.add(createCondPropagationPass()); // Propagate conditionals + MPM.add(createTailCallEliminationPass()); // Eliminate tail calls + MPM.add(createCFGSimplificationPass()); // Merge & remove BBs + MPM.add(createReassociatePass()); // Reassociate expressions + MPM.add(createLoopRotatePass()); // Rotate Loop + MPM.add(createLICMPass()); // Hoist loop invariants + MPM.add(createLoopUnswitchPass()); + MPM.add(createLoopIndexSplitPass()); // Split loop index + MPM.add(createInstructionCombiningPass()); + MPM.add(createIndVarSimplifyPass()); // Canonicalize indvars + MPM.add(createLoopDeletionPass()); // Delete dead loops + if (UnrollLoop) + MPM.add(createLoopUnrollPass()); // Unroll small loops + MPM.add(createInstructionCombiningPass()); // Clean up after the unroller + MPM.add(createGVNPass()); // Remove redundancies + MPM.add(createMemCpyOptPass()); // Remove memcpy / form memset + MPM.add(createSCCPPass()); // Constant prop with SCCP + + // Run instcombine after redundancy elimination to exploit opportunities + // opened up by them. + MPM.add(createInstructionCombiningPass()); + MPM.add(createCondPropagationPass()); // Propagate conditionals + MPM.add(createDeadStoreEliminationPass()); // Delete dead stores + MPM.add(createAggressiveDCEPass()); // Delete dead instructions + MPM.add(createCFGSimplificationPass()); // Merge & remove BBs + + if (EnableIPO) { + MPM.add(createStripDeadPrototypesPass()); // Get rid of dead prototypes + MPM.add(createDeadTypeEliminationPass()); // Eliminate dead types + } + + if (OptLevel > 1 && EnableIPO) + MPM.add(createConstantMergePass()); // Merge dup global constants + + return; +} -- 2.34.1