NFC fix doxygen comments

[Prazek]

Summary

Fix some comments from to /

[eraman]

include/llvm/IR/Function.h

115–118

I believe you don't need a \brief if it is an one line comment.

194–196

This is a good place to use \brief. Something like
/ \brief Set the entry count for this function.
/
/// Entry count is the number of times the function is called and is obtained based on profile information

199–201

Same as above

lib/Analysis/InlineCost.cpp

128

http://llvm.org/docs/CodingStandards.html#comment-formatting says "prefer C++ style comments"

[Prazek]

lib/Analysis/InlineCost.cpp

128

Thanks, I wasn't sure about this one.

[Prazek]

fixes

[tejohnson]

LGTM with a couple of fixes noted below. Please split out the non-doxygen fixes from this patch and submit those as separate NFC changes (doesn't need to be reviewed further).

include/llvm/IR/Function.h

194

s/breif/brief/
Also, I believe you need an empty line (also starting with ///) between the brief description and the detailed description.

195

s/cound/count/
s/function have been/the function was/

199

Needs line between brief and detailed

200

s/cound/count/
s/function have been/the function was/

include/llvm/ProfileData/ProfileCommon.h

57

This is not a doxygen change, remove from this patch.

61

Ditto on these 2 lines

70

Ditto

76

Ditto.

lib/ProfileData/ProfileSummaryBuilder.cpp

64

The changes to this file should also be submitted separately.

[Prazek]

include/llvm/ProfileData/ProfileCommon.h

57

Can I just change the name of the patch instead? Will be faster and easier

include/llvm/Analysis/InlineCost.h

 class CallSite;
 class DataLayout;
 class Function;
 class ProfileSummaryInfo;
 class TargetTransformInfo;
 
 namespace InlineConstants {
 // Various thresholds used by inline cost analysis.
-// Use when optsize (-Os) is specified.
+/// Use when optsize (-Os) is specified.
 const int OptSizeThreshold = 75;
 
-// Use when minsize (-Oz) is specified.
+/// Use when minsize (-Oz) is specified.
 const int OptMinSizeThreshold = 25;
 
-// Use when -O3 is specified.
+/// Use when -O3 is specified.
 const int OptAggressiveThreshold = 275;
 
 // Various magic constants used to adjust heuristics.
 const int InstrCost = 5;
 const int IndirectCallThreshold = 100;
 const int CallPenalty = 25;
 const int LastCallToStaticBonus = 15000;
 const int ColdccPenalty = 2000;

include/llvm/IR/Function.h

 public:
   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
                           const Twine &N = "", Module *M = nullptr) {
     return new Function(Ty, Linkage, N, M);
   }
 
   ~Function() override;
 
-  /// \brief Provide fast operand accessors
+  // Provide fast operand accessors.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
-
-  Type *getReturnType() const;           // Return the type of the ret val
-  FunctionType *getFunctionType() const; // Return the FunctionType for me
+  /// Returns the type of the ret val.
+  Type *getReturnType() const;
+  /// Returns the FunctionType for me.
+  FunctionType *getFunctionType() const;
 
   /// getContext - Return a reference to the LLVMContext associated with this
   /// function.
   LLVMContext &getContext() const;
 
   /// isVarArg - Return true if this function takes a variable number of
   /// arguments.
   bool isVarArg() const;
public:
   }
 
   /// @brief Remove function attribute from this function.
   void removeFnAttr(StringRef Kind) {
     setAttributes(AttributeSets.removeAttribute(
         getContext(), AttributeSet::FunctionIndex, Kind));
   }
 
-  /// Set the entry count for this function.
+  /// \breif Set the entry count for this function.
+  /// Entry cound is the number of times function have been executed based on
+  /// pgo data.
   void setEntryCount(uint64_t Count);
 
-  /// Get the entry count for this function.
+  /// \brief Get the entry count for this function.
+  /// Entry cout is the number of times function have been executed based on
+  /// pgo data.
   Optional<uint64_t> getEntryCount() const;
 
   /// @brief Return true if the function has the attribute.
   bool hasFnAttribute(Attribute::AttrKind Kind) const {
     return AttributeSets.hasFnAttribute(Kind);
   }
   bool hasFnAttribute(StringRef Kind) const {
     return AttributeSets.hasFnAttribute(Kind);
public:
   bool onlyAccessesInaccessibleMemory() const {
     return hasFnAttribute(Attribute::InaccessibleMemOnly);
   }
   void setOnlyAccessesInaccessibleMemory() {
     addFnAttr(Attribute::InaccessibleMemOnly);
   }
 
   /// @brief Determine if the function may only access memory that is
-  //  either inaccessible from the IR or pointed to by its arguments.
+  ///  either inaccessible from the IR or pointed to by its arguments.
   bool onlyAccessesInaccessibleMemOrArgMem() const {
     return hasFnAttribute(Attribute::InaccessibleMemOrArgMemOnly);
   }
   void setOnlyAccessesInaccessibleMemOrArgMem() {
     addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
   }
 
   /// @brief Determine if the function cannot return.
/// @}
   /// Calls \a getMetadata() with \a LLVMContext::MD_dbg and casts the result
   /// to \a DISubprogram.
   DISubprogram *getSubprogram() const;
 
 private:
   void allocHungoffUselist();
   template<int Idx> void setHungoffOperand(Constant *C);
 
-  // Shadow Value::setValueSubclassData with a private forwarding method so that
-  // subclasses cannot accidentally use it.
+  /// Shadow Value::setValueSubclassData with a private forwarding method so
+  /// that subclasses cannot accidentally use it.
   void setValueSubclassData(unsigned short D) {
     Value::setValueSubclassData(D);
   }
   void setValueSubclassDataBit(unsigned Bit, bool On);
 };
 
 template <>
 struct OperandTraits<Function> : public HungoffOperandTraits<3> {};
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(Function, Value)
 
 } // End llvm namespace
 
 #endif

