Improve comments terseness in PassBuilder.h

[neysofu]

Summary

A small but sensible improvement to some comments. This revision is mostly for me to get the hang of the contributing process to then do bigger tasks.

[asbirlea]

Thanks for the cleanup! A couple of small comments inline.

include/llvm/Passes/PassBuilder.h

73

s/a LLVM/LLVM

76

clang-format all updated comments back to 80.

100

s/access/accesses (might as well correct my typos while at it :) )

130

Nit: Maybe keep this line and the empty line below, since it's the comment pattern for all the other structs/enums/classes in this class? It's fine either way.

[asbirlea]

Assume obsolete, please readd if active.

include/llvm/Passes/PassBuilder.h

struct PGOOptions {
   CSPGOAction CSAction;
   bool SamplePGOSupport;
 };
 
 /// Tunable parameters for passes in the default pipelines.
 class PipelineTuningOptions {
 public:
   /// Constructor sets pipeline tuning defaults based on cl::opts. Each option
   /// can be set in the PassBuilder when using a LLVM as a library.
   PipelineTuningOptions();
 
-  /// Tuning option to set loop interleaving on/off. Its default value is that
+  /// Enables/disables loop interleaving. Its default value is that
   /// of the flag: `-interleave-loops`.
   bool LoopInterleaving;
 
-  /// Tuning option to enable/disable loop vectorization. Its default value is
+  /// Enables/disables loop vectorization. Its default value is
   /// that of the flag: `-vectorize-loops`.
   bool LoopVectorization;
 
-  /// Tuning option to enable/disable slp loop vectorization. Its default value
+  /// Enables/disables slp loop vectorization. Its default value
   /// is that of the flag: `vectorize-slp`.
   bool SLPVectorization;
 
-  /// Tuning option to enable/disable loop unrolling. Its default value is true.
+  /// Enables/disables loop unrolling. Its default value is true.
   bool LoopUnrolling;
 
-  /// Tuning option to forget all SCEV loops in LoopUnroll. Its default value
+  /// Tells to forget all SCEV loops in LoopUnroll. Its default value
   /// is that of the flag: `-forget-scev-loop-unroll`.
   bool ForgetAllSCEVInLoopUnroll;
 
-  /// Tuning option to cap the number of calls to retrive clobbering accesses in
+  /// Caps the number of calls to retrive clobbering accesses in
   /// MemorySSA, in LICM.
   unsigned LicmMssaOptCap;
 
-  /// Tuning option to disable promotion to scalars in LICM with MemorySSA, if
+  /// Disables promotion to scalars in LICM with MemorySSA, if
   /// the number of access is too large.
   unsigned LicmMssaNoAccForPromotionCap;
 };
 
 /// This class provides access to building LLVM's passes.
 ///
 /// Its members provide the baseline state available to passes during their
 /// construction. The \c PassRegistry.def file specifies how to construct all
 /// of the built-in passes, and those may reference these members during
public:
   /// name is the name of a pass, the InnerPipeline is empty, since passes
   /// cannot contain inner pipelines. See parsePassPipeline() for a more
   /// detailed description of the textual pipeline format.
   struct PipelineElement {
     StringRef Name;
     std::vector<PipelineElement> InnerPipeline;
   };
 
-  /// ThinLTO phase.
-  ///
-  /// This enumerates the LLVM ThinLTO optimization phases.
+  /// Enumerates the possible LLVM ThinLTO optimization phases.
   enum class ThinLTOPhase {
     /// No ThinLTO behavior needed.
     None,
     /// ThinLTO prelink (summary) phase.
     PreLink,
     /// ThinLTO postlink (backend compile) phase.
     PostLink
   };
public:
   /// This is an interface that can be used to populate a \c
   /// ModuleAnalysisManager with all registered module analyses. Callers can
   /// still manually register any additional analyses. Callers can also
   /// pre-register analyses and this will not override those.
   void registerModuleAnalyses(ModuleAnalysisManager &MAM);
 
   /// Registers all available CGSCC analysis passes.
   ///
-  /// This is an interface that can be used to populate a \c CGSCCAnalysisManager
-  /// with all registered CGSCC analyses. Callers can still manually register any
-  /// additional analyses. Callers can also pre-register analyses and this will
-  /// not override those.
+  /// This is an interface that can be used to populate a \c
+  /// CGSCCAnalysisManager with all registered CGSCC analyses. Callers can still
+  /// manually register any additional analyses. Callers can also pre-register
+  /// analyses and this will not override those.
   void registerCGSCCAnalyses(CGSCCAnalysisManager &CGAM);
 
   /// Registers all available function analysis passes.
   ///
   /// This is an interface that can be used to populate a \c
   /// FunctionAnalysisManager with all registered function analyses. Callers can
   /// still manually register any additional analyses. Callers can also
   /// pre-register analyses and this will not override those.
public:
   /// information about the semantics of the IR.
   ///
   /// Note that \p Level cannot be `O0` here. The pipelines produced are
   /// only intended for use when attempting to optimize code. If frontends
   /// require some transformations for semantic reasons, they should explicitly
   /// build them.
   ///
   /// \p Phase indicates the current ThinLTO phase.
-  FunctionPassManager
-  buildFunctionSimplificationPipeline(OptimizationLevel Level,
-                                      ThinLTOPhase Phase,
-                                      bool DebugLogging = false);
+  FunctionPassManager buildFunctionSimplificationPipeline(
+      OptimizationLevel Level, ThinLTOPhase Phase, bool DebugLogging = false);
 
   /// Construct the core LLVM module canonicalization and simplification
   /// pipeline.
   ///
   /// This pipeline focuses on canonicalizing and simplifying the entire module
   /// of IR. Much like the function simplification pipeline above, it is
   /// suitable to run repeatedly over the IR and is not expected to destroy
   /// important information. It does, however, perform inlining and other
   /// heuristic based simplifications that are not strictly reversible.
   ///
   /// Note that \p Level cannot be `O0` here. The pipelines produced are
   /// only intended for use when attempting to optimize code. If frontends
   /// require some transformations for semantic reasons, they should explicitly
   /// build them.
   ///
   /// \p Phase indicates the current ThinLTO phase.
   ModulePassManager
-  buildModuleSimplificationPipeline(OptimizationLevel Level,
-                                    ThinLTOPhase Phase,
+  buildModuleSimplificationPipeline(OptimizationLevel Level, ThinLTOPhase Phase,
                                     bool DebugLogging = false);
 
   /// Construct the core LLVM module optimization pipeline.
   ///
   /// This pipeline focuses on optimizing the execution speed of the IR. It
   /// uses cost modeling and thresholds to balance code growth against runtime
   /// improvements. It includes vectorization and other information destroying
   /// transformations. It also cannot generally be run repeatedly on a module
if (PipelineName != AnalysisName)
       return false;
     PM.addPass(RequireAnalysisPass<AnalysisT, IRUnitT, AnalysisManagerT,
                                    ExtraArgTs...>());
     return true;
   }
 
   return false;
 }
-}
+} // namespace llvm
 
 #endif