//===--- Passes.def - Swift SILPass Metaprogramming -------------*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file defines macros used for macro-metaprogramming with SILPasses.
//
//===----------------------------------------------------------------------===//

/// PASS(Id, Name, Description)
///   The pass is identified by PassKind::Id, and there exists a
///   global function swift::create##Id().
///
///   This macro must be defined by the includer.
#ifndef PASS
#error "Macro must be defined by includer"
#endif

/// IRGEN_PASS(Id, Name, Description)
///   The pass is identified by PassKind::Id.
///   An IRGen pass is created by IRGen and needs to be register with the pass
///   manager dynamically.
#ifndef IRGEN_PASS
#define IRGEN_PASS(Id, Name, Description) PASS(Id, Name, Description)
#endif

/// PASS_RANGE(RANGE_ID, START, END)
///   Pass IDs between PassKind::START and PassKind::END, inclusive,
///   fall within the set known as
#ifndef PASS_RANGE
#define PASS_RANGE(Id, First, Last)
#endif

PASS(AADumper, "aa-dump",
     "Dump AA result for all pairs of ValueKinds in all functions")
PASS(ABCOpt, "abcopts",
     "Optimization of array bounds checks")
PASS(AddressLowering, "address-lowering",
     "SIL AddressOnly lowering.")
PASS(AllocBoxToStack, "allocbox-to-stack",
     "Promote heap allocations to stack allocations")
IRGEN_PASS(AllocStackHoisting, "alloc-stack-hoisting",
           "Hoist generic alloc_stack instructions to the entry block")
PASS(ArrayCountPropagation, "array-count-propagation",
     "Propagate the count of arrays")
PASS(ArrayElementPropagation, "array-element-propagation",
     "Propagate the value of array elements")
PASS(AssumeSingleThreaded, "sil-assume-single-threaded",
     "Assume that code will be executed in a single-threaded environment")
PASS(BasicInstructionPropertyDumper, "basic-instruction-property-dump",
     "Dump MemBehavior and ReleaseBehavior results from calling "
     "SILInstruction::{getMemoryBehavior,getReleasingBehavior}()"
     " on all instructions")
PASS(BasicCalleePrinter, "basic-callee-printer",
     "Construct basic callee analysis and use it to print callees "
     "for testing purposes")
PASS(CFGPrinter, "view-cfg",
     "View the CFG of all passed in functions")
PASS(COWArrayOpts, "cowarray-opt",
     "COW Array optimizations")
PASS(CSE, "cse",
     "Common subexpression elimination")
PASS(CallerAnalysisPrinter, "caller-analysis-printer",
     "Print callsites of every function in the module")
PASS(CapturePromotion, "capture-promotion",
     "Promote captures from by-reference to by-value")
PASS(CapturePropagation, "capture-prop",
     "Captured Constant Propagation")
PASS(ClosureSpecializer, "closure-specialize",
     "Specialize functions passed a closure to call the closure directly")
PASS(CodeSinking, "code-sinking",
     "Sinks code closer to users")
PASS(ComputeDominanceInfo, "compute-dominance-info",
     "Utility pass that computes (post-)dominance info for all functions in "
     "order to help test dominanceinfo updating")
PASS(ComputeLoopInfo, "compute-loop-info",
     "Utility pass that computes loop info for all functions in order to help "
     "test loop info updating")
PASS(ConditionForwarding, "condition-forwarding",
     "Forward conditional branch instructions")
PASS(CopyForwarding, "copy-forwarding",
     "Eliminate redundant copies")
PASS(EpilogueARCMatcherDumper, "sil-epilogue-arc-dumper",
     "Dump epilogue retains for return value and releases for arguments")
PASS(EpilogueRetainReleaseMatcherDumper, "sil-epilogue-retain-release-dumper",
     "Dump epilogue retains for return value and releases for arguments")
PASS(RedundantOverflowCheckRemoval, "remove-redundant-overflow-checks",
     "Removes redundant overflow checks")
PASS(DCE, "dce",
     "Eliminate dead code")
PASS(DeadArgSignatureOpt, "dead-arg-signature-opt",
     "Create function with removed dead arguments")
