Remove \brief commands from doxygen comments.

[MaskRay]

Summary

This is similar to D46290 D46320.

[grimar]

LGTM

include/lld/Common/Version.h

 
 #ifndef LLD_VERSION_H
 #define LLD_VERSION_H
 
 #include "lld/Common/Version.inc"
 #include "llvm/ADT/StringRef.h"
 
 namespace lld {
-/// \brief Retrieves a string representing the complete lld version.
+/// Retrieves a string representing the complete lld version.
 std::string getLLDVersion();
 }
 
 #endif // LLD_VERSION_H

include/lld/Core/DefinedAtom.h

 #include "lld/Common/LLVM.h"
 #include "lld/Core/Atom.h"
 #include "lld/Core/Reference.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace lld {
 class File;
 
-/// \brief The fundamental unit of linking.
+/// The fundamental unit of linking.
 ///
 /// A C function or global variable is an atom.  An atom has content and
 /// attributes. The content of a function atom is the instructions that
 /// implement the function.  The content of a global variable atom is its
 /// initial bytes.
 ///
 /// Here are some example attribute sets for common atoms. If a particular
 /// attribute is not listed, the default values are:  definition=regular,
public:
 
   enum DeadStripKind {
     deadStripNormal,        // linker may dead strip this atom
     deadStripNever,         // linker must never dead strip this atom
     deadStripAlways         // linker must remove this atom if unused
   };
 
   enum DynamicExport {
-    /// \brief The linker may or may not export this atom dynamically depending
+    /// The linker may or may not export this atom dynamically depending
     ///   on the output type and other context of the link.
     dynamicExportNormal,
-    /// \brief The linker will always export this atom dynamically.
+    /// The linker will always export this atom dynamically.
     dynamicExportAlways,
   };
 
   // Attributes describe a code model used by the atom.
   enum CodeModel {
     codeNA,           // no specific code model
     // MIPS code models
     codeMipsPIC,      // PIC function in a PIC / non-PIC mixed file
struct Alignment {
     uint16_t value;
     uint16_t modulus;
 
     bool operator==(const Alignment &rhs) const {
       return (value == rhs.value) && (modulus == rhs.modulus);
     }
   };
 
-  /// \brief returns a value for the order of this Atom within its file.
+  /// returns a value for the order of this Atom within its file.
   ///
   /// This is used by the linker to order the layout of Atoms so that the
   /// resulting image is stable and reproducible.
   virtual uint64_t ordinal() const = 0;
 
-  /// \brief the number of bytes of space this atom's content will occupy in the
+  /// the number of bytes of space this atom's content will occupy in the
   /// final linked image.
   ///
   /// For a function atom, it is the number of bytes of code in the function.
   virtual uint64_t size() const = 0;
 
-  /// \brief The size of the section from which the atom is instantiated.
+  /// The size of the section from which the atom is instantiated.
   ///
   /// Merge::mergeByLargestSection is defined in terms of section size
   /// and not in terms of atom size, so we need this function separate
   /// from size().
   virtual uint64_t sectionSize() const { return 0; }
 
-  /// \brief The visibility of this atom to other atoms.
+  /// The visibility of this atom to other atoms.
   ///
   /// C static functions have scope scopeTranslationUnit.  Regular C functions
   /// have scope scopeGlobal.  Functions compiled with visibility=hidden have
   /// scope scopeLinkageUnit so they can be see by other atoms being linked but
   /// not by the OS loader.
   virtual Scope scope() const = 0;
 
-  /// \brief Whether the linker should use direct or indirect access to this
+  /// Whether the linker should use direct or indirect access to this
   /// atom.
   virtual Interposable interposable() const = 0;
 
-  /// \brief how the linker should handle if multiple atoms have the same name.
+  /// how the linker should handle if multiple atoms have the same name.
   virtual Merge merge() const = 0;
 
-  /// \brief The type of this atom, such as code or data.
+  /// The type of this atom, such as code or data.
   virtual ContentType contentType() const = 0;
 
-  /// \brief The alignment constraints on how this atom must be laid out in the
+  /// The alignment constraints on how this atom must be laid out in the
   /// final linked image (e.g. 16-byte aligned).
   virtual Alignment alignment() const = 0;
 
-  /// \brief Whether this atom must be in a specially named section in the final
+  /// Whether this atom must be in a specially named section in the final
   /// linked image, or if the linker can infer the section based on the
   /// contentType().
   virtual SectionChoice sectionChoice() const = 0;
 
-  /// \brief If sectionChoice() != sectionBasedOnContent, then this return the
+  /// If sectionChoice() != sectionBasedOnContent, then this return the
   /// name of the section the atom should be placed into.
   virtual StringRef customSectionName() const = 0;
 
-  /// \brief constraints on whether the linker may dead strip away this atom.
+  /// constraints on whether the linker may dead strip away this atom.
   virtual DeadStripKind deadStrip() const = 0;
 
-  /// \brief Under which conditions should this atom be dynamically exported.
+  /// Under which conditions should this atom be dynamically exported.
   virtual DynamicExport dynamicExport() const {
     return dynamicExportNormal;
   }
 
-  /// \brief Code model used by the atom.
+  /// Code model used by the atom.
   virtual CodeModel codeModel() const { return codeNA; }
 
-  /// \brief Returns the OS memory protections required for this atom's content
+  /// Returns the OS memory protections required for this atom's content
   /// at runtime.
   ///
   /// A function atom is R_X, a global variable is RW_, and a read-only constant
   /// is R__.
   virtual ContentPermissions permissions() const;
 
-  /// \brief returns a reference to the raw (unrelocated) bytes of this Atom's
+  /// returns a reference to the raw (unrelocated) bytes of this Atom's
   /// content.
   virtual ArrayRef<uint8_t> rawContent() const = 0;
 
   /// This class abstracts iterating over the sequence of References
   /// in an Atom.  Concrete instances of DefinedAtom must implement
   /// the derefIterator() and incrementIterator() methods.
   class reference_iterator {
   public:
reference_iterator &operator++() {
       _atom.incrementIterator(_it);
       return *this;
     }
   private:
     const DefinedAtom &_atom;
     const void *_it;
   };
 
-  /// \brief Returns an iterator to the beginning of this Atom's References.
+  /// Returns an iterator to the beginning of this Atom's References.
   virtual reference_iterator begin() const = 0;
 
-  /// \brief Returns an iterator to the end of this Atom's References.
+  /// Returns an iterator to the end of this Atom's References.
   virtual reference_iterator end() const = 0;
 
   /// Adds a reference to this atom.
   virtual void addReference(Reference::KindNamespace ns,
                             Reference::KindArch arch,
                             Reference::KindValue kindValue, uint64_t off,
                             const Atom *target, Reference::Addend a) {
     llvm_unreachable("Subclass does not permit adding references");

 
 protected:
   // DefinedAtom is an abstract base class. Only subclasses can access
   // constructor.
   DefinedAtom() : Atom(definitionRegular) { }
 
   ~DefinedAtom() override = default;
 
-  /// \brief Returns a pointer to the Reference object that the abstract
+  /// Returns a pointer to the Reference object that the abstract
   /// iterator "points" to.
   virtual const Reference *derefIterator(const void *iter) const = 0;
 
-  /// \brief Adjusts the abstract iterator to "point" to the next Reference
+  /// Adjusts the abstract iterator to "point" to the next Reference
   /// object for this Atom.
   virtual void incrementIterator(const void *&iter) const = 0;
 };
 } // end namespace lld
 
 #endif