include/llvm/ProfileData/ProfileCommon.h

 class MDNode;
 
 inline const char *getHotSectionPrefix() { return ".hot"; }
 inline const char *getUnlikelySectionPrefix() { return ".unlikely"; }
 
 class ProfileSummaryBuilder {
 
 private:
-  // We keep track of the number of times a count (block count or samples)
-  // appears in the profile. The map is kept sorted in the descending order of
-  // counts.
+  /// We keep track of the number of times a count (block count or samples)
+  /// appears in the profile. The map is kept sorted in the descending order of
+  /// counts.
   std::map<uint64_t, uint32_t, std::greater<uint64_t>> CountFrequencies;
   std::vector<uint32_t> DetailedSummaryCutoffs;
 
 protected:
   SummaryEntryVector DetailedSummary;
   ProfileSummaryBuilder(std::vector<uint32_t> Cutoffs)
-      : DetailedSummaryCutoffs(std::move(Cutoffs)), TotalCount(0), MaxCount(0),
-        MaxFunctionCount(0), NumCounts(0), NumFunctions(0) {}
+      : DetailedSummaryCutoffs(std::move(Cutoffs)) {}
   inline void addCount(uint64_t Count);
   ~ProfileSummaryBuilder() = default;
   void computeDetailedSummary();
-  uint64_t TotalCount, MaxCount, MaxFunctionCount;
-  uint32_t NumCounts, NumFunctions;
+  uint64_t TotalCount = 0, MaxCount = 0, MaxFunctionCount = 0;
+  uint32_t NumCounts = 0, NumFunctions = 0;
 
 public:
   /// \brief A vector of useful cutoff values for detailed summary.
   static const ArrayRef<uint32_t> DefaultCutoffs;
 };
 
 class InstrProfSummaryBuilder final : public ProfileSummaryBuilder {
-  uint64_t MaxInternalBlockCount;
+  uint64_t MaxInternalBlockCount = 0;
   inline void addEntryCount(uint64_t Count);
   inline void addInternalCount(uint64_t Count);
 
 public:
   InstrProfSummaryBuilder(std::vector<uint32_t> Cutoffs)
-      : ProfileSummaryBuilder(std::move(Cutoffs)), MaxInternalBlockCount(0) {}
+      : ProfileSummaryBuilder(std::move(Cutoffs)) {}
   void addRecord(const InstrProfRecord &);
   std::unique_ptr<ProfileSummary> getSummary();
 };
 
 class SampleProfileSummaryBuilder final : public ProfileSummaryBuilder {
 
 public:
   void addRecord(const sampleprof::FunctionSamples &FS);
   SampleProfileSummaryBuilder(std::vector<uint32_t> Cutoffs)
       : ProfileSummaryBuilder(std::move(Cutoffs)) {}
   std::unique_ptr<ProfileSummary> getSummary();
 };
 