PASS(DeadFunctionElimination, "sil-deadfuncelim",
     "Remove unused functions")
PASS(DeadObjectElimination, "deadobject-elim",
     "Eliminate unused objects that do not have destructors with side effects")
PASS(DefiniteInitialization, "definite-init",
     "Definite Initialization")
PASS(Devirtualizer, "devirtualizer", "Devirtualize indirect calls")
PASS(DiagnoseUnreachable, "diagnose-unreachable",
     "Diagnose Unreachable Code")
PASS(DiagnosticConstantPropagation, "diagnostic-constant-propagation",
     "Propagate constants and emit diagnostics")
PASS(EagerSpecializer, "eager-specializer",
     "Specialize speculatively and insert dispatch guarded by type checks")
PASS(EarlyCodeMotion, "early-codemotion",
     "Code motion without release hoisting")
PASS(EarlyInliner, "early-inline",
     "Inline functions that are not marked as having special semantics")
PASS(EmitDFDiagnostics, "dataflow-diagnostics",
     "Emit SIL Diagnostics")
PASS(EscapeAnalysisDumper, "escapes-dump",
     "Dumps the results of escape analysis for all functions")
PASS(ExternalDefsToDecls, "external-defs-to-decls",
     "Convert external definitions to decls")
PASS(ExternalFunctionDefinitionsElimination, "external-func-definition-elim",
     "Eliminate external function definitions")
PASS(FunctionOrderPrinter, "function-order-printer",
     "Print function orderings for test purposes")
PASS(FunctionSignatureOpts, "function-signature-opts",
     "Create function with optimized signatures")
PASS(ARCSequenceOpts, "arc-sequence-opts",
     "Optimize sequences of retain/release opts by removing redundant inner "
     "retain/release sequences")
PASS(ARCLoopOpts, "arc-loop-opts",
     "Run all arc loop passes")
PASS(RedundantLoadElimination, "redundant-load-elim",
     "Multiple basic block redundant load elimination")
PASS(DeadStoreElimination, "dead-store-elim",
     "Multiple basic block dead store elimination")
PASS(GenericSpecializer, "generic-specializer",
     "Specialization of generic functions by static types")
PASS(GlobalOpt, "global-opt",
     "Global variable optimizations")
PASS(GlobalPropertyOpt, "global-property-opt",
     "Optimize properties")
PASS(GuaranteedARCOpts, "guaranteed-arc-opts",
     "Guaranteed ARC optimizations")
PASS(HighLevelCSE, "high-level-cse",
     "Common subexpression elimination on High-level SIL")
PASS(HighLevelLICM, "high-level-licm",
     "High Level Loop invariant code motion")
PASS(IVInfoPrinter, "iv-info-printer",
     "Display induction variable information")
PASS(InstCount, "inst-count",
     "Count all instructions in the module using llvm Statistics")
PASS(JumpThreadSimplifyCFG, "simplify-cfg",
     "Clean up the CFG of SIL functions")
PASS(LetPropertiesOpt, "let-properties-opt",
     "SIL let properties optimization")
PASS(LICM, "licm",
     "Loop invariant code motion")
PASS(LateCodeMotion, "late-codemotion",
     "Code motion with release hoisting")
PASS(LateInliner, "late-inline",
     "Run the late inliner")
PASS(LoopCanonicalizer, "loop-canonicalizer",
     "Canonicalize loops")
PASS(LoopInfoPrinter, "loop-info-printer",
     "Display loop information")
PASS(LoopRegionViewText, "loop-region-view-text",
     "Construct the loop region data structure and dump its contents as text")
PASS(LoopRegionViewCFG, "loop-region-view-cfg",
     "Construct the loop region data structure and dump its contents as a pdf cfg")
PASS(LoopRotate, "loop-rotate",
     "Rotate loops")
PASS(LoopUnroll, "loop-unroll",
     "Unroll loops")
PASS(LowerAggregateInstrs, "lower-aggregate-instrs",
     "Lower aggregate instructions to scalar instructions")
PASS(MandatoryInlining, "mandatory-inlining",
     "Inline transparent functions")
PASS(Mem2Reg, "mem2reg",
     "Promote stack allocations to SSA values")