include/lld/Core/File.h

 ///      }
 ///
 /// The Atom objects in a File are owned by the File object.  The Atom objects
 /// are destroyed when the File object is destroyed.
 class File {
 public:
   virtual ~File();
 
-  /// \brief Kinds of files that are supported.
+  /// Kinds of files that are supported.
   enum Kind {
     kindErrorObject,          ///< a error object file (.o)
     kindNormalizedObject,     ///< a normalized file (.o)
     kindMachObject,           ///< a MachO object file (.o)
     kindCEntryObject,         ///< a file for CEntries
     kindHeaderObject,         ///< a file for file headers
     kindEntryObject,          ///< a file for the entry
     kindUndefinedSymsObject,  ///< a file for undefined symbols
     kindStubHelperObject,     ///< a file for stub helpers
     kindResolverMergedObject, ///< the resolver merged file.
     kindSectCreateObject,     ///< a sect create object file (.o)
     kindSharedLibrary,        ///< shared library (.so)
     kindArchiveLibrary        ///< archive (.a)
   };
 
-  /// \brief Returns file kind.  Need for dyn_cast<> on File objects.
+  /// Returns file kind.  Need for dyn_cast<> on File objects.
   Kind kind() const {
     return _kind;
   }
 
   /// This returns the path to the file which was used to create this object
   /// (e.g. "/tmp/foo.o"). If the file is a member of an archive file, the
   /// returned string includes the archive file name.
   StringRef path() const {
public:
     OwningAtomPtr<T> &operator[](size_t idx) {
       return _v[idx];
     }
 
   private:
     AtomVector<T> &_v;
   };
 
-  /// \brief Must be implemented to return the AtomVector object for
+  /// Must be implemented to return the AtomVector object for
   /// all DefinedAtoms in this File.
   virtual const AtomRange<DefinedAtom> defined() const = 0;
 
-  /// \brief Must be implemented to return the AtomVector object for
+  /// Must be implemented to return the AtomVector object for
   /// all UndefinedAtomw in this File.
   virtual const AtomRange<UndefinedAtom> undefined() const = 0;
 
-  /// \brief Must be implemented to return the AtomVector object for
+  /// Must be implemented to return the AtomVector object for
   /// all SharedLibraryAtoms in this File.
   virtual const AtomRange<SharedLibraryAtom> sharedLibrary() const = 0;
 
-  /// \brief Must be implemented to return the AtomVector object for
+  /// Must be implemented to return the AtomVector object for
   /// all AbsoluteAtoms in this File.
   virtual const AtomRange<AbsoluteAtom> absolute() const = 0;
 
   /// Drop all of the atoms owned by this file.  This will result in all of
   /// the atoms running their destructors.
   /// This is required because atoms may be allocated on a BumpPtrAllocator
   /// of a different file.  We need to destruct all atoms before any files.
   virtual void clearAtoms() = 0;
 
-  /// \brief If a file is parsed using a different method than doParse(),
+  /// If a file is parsed using a different method than doParse(),
   /// one must use this method to set the last error status, so that
   /// doParse will not be called twice. Only YAML reader uses this
   /// (because YAML reader does not read blobs but structured data).
   void setLastError(std::error_code err) { _lastError = err; }
 
   std::error_code parse();
 
   // Usually each file owns a std::unique_ptr<MemoryBuffer>.
   // However, there's one special case. If a file is an archive file,
   // the archive file and its children all shares the same memory buffer.
   // This method is used by the ArchiveFile to give its children
   // co-ownership of the buffer.
   void setSharedMemoryBuffer(std::shared_ptr<MemoryBuffer> mb) {
     _sharedMemoryBuffer = mb;
   }
 
 protected:
-  /// \brief only subclasses of File can be instantiated
+  /// only subclasses of File can be instantiated
   File(StringRef p, Kind kind)
     : _path(p), _kind(kind), _ordinal(UINT64_MAX),
       _nextAtomOrdinal(0) {}
 
-  /// \brief Subclasses should override this method to parse the
+  /// Subclasses should override this method to parse the
   /// memory buffer passed to this file's constructor.
   virtual std::error_code doParse() { return std::error_code(); }
 
   static AtomVector<DefinedAtom> _noDefinedAtoms;
   static AtomVector<UndefinedAtom> _noUndefinedAtoms;
   static AtomVector<SharedLibraryAtom> _noSharedLibraryAtoms;
   static AtomVector<AbsoluteAtom> _noAbsoluteAtoms;
   mutable llvm::BumpPtrAllocator _allocator;

include/lld/Core/Instrumentation.h

 //===- include/Core/Instrumentation.h - Instrumentation API ---------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief Provide an Instrumentation API that optionally uses VTune interfaces.
+/// Provide an Instrumentation API that optionally uses VTune interfaces.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_INSTRUMENTATION_H
 #define LLD_CORE_INSTRUMENTATION_H
 
 #include "llvm/Support/Compiler.h"
 #include <utility>
 
 #ifdef LLD_HAS_VTUNE
 # include <ittnotify.h>
 #endif
 
 namespace lld {
 #ifdef LLD_HAS_VTUNE
-/// \brief A unique global scope for instrumentation data.
+/// A unique global scope for instrumentation data.
 ///
 /// Domains last for the lifetime of the application and cannot be destroyed.
 /// Multiple Domains created with the same name represent the same domain.
 class Domain {
   __itt_domain *_domain;
 
 public:
   explicit Domain(const char *name) : _domain(__itt_domain_createA(name)) {}
 
   operator __itt_domain *() const { return _domain; }
   __itt_domain *operator->() const { return _domain; }
 };
 
-/// \brief A global reference to a string constant.
+/// A global reference to a string constant.
 ///
 /// These are uniqued by the ITT runtime and cannot be deleted. They are not
 /// specific to a domain.
 ///
 /// Prefer reusing a single StringHandle over passing a ntbs when the same
 /// string will be used often.
 class StringHandle {
   __itt_string_handle *_handle;
 
 public:
   StringHandle(const char *name) : _handle(__itt_string_handle_createA(name)) {}
 
   operator __itt_string_handle *() const { return _handle; }
 };
 
-/// \brief A task on a single thread. Nests within other tasks.
+/// A task on a single thread. Nests within other tasks.
 ///
 /// Each thread has its own task stack and tasks nest recursively on that stack.
 /// A task cannot transfer threads.
 ///
 /// SBRM is used to ensure task starts and ends are ballanced. The lifetime of
 /// a task is either the lifetime of this object, or until end is called.
 class ScopedTask {
   __itt_domain *_domain;
 
   ScopedTask(const ScopedTask &) = delete;
   ScopedTask &operator=(const ScopedTask &) = delete;
 
 public:
-  /// \brief Create a task in Domain \p d named \p s.
+  /// Create a task in Domain \p d named \p s.
   ScopedTask(const Domain &d, const StringHandle &s) : _domain(d) {
     __itt_task_begin(d, __itt_null, __itt_null, s);
   }
 
   ScopedTask(ScopedTask &&other) {
     *this = std::move(other);
   }
 
   ScopedTask &operator=(ScopedTask &&other) {
     _domain = other._domain;
     other._domain = nullptr;
     return *this;
   }
 
-  /// \brief Prematurely end this task.
+  /// Prematurely end this task.
   void end() {
     if (_domain)
       __itt_task_end(_domain);
     _domain = nullptr;
   }
 
   ~ScopedTask() { end(); }
 };
 
-/// \brief A specific point in time. Allows metadata to be associated.
+/// A specific point in time. Allows metadata to be associated.
 class Marker {
 public:
   Marker(const Domain &d, const StringHandle &s) {
     __itt_marker(d, __itt_null, s, __itt_scope_global);
   }
 };
 #else
 class Domain {

include/lld/Core/LinkingContext.h

 namespace lld {
 
 class PassManager;
 class File;
 class Writer;
 class Node;
 class SharedLibraryFile;
 
-/// \brief The LinkingContext class encapsulates "what and how" to link.
+/// The LinkingContext class encapsulates "what and how" to link.
 ///
 /// The base class LinkingContext contains the options needed by core linking.
 /// Subclasses of LinkingContext have additional options needed by specific
 /// Writers.
 class LinkingContext {
 public:
   virtual ~LinkingContext();
 

include/lld/Core/PassManager.h

 #include "llvm/Support/Error.h"
 #include <memory>
 #include <vector>
 
 namespace lld {
 class SimpleFile;
 class Pass;
 
-/// \brief Owns and runs a collection of passes.
+/// Owns and runs a collection of passes.
 ///
 /// This class is currently just a container for passes and a way to run them.
 ///
 /// In the future this should handle timing pass runs, running parallel passes,
 /// and validate/satisfy pass dependencies.
 class PassManager {
 public:
   void add(std::unique_ptr<Pass> pass) {
     _passes.push_back(std::move(pass));
   }
 
   llvm::Error runOnFile(SimpleFile &file) {
     for (std::unique_ptr<Pass> &pass : _passes)
       if (llvm::Error EC = pass->perform(file))
         return EC;
     return llvm::Error::success();
   }
 
 private:
-  /// \brief Passes in the order they should run.
+  /// Passes in the order they should run.
   std::vector<std::unique_ptr<Pass>> _passes;
 };
 } // end namespace lld
 
 #endif

include/lld/Core/Reader.h

 } // end namespace llvm
 
 namespace lld {
 
 class File;
 class LinkingContext;
 class MachOLinkingContext;
 
-/// \brief An abstract class for reading object files, library files, and
+/// An abstract class for reading object files, library files, and
 /// executable files.
 ///
 /// Each file format (e.g. mach-o, etc) has a concrete subclass of Reader.
 class Reader {
 public:
   virtual ~Reader() = default;
 
   /// Sniffs the file to determine if this Reader can parse it.
   /// The method is called with:
   /// 1) the file_magic enumeration returned by identify_magic()
   /// 2) the whole file content buffer if the above is not enough.
   virtual bool canParse(llvm::file_magic magic, MemoryBufferRef mb) const = 0;
 
-  /// \brief Parse a supplied buffer (already filled with the contents of a
+  /// Parse a supplied buffer (already filled with the contents of a
   /// file) and create a File object.
   /// The resulting File object takes ownership of the MemoryBuffer.
   virtual ErrorOr<std::unique_ptr<File>>
   loadFile(std::unique_ptr<MemoryBuffer> mb, const class Registry &) const = 0;
 };
 
-/// \brief An abstract class for handling alternate yaml representations
+/// An abstract class for handling alternate yaml representations
 /// of object files.
 ///
 /// The YAML syntax allows "tags" which are used to specify the type of
 /// the YAML node.  In lld, top level YAML documents can be in many YAML
 /// representations (e.g mach-o encoded as yaml, etc).  A tag is used to
 /// specify which representation is used in the following YAML document.
 /// To work, there must be a YamlIOTaggedDocumentHandler registered that
 /// handles each tag type.

include/lld/Core/Resolver.h

 #include <unordered_set>
 #include <vector>
 
 namespace lld {
 
 class Atom;
 class LinkingContext;
 
-/// \brief The Resolver is responsible for merging all input object files
+/// The Resolver is responsible for merging all input object files
 /// and producing a merged graph.
 class Resolver {
 public:
   Resolver(LinkingContext &ctx) : _ctx(ctx), _result(new MergedFile()) {}
 
   // InputFiles::Handler methods
   void doDefinedAtom(OwningAtomPtr<DefinedAtom> atom);
   bool doUndefinedAtom(OwningAtomPtr<UndefinedAtom> atom);
   void doSharedLibraryAtom(OwningAtomPtr<SharedLibraryAtom> atom);
   void doAbsoluteAtom(OwningAtomPtr<AbsoluteAtom> atom);
 
   // Handle files, this adds atoms from the current file thats
   // being processed by the resolver
   llvm::Expected<bool> handleFile(File &);
 
   // Handle an archive library file.
   llvm::Expected<bool> handleArchiveFile(File &);
 
   // Handle a shared library file.
   llvm::Error handleSharedLibrary(File &);
 
-  /// @brief do work of merging and resolving and return list
+  /// do work of merging and resolving and return list
   bool resolve();
 
   std::unique_ptr<SimpleFile> resultFile() { return std::move(_result); }
 
 private:
   typedef std::function<llvm::Expected<bool>(StringRef)> UndefCallback;
 
   bool undefinesAdded(int begin, int end);
   File *getFile(int &index);
 
-  /// \brief The main function that iterates over the files to resolve
+  /// The main function that iterates over the files to resolve
   bool resolveUndefines();
   void updateReferences();
   void deadStripOptimize();
   bool checkUndefines();
   void removeCoalescedAwayAtoms();
   llvm::Expected<bool> forEachUndefines(File &file, UndefCallback callback);
 
   void markLive(const Atom *atom);

include/lld/Core/Simple.h

 //===- lld/Core/Simple.h - Simple implementations of Atom and File --------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief Provide simple implementations for Atoms and File.
+/// Provide simple implementations for Atoms and File.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_CORE_SIMPLE_H
 #define LLD_CORE_SIMPLE_H
 
 #include "lld/Core/AbsoluteAtom.h"
 #include "lld/Core/Atom.h"

include/lld/Core/SymbolTable.h

 class AbsoluteAtom;
 class Atom;
 class DefinedAtom;
 class LinkingContext;
 class ResolverOptions;
 class SharedLibraryAtom;
 class UndefinedAtom;
 
-/// \brief The SymbolTable class is responsible for coalescing atoms.
+/// The SymbolTable class is responsible for coalescing atoms.
 ///
 /// All atoms coalescable by-name or by-content should be added.
 /// The method replacement() can be used to find the replacement atom
 /// if an atom has been coalesced away.
 class SymbolTable {
 public:
-  /// @brief add atom to symbol table
+  /// add atom to symbol table
   bool add(const DefinedAtom &);
 
-  /// @brief add atom to symbol table
+  /// add atom to symbol table
   bool add(const UndefinedAtom &);
 
-  /// @brief add atom to symbol table
+  /// add atom to symbol table
   bool add(const SharedLibraryAtom &);
 
-  /// @brief add atom to symbol table
+  /// add atom to symbol table
   bool add(const AbsoluteAtom &);
 
-  /// @brief returns atom in symbol table for specified name (or nullptr)
+  /// returns atom in symbol table for specified name (or nullptr)
   const Atom *findByName(StringRef sym);
 
-  /// @brief returns vector of remaining UndefinedAtoms
+  /// returns vector of remaining UndefinedAtoms
   std::vector<const UndefinedAtom *> undefines();
 
-  /// @brief if atom has been coalesced away, return replacement, else return atom
+  /// if atom has been coalesced away, return replacement, else return atom
   const Atom *replacement(const Atom *);
 
-  /// @brief if atom has been coalesced away, return true
+  /// if atom has been coalesced away, return true
   bool isCoalescedAway(const Atom *);
 
 private:
   typedef llvm::DenseMap<const Atom *, const Atom *> AtomToAtom;
 
   struct StringRefMappingInfo {
     static StringRef getEmptyKey() { return StringRef(); }
     static StringRef getTombstoneKey() { return StringRef(" ", 1); }

include/lld/Core/Writer.h

 #include <memory>
 #include <vector>
 
 namespace lld {
 class File;
 class LinkingContext;
 class MachOLinkingContext;
 
-/// \brief The Writer is an abstract class for writing object files, shared
+/// The Writer is an abstract class for writing object files, shared
 /// library files, and executable files.  Each file format (e.g. mach-o, etc)
 /// has a concrete subclass of Writer.
 class Writer {
 public:
   virtual ~Writer();
 
-  /// \brief Write a file from the supplied File object
+  /// Write a file from the supplied File object
   virtual llvm::Error writeFile(const File &linkedFile, StringRef path) = 0;
 
-  /// \brief This method is called by Core Linking to give the Writer a chance
+  /// This method is called by Core Linking to give the Writer a chance
   /// to add file format specific "files" to set of files to be linked. This is
   /// how file format specific atoms can be added to the link.
   virtual void createImplicitFiles(std::vector<std::unique_ptr<File>> &) {}
 
 protected:
   // only concrete subclasses can be instantiated
   Writer();
 };
 
 std::unique_ptr<Writer> createWriterMachO(const MachOLinkingContext &);
 std::unique_ptr<Writer> createWriterYAML(const LinkingContext &);
 } // end namespace lld
 
 #endif

include/lld/ReaderWriter/MachOLinkingContext.h

public:
   uint32_t sdkVersion() const { return _sdkVersion; }
   void setSdkVersion(uint64_t v) { _sdkVersion = v; }
 
   uint64_t sourceVersion() const { return _sourceVersion; }
   void setSourceVersion(uint64_t v) { _sourceVersion = v; }
 
   uint32_t swiftVersion() const { return _swiftVersion; }
 
-  /// \brief Checks whether a given path on the filesystem exists.
+  /// Checks whether a given path on the filesystem exists.
   ///
   /// When running in -test_file_usage mode, this method consults an
   /// internally maintained list of files that exist (provided by -path_exists)
   /// instead of the actual filesystem.
   bool pathExists(StringRef path) const;
 
   /// Like pathExists() but only used on files - not directories.
   bool fileExists(StringRef path) const;
 
-  /// \brief Adds any library search paths derived from the given base, possibly
+  /// Adds any library search paths derived from the given base, possibly
   /// modified by -syslibroots.
   ///
   /// The set of paths added consists of approximately all syslibroot-prepended
   /// versions of libPath that exist, or the original libPath if there are none
   /// for whatever reason. With various edge-cases for compatibility.
   void addModifiedSearchDir(StringRef libPath, bool isSystemPath = false);
 
-  /// \brief Determine whether -lFoo can be resolve within the given path, and
+  /// Determine whether -lFoo can be resolve within the given path, and
   /// return the filename if so.
   ///
   /// The -lFoo option is documented to search for libFoo.dylib and libFoo.a in
   /// that order, unless Foo ends in ".o", in which case only the exact file
   /// matches (e.g. -lfoo.o would only find foo.o).
   llvm::Optional<StringRef> searchDirForLibrary(StringRef path,
                                                 StringRef libName) const;
 
-  /// \brief Iterates through all search path entries looking for libName (as
+  /// Iterates through all search path entries looking for libName (as
   /// specified by -lFoo).
   llvm::Optional<StringRef> searchLibrary(StringRef libName) const;
 
   /// Add a framework search path.  Internally, this method may be prepended
   /// the path with syslibroot.
   void addFrameworkSearchDir(StringRef fwPath, bool isSystemPath = false);
 
-  /// \brief Iterates through all framework directories looking for
+  /// Iterates through all framework directories looking for
   /// Foo.framework/Foo (when fwName = "Foo").
   llvm::Optional<StringRef> findPathForFramework(StringRef fwName) const;
 
-  /// \brief The dylib's binary compatibility version, in the raw uint32 format.
+  /// The dylib's binary compatibility version, in the raw uint32 format.
   ///
   /// When building a dynamic library, this is the compatibility version that
   /// gets embedded into the result. Other Mach-O binaries that link against
   /// this library will store the compatibility version in its load command. At
   /// runtime, the loader will verify that the binary is compatible with the
   /// installed dynamic library.
   uint32_t compatibilityVersion() const { return _compatibilityVersion; }
 
-  /// \brief The dylib's current version, in the the raw uint32 format.
+  /// The dylib's current version, in the the raw uint32 format.
   ///
   /// When building a dynamic library, this is the current version that gets
   /// embedded into the result. Other Mach-O binaries that link against
   /// this library will store the compatibility version in its load command.
   uint32_t currentVersion() const { return _currentVersion; }
 
-  /// \brief The dylib's install name.
+  /// The dylib's install name.
   ///
   /// Binaries that link against the dylib will embed this path into the dylib
   /// load command. When loading the binaries at runtime, this is the location
   /// on disk that the loader will look for the dylib.
   StringRef installName() const { return _installName; }
 
-  /// \brief Whether or not the dylib has side effects during initialization.
+  /// Whether or not the dylib has side effects during initialization.
   ///
   /// Dylibs marked as being dead strippable provide the guarantee that loading
   /// the dylib has no side effects, allowing the linker to strip out the dylib
   /// when linking a binary that does not use any of its symbols.
   bool deadStrippableDylib() const { return _deadStrippableDylib; }
 
-  /// \brief Whether or not to use flat namespace.
+  /// Whether or not to use flat namespace.
   ///
   /// MachO usually uses a two-level namespace, where each external symbol
   /// referenced by the target is associated with the dylib that will provide
   /// the symbol's definition at runtime. Using flat namespace overrides this
   /// behavior: the linker searches all dylibs on the command line and all
   /// dylibs those original dylibs depend on, but does not record which dylib
   /// an external symbol came from. At runtime dyld again searches all images
   /// and uses the first definition it finds. In addition, any undefines in
   /// loaded flat_namespace dylibs must be resolvable at build time.
   bool useFlatNamespace() const { return _flatNamespace; }
 
-  /// \brief How to handle undefined symbols.
+  /// How to handle undefined symbols.
   ///
   /// Options are:
   ///  * error: Report an error and terminate linking.
   ///  * warning: Report a warning, but continue linking.
   ///  * suppress: Ignore and continue linking.
   ///  * dynamic_lookup: For use with -twolevel namespace: Records source dylibs
   ///    for symbols that are defined in a linked dylib at static link time.
   ///    Undefined symbols are handled by searching all loaded images at
   ///    runtime.
   UndefinedMode undefinedMode() const { return _undefinedMode; }
 
-  /// \brief The path to the executable that will load the bundle at runtime.
+  /// The path to the executable that will load the bundle at runtime.
   ///
   /// When building a Mach-O bundle, this executable will be examined if there
   /// are undefined symbols after the main link phase. It is expected that this
   /// binary will be loading the bundle at runtime and will provide the symbols
   /// at that point.
   StringRef bundleLoader() const { return _bundleLoader; }
 
   void setCompatibilityVersion(uint32_t vers) { _compatibilityVersion = vers; }
public:
   }
 
   void addRpath(StringRef rpath);
   const StringRefVector &rpaths() const { return _rpaths; }
 
   /// Add section alignment constraint on final layout.
   void addSectionAlignment(StringRef seg, StringRef sect, uint16_t align);
 
-  /// \brief Add a section based on a command-line sectcreate option.
+  /// Add a section based on a command-line sectcreate option.
   void addSectCreateSection(StringRef seg, StringRef sect,
                             std::unique_ptr<MemoryBuffer> content);
 
   /// Returns true if specified section had alignment constraints.
   bool sectionAligned(StringRef seg, StringRef sect, uint16_t &align) const;
 
   StringRef dyldPath() const { return "/usr/lib/dyld"; }
 

lib/ReaderWriter/FileArchive.cpp

 using llvm::object::Archive;
 using llvm::file_magic;
 using llvm::identify_magic;
 
 namespace lld {
 
 namespace {
 
-/// \brief The FileArchive class represents an Archive Library file
+/// The FileArchive class represents an Archive Library file
 class FileArchive : public lld::ArchiveLibraryFile {
 public:
   FileArchive(std::unique_ptr<MemoryBuffer> mb, const Registry &reg,
               StringRef path, bool logLoading)
       : ArchiveLibraryFile(path), _mb(std::shared_ptr<MemoryBuffer>(mb.release())),
         _registry(reg), _logLoading(logLoading) {}
 
-  /// \brief Check if any member of the archive contains an Atom with the
+  /// Check if any member of the archive contains an Atom with the
   /// specified name and return the File object for that member, or nullptr.
   File *find(StringRef name) override {
     auto member = _symbolMemberMap.find(name);
     if (member == _symbolMemberMap.end())
       return nullptr;
     Archive::Child c = member->second;
 
     // Don't return a member already returned
File *find(StringRef name) override {
 
     File *file = result.get();
     _filesReturned.push_back(std::move(result));
 
     // Give up the file pointer. It was stored and will be destroyed with destruction of FileArchive
     return file;
   }
 
-  /// \brief parse each member
+  /// parse each member
   std::error_code
   parseAllMembers(std::vector<std::unique_ptr<File>> &result) override {
     if (std::error_code ec = parse())
       return ec;
     llvm::Error err = llvm::Error::success();
     for (auto mf = _archive->child_begin(err), me = _archive->child_end();
          mf != me; ++mf) {
       std::unique_ptr<File> file;

unittests/DriverTests/DarwinLdDriverTest.cpp

 //===- lld/unittest/DarwinLdDriverTest.cpp --------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// \brief Darwin's ld driver tests.
+/// Darwin's ld driver tests.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "lld/Common/Driver.h"
 #include "lld/ReaderWriter/MachOLinkingContext.h"
 #include "llvm/BinaryFormat/MachO.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"