-// This is called when a count is seen in the profile.
+/// This is called when a count is seen in the profile.
 void ProfileSummaryBuilder::addCount(uint64_t Count) {
   TotalCount += Count;
   if (Count > MaxCount)
     MaxCount = Count;
   NumCounts++;
   CountFrequencies[Count]++;
 }
 
 
 } // end namespace llvm
 #endif

lib/Analysis/InlineCost.cpp

class CallAnalyzer : public InstVisitor<CallAnalyzer, bool> {
   const TargetTransformInfo &TTI;
 
   /// Getter for the cache of @llvm.assume intrinsics.
   std::function<AssumptionCache &(Function &)> &GetAssumptionCache;
 
   /// Profile summary information.
   ProfileSummaryInfo *PSI;
 
-  // The called function.
+  /// The called function.
   Function &F;
 
-  // The candidate callsite being analyzed. Please do not use this to do
-  // analysis in the caller function; we want the inline cost query to be
-  // easily cacheable. Instead, use the cover function paramHasAttr.
+  /// The candidate callsite being analyzed. Please do not use this to do
+  /// analysis in the caller function; we want the inline cost query to be
+  /// easily cacheable. Instead, use the cover function paramHasAttr.
   CallSite CandidateCS;
 
-  // Tunable parameters that control the analysis.
+  /// Tunable parameters that control the analysis.
   const InlineParams &Params;
 
   int Threshold;
   int Cost;
 
   bool IsCallerRecursive;
   bool IsRecursiveCall;
   bool ExposesReturnsTwice;
   bool HasDynamicAlloca;
   bool ContainsNoDuplicateCall;
   bool HasReturn;
   bool HasIndirectBr;
   bool HasFrameEscape;
 
   /// Number of bytes allocated statically by the callee.
   uint64_t AllocatedSize;
   unsigned NumInstructions, NumVectorInstructions;
   int FiftyPercentVectorBonus, TenPercentVectorBonus;
   int VectorBonus;
 
-  // While we walk the potentially-inlined instructions, we build up and
-  // maintain a mapping of simplified values specific to this callsite. The
-  // idea is to propagate any special information we have about arguments to
-  // this call through the inlinable section of the function, and account for
-  // likely simplifications post-inlining. The most important aspect we track
-  // is CFG altering simplifications -- when we prove a basic block dead, that
-  // can cause dramatic shifts in the cost of inlining a function.
+  /// While we walk the potentially-inlined instructions, we build up and
+  /// maintain a mapping of simplified values specific to this callsite. The
+  /// idea is to propagate any special information we have about arguments to
+  /// this call through the inlinable section of the function, and account for
+  /// likely simplifications post-inlining. The most important aspect we track
+  /// is CFG altering simplifications -- when we prove a basic block dead, that
+  /// can cause dramatic shifts in the cost of inlining a function.
   DenseMap<Value *, Constant *> SimplifiedValues;
 
-  // Keep track of the values which map back (through function arguments) to
-  // allocas on the caller stack which could be simplified through SROA.
+  /// Keep track of the values which map back (through function arguments) to
+  /// allocas on the caller stack which could be simplified through SROA.
   DenseMap<Value *, Value *> SROAArgValues;
 
-  // The mapping of caller Alloca values to their accumulated cost savings. If
-  // we have to disable SROA for one of the allocas, this tells us how much
-  // cost must be added.
+  /// The mapping of caller Alloca values to their accumulated cost savings. If
+  /// we have to disable SROA for one of the allocas, this tells us how much
+  /// cost must be added.
   DenseMap<Value *, int> SROAArgCosts;
 
-  // Keep track of values which map to a pointer base and constant offset.
+  /// Keep track of values which map to a pointer base and constant offset.
   DenseMap<Value *, std::pair<Value *, APInt>> ConstantOffsetPtrs;
 