PASS(MemBehaviorDumper, "mem-behavior-dump",
     "Dump MemBehavior results from alias analysis for all instruction pairs")
PASS(LSLocationPrinter, "lslocation-dump",
     "Dump LSLocation results from analyzing all accessed locations")
PASS(MergeCondFails, "merge-cond_fails",
     "Remove redundant overflow checks")
PASS(MoveCondFailToPreds, "move-cond-fail-to-preds",
     "Test pass that hoists conditional fails to predecessors blocks when "
     "profitable")
PASS(NoReturnFolding, "noreturn-folding",
     "Add 'unreachable' after noreturn calls")
PASS(OwnershipModelEliminator, "ownership-model-eliminator",
     "Eliminate SIL ownership constructs that are not supported by the whole"
     " compiler from the IR")
PASS(RCIdentityDumper, "rc-id-dumper",
     "Dump the RCIdentity of all values in a function")
// TODO: It makes no sense to have early inliner, late inliner, and
// perf inliner in terms of names.
PASS(PerfInliner, "inline",
     "Inline functions which are determined to be less than a pre-set cost")
PASS(PerformanceConstantPropagation, "performance-constant-propagation",
     "Propagate constants and do not emit diagnostics")
PASS(PredictableMemoryOptimizations, "predictable-memopt",
     "Predictable early memory optimizations")
PASS(ReleaseDevirtualizer, "release-devirtualizer",
     "Devirtualize release-instructions")
PASS(RetainSinking, "retain-sinking",
     "Sink retains")
PASS(ReleaseHoisting, "release-hoisting",
     "Hoist releases")
PASS(LateReleaseHoisting, "late-release-hoisting",
     "Hoist releases")
PASS(RemovePins, "remove-pins",
     "Remove pin/unpin pairs")
PASS(SideEffectsDumper, "side-effects-dump",
     "Dumps the results of side-effect analysis for all functions")
PASS(SILCleanup, "cleanup",
     "Cleanup SIL in preparation for IRGen")
PASS(SILCombine, "sil-combine",
     "Perform small peepholes and combine operations")
PASS(SILDebugInfoGenerator, "sil-debuginfo-gen",
     "Write a SIL file for debugging")
PASS(SILLinker, "linker",
     "Link in all of the serialized SIL referenced in the module")
PASS(SROA, "sroa",
     "SIL scalar replacement of aggregates")
PASS(SROABBArgs, "sroa-bb-args",
     "SIL scalar replacement of aggregates of bb arguments")
PASS(SimplifyBBArgs, "simplify-bb-args",
     "Simplify basic block arguments")
// TODO: What should this be called. We are just following what was previously in SILOpt.
PASS(SimplifyCFG, "normal-simplify-cfg",
     "Clean up the CFG of SIL functions")
PASS(SpeculativeDevirtualization, "specdevirt",
     "Speculate targets of virtual calls")
PASS(SplitAllCriticalEdges, "split-critical-edges",
     "Split all critical edges")
PASS(SplitNonCondBrCriticalEdges, "split-non-cond_br-critical-edges",
     "Split all critical edges that do not involve cond_br")
PASS(StackPromotion, "stack-promotion",
     "Promote allocated objects on the stack")
PASS(StripDebugInfo, "strip-debug-info",
     "Strip debug info")
PASS(SwiftArrayOpts, "array-specialize",
     "Specialize arrays")
PASS(UnsafeGuaranteedPeephole, "unsafe-guaranteed-peephole",
     "Peephole retain/release removal for regions denoted by "
     "Builtin.unsafeGuaranteed")
PASS(UsePrespecialized, "use-prespecialized",
     "Use pre-specialized functions")
PASS(ValueOwnershipKindDumper, "value-ownership-kind-dumper",
     "Print the value ownership kind of all ValueBase in a SILModule")
PASS(BugReducerTester, "bug-reducer-tester",
     "Utility pass for testing sil-bug-reducer. Asserts when visits an apply that calls a specific function")
PASS_RANGE(AllPasses, AADumper, BugReducerTester)

#undef IRGEN_PASS
#undef PASS
#undef PASS_RANGE