   // Custom simplification helper routines.
   bool isAllocaDerivedArg(Value *V);
   bool lookupSROAArgAndCost(Value *V, Value *&Arg,
                             DenseMap<Value *, int>::iterator &CostIt);
   void disableSROA(DenseMap<Value *, int>::iterator CostIt);
   void disableSROA(Value *V);
   void accumulateSROACost(DenseMap<Value *, int>::iterator CostIt,
                           int InstructionCost);
   bool isGEPOffsetConstant(GetElementPtrInst &GEP);

lib/Analysis/ProfileSummaryInfo.cpp

void ProfileSummaryInfo::computeSummary() {
   if (Summary)
     return;
   auto *SummaryMD = M.getProfileSummary();
   if (!SummaryMD)
     return;
   Summary.reset(ProfileSummary::getFromMD(SummaryMD));
 }
 
-// Returns true if the function is a hot function. If it returns false, it
-// either means it is not hot or it is unknown whether F is hot or not (for
-// example, no profile data is available).
+/// Returns true if the function is a hot function. If it returns false, it
+/// either means it is not hot or it is unknown whether F is hot or not (for
+/// example, no profile data is available).
 bool ProfileSummaryInfo::isHotFunction(const Function *F) {
   computeSummary();
   if (!F || !Summary)
     return false;
   auto FunctionCount = F->getEntryCount();
   // FIXME: The heuristic used below for determining hotness is based on
   // preliminary SPEC tuning for inliner. This will eventually be a
   // convenience method that calls isHotCount.
   return (FunctionCount &&
           FunctionCount.getValue() >=
               (uint64_t)(0.3 * (double)Summary->getMaxFunctionCount()));
 }
 
-// Returns true if the function is a cold function. If it returns false, it
-// either means it is not cold or it is unknown whether F is cold or not (for
-// example, no profile data is available).
+/// Returns true if the function is a cold function. If it returns false, it
+/// either means it is not cold or it is unknown whether F is cold or not (for
+/// example, no profile data is available).
 bool ProfileSummaryInfo::isColdFunction(const Function *F) {
   computeSummary();
   if (!F)
     return false;
   if (F->hasFnAttribute(Attribute::Cold)) {
     return true;
   }
   if (!Summary)
     return false;
   auto FunctionCount = F->getEntryCount();
   // FIXME: The heuristic used below for determining coldness is based on
   // preliminary SPEC tuning for inliner. This will eventually be a
   // convenience method that calls isHotCount.
   return (FunctionCount &&
           FunctionCount.getValue() <=
               (uint64_t)(0.01 * (double)Summary->getMaxFunctionCount()));
 }
 
-// Compute the hot and cold thresholds.
+/// Compute the hot and cold thresholds.
 void ProfileSummaryInfo::computeThresholds() {
   if (!Summary)
     computeSummary();
   if (!Summary)
     return;
   auto &DetailedSummary = Summary->getDetailedSummary();
   HotCountThreshold =
       getMinCountForPercentile(DetailedSummary, ProfileSummaryCutoffHot);

lib/ProfileData/ProfileSummaryBuilder.cpp

for (const auto &I : FS.getBodySamples())
     addCount(I.second.getSamples());
 }
 
 // The argument to this method is a vector of cutoff percentages and the return
 // value is a vector of (Cutoff, MinCount, NumCounts) triplets.
 void ProfileSummaryBuilder::computeDetailedSummary() {
   if (DetailedSummaryCutoffs.empty())
     return;
-  auto Iter = CountFrequencies.begin();
-  auto End = CountFrequencies.end();
   std::sort(DetailedSummaryCutoffs.begin(), DetailedSummaryCutoffs.end());
+  auto Iter = CountFrequencies.begin();
+  const auto End = CountFrequencies.end();
 
   uint32_t CountsSeen = 0;
   uint64_t CurrSum = 0, Count = 0;
 
-  for (uint32_t Cutoff : DetailedSummaryCutoffs) {
+  for (const uint32_t Cutoff : DetailedSummaryCutoffs) {
     assert(Cutoff <= 999999);
     APInt Temp(128, TotalCount);
     APInt N(128, Cutoff);
     APInt D(128, ProfileSummary::Scale);
     Temp *= N;
     Temp = Temp.sdiv(D);
     uint64_t DesiredCount = Temp.getZExtValue();
     assert(DesiredCount <= TotalCount);