Fix a bunch of Doxygen syntax issues. Escape special characters,

and put @file directives on their own comment line.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@65920 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/CodeGen/MachineConstantPool.h

@@ -7,7 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-/// @file This file declares the MachineConstantPool class which is an abstract
+/// @file
+/// This file declares the MachineConstantPool class which is an abstract
 /// constant pool to keep track of constants referenced by a function.
 //
 //===----------------------------------------------------------------------===//

include/llvm/CodeGen/MachineFrameInfo.h

@@ -119,7 +119,7 @@ class MachineFrameInfo {
   bool HasVarSizedObjects;
 
   /// FrameAddressTaken - This boolean keeps track of whether there is a call
-  /// to builtin @llvm.frameaddress.
+  /// to builtin \@llvm.frameaddress.
   bool FrameAddressTaken;
 
   /// StackSize - The prolog/epilog code inserter calculates the final stack
@@ -207,7 +207,7 @@ public:
 
   /// isFrameAddressTaken - This method may be called any time after instruction
   /// selection is complete to determine if there is a call to
-  /// @llvm.frameaddress in this function.
+  /// \@llvm.frameaddress in this function.
   bool isFrameAddressTaken() const { return FrameAddressTaken; }
   void setFrameAddressIsTaken(bool T) { FrameAddressTaken = T; }
 

include/llvm/CodeGen/RegisterCoalescer.h

@@ -64,7 +64,7 @@ namespace llvm {
   ///
   ///   class LinearScanRegallocQuery : public RegallocQuery {
   ///   private:
-  ///     const LiveIntervals &li;
+  ///     const LiveIntervals \&li;
   ///
   ///   public:
   ///     LinearScanRegallocQuery(LiveIntervals &intervals) 

include/llvm/CodeGen/SelectionDAGNodes.h

@@ -1125,7 +1125,7 @@ public:
   unsigned getOpcode()  const { return (unsigned short)NodeType; }
 
   /// isTargetOpcode - Test if this node has a target-specific opcode (in the
-  /// <target>ISD namespace).
+  /// \<target\>ISD namespace).
   bool isTargetOpcode() const { return NodeType >= ISD::BUILTIN_OP_END; }
 
   /// isMachineOpcode - Test if this node has a post-isel opcode, directly

include/llvm/Constants.h

@@ -7,7 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-/// @file This file contains the declarations for the subclasses of Constant, 
+/// @file
+/// This file contains the declarations for the subclasses of Constant, 
 /// which represent the different flavors of constant values that live in LLVM.
 /// Note that Constants are immutable (once created they never change) and are 
 /// fully shared by structural equivalence.  This means that two structurally

include/llvm/Module.h

@@ -7,7 +7,8 @@
 //
 //===----------------------------------------------------------------------===//
 //
-/// @file This file contains the declarations for the Module class.
+/// @file
+/// Module.h This file contains the declarations for the Module class.
 //
 //===----------------------------------------------------------------------===//
 

include/llvm/System/IncludeFile.h

@@ -64,7 +64,8 @@ namespace llvm {
 /// helps to resolve that problem. The basic strategy is to use this class in
 /// a header file and pass the address of a variable to the constructor. If the
 /// variable is defined in the header file's corresponding .cpp file then all
-/// tools/libraries that #include the header file will require the .cpp as well.
+/// tools/libraries that \#include the header file will require the .cpp as
+/// well.
 /// For example:<br/>
 /// <tt>extern int LinkMyCodeStub;</tt><br/>
 /// <tt>static IncludeFile LinkMyModule(&LinkMyCodeStub);</tt><br/>

include/llvm/Target/TargetLowering.h

@@ -1597,7 +1597,7 @@ private:
   ISD::CondCode CmpLibcallCCs[RTLIB::UNKNOWN_LIBCALL];
 
 protected:
-  /// When lowering @llvm.memset this field specifies the maximum number of
+  /// When lowering \@llvm.memset this field specifies the maximum number of
   /// store operations that may be substituted for the call to memset. Targets
   /// must set this value based on the cost threshold for that target. Targets
   /// should assume that the memset will be done using as many of the largest
@@ -1608,7 +1608,7 @@ protected:
   /// @brief Specify maximum number of store instructions per memset call.
   unsigned maxStoresPerMemset;
 
-  /// When lowering @llvm.memcpy this field specifies the maximum number of
+  /// When lowering \@llvm.memcpy this field specifies the maximum number of
   /// store operations that may be substituted for a call to memcpy. Targets
   /// must set this value based on the cost threshold for that target. Targets
   /// should assume that the memcpy will be done using as many of the largest
@@ -1620,7 +1620,7 @@ protected:
   /// @brief Specify maximum bytes of store instructions per memcpy call.
   unsigned maxStoresPerMemcpy;
 
-  /// When lowering @llvm.memmove this field specifies the maximum number of
+  /// When lowering \@llvm.memmove this field specifies the maximum number of
   /// store instructions that may be substituted for a call to memmove. Targets
   /// must set this value based on the cost threshold for that target. Targets
   /// should assume that the memmove will be done using as many of the largest

lib/Target/ARM/AsmPrinter/ARMAsmPrinter.cpp

@@ -799,7 +799,7 @@ bool ARMAsmPrinter::doInitialization(Module &M) {
 }
 
 /// PrintUnmangledNameSafely - Print out the printable characters in the name.
-/// Don't print things like \n or \0.
+/// Don't print things like \\n or \\0.
 static void PrintUnmangledNameSafely(const Value *V, raw_ostream &OS) {
   for (const char *Name = V->getNameStart(), *E = Name+V->getNameLen();
        Name != E; ++Name)

lib/Target/CellSPU/AsmPrinter/SPUAsmPrinter.cpp

@@ -496,7 +496,7 @@ bool LinuxAsmPrinter::doInitialization(Module &M) {
 }
 
 /// PrintUnmangledNameSafely - Print out the printable characters in the name.
-/// Don't print things like \n or \0.
+/// Don't print things like \\n or \\0.
 static void PrintUnmangledNameSafely(const Value *V, raw_ostream &OS) {
   for (const char *Name = V->getNameStart(), *E = Name+V->getNameLen();
        Name != E; ++Name)

lib/Target/PowerPC/AsmPrinter/PPCAsmPrinter.cpp

@@ -657,7 +657,7 @@ bool PPCLinuxAsmPrinter::doInitialization(Module &M) {
 }
 
 /// PrintUnmangledNameSafely - Print out the printable characters in the name.
-/// Don't print things like \n or \0.
+/// Don't print things like \\n or \\0.
 static void PrintUnmangledNameSafely(const Value *V, raw_ostream &OS) {
   for (const char *Name = V->getNameStart(), *E = Name+V->getNameLen();
        Name != E; ++Name)

lib/Target/PowerPC/PPCRegisterInfo.cpp

@@ -467,9 +467,9 @@ unsigned findScratchRegister(MachineBasicBlock::iterator II, RegScavenger *RS,
 /// lowerDynamicAlloc - Generate the code for allocating an object in the
 /// current frame.  The sequence of code with be in the general form
 ///
-///   addi   R0, SP, #frameSize ; get the address of the previous frame
+///   addi   R0, SP, \#frameSize ; get the address of the previous frame
 ///   stwxu  R0, SP, Rnegsize   ; add and update the SP with the negated size
-///   addi   Rnew, SP, #maxCalFrameSize ; get the top of the allocation
+///   addi   Rnew, SP, \#maxCalFrameSize ; get the top of the allocation
 ///
 void PPCRegisterInfo::lowerDynamicAlloc(MachineBasicBlock::iterator II,
                                         int SPAdj, RegScavenger *RS) const {

lib/Target/X86/AsmPrinter/X86ATTAsmPrinter.cpp

@@ -85,7 +85,7 @@ static X86MachineFunctionInfo calculateFunctionInfo(const Function *F,
 }
 
 /// PrintUnmangledNameSafely - Print out the printable characters in the name.
-/// Don't print things like \n or \0.
+/// Don't print things like \\n or \\0.
 static void PrintUnmangledNameSafely(const Value *V, raw_ostream &OS) {
   for (const char *Name = V->getNameStart(), *E = Name+V->getNameLen();
        Name != E; ++Name)

lib/Transforms/Scalar/InstructionCombining.cpp

@@ -11381,9 +11381,9 @@ static Instruction *InstCombineStoreToCast(InstCombiner &IC, StoreInst &SI) {
 /// equivalentAddressValues - Test if A and B will obviously have the same
 /// value. This includes recognizing that %t0 and %t1 will have the same
 /// value in code like this:
-///   %t0 = getelementptr @a, 0, 3
+///   %t0 = getelementptr \@a, 0, 3
 ///   store i32 0, i32* %t0
-///   %t1 = getelementptr @a, 0, 3
+///   %t1 = getelementptr \@a, 0, 3
 ///   %t2 = load i32* %t1
 ///
 static bool equivalentAddressValues(Value *A, Value *B) {

lib/Transforms/Utils/BasicBlockUtils.cpp

@@ -425,9 +425,9 @@ BasicBlock *llvm::SplitBlockPredecessors(BasicBlock *BB,
 /// AreEquivalentAddressValues - Test if A and B will obviously have the same
 /// value. This includes recognizing that %t0 and %t1 will have the same
 /// value in code like this:
-///   %t0 = getelementptr @a, 0, 3
+///   %t0 = getelementptr \@a, 0, 3
 ///   store i32 0, i32* %t0
-///   %t1 = getelementptr @a, 0, 3
+///   %t1 = getelementptr \@a, 0, 3
 ///   %t2 = load i32* %t1
 ///
 static bool AreEquivalentAddressValues(const Value *A, const Value *B) {

lib/VMCore/Constants.cpp

@@ -1277,8 +1277,8 @@ ConstantAggregateZero *ConstantAggregateZero::get(const Type *Ty) {
   return AggZeroConstants->getOrCreate(Ty, 0);
 }
 
-// destroyConstant - Remove the constant from the constant table...
-//
+/// destroyConstant - Remove the constant from the constant table...
+///
 void ConstantAggregateZero::destroyConstant() {
   AggZeroConstants->remove(this);
   destroyConstantImpl();
@@ -1328,8 +1328,8 @@ Constant *ConstantArray::get(const ArrayType *Ty,
   return ConstantAggregateZero::get(Ty);
 }
 
-// destroyConstant - Remove the constant from the constant table...
-//
+/// destroyConstant - Remove the constant from the constant table...
+///
 void ConstantArray::destroyConstant() {
   ArrayConstants->remove(this);
   destroyConstantImpl();
@@ -1370,7 +1370,7 @@ bool ConstantArray::isString() const {
 }
 
 /// isCString - This method returns true if the array is a string (see
-/// isString) and it ends in a null byte \0 and does not contains any other
+/// isString) and it ends in a null byte \\0 and does not contains any other
 /// null bytes except its terminator.
 bool ConstantArray::isCString() const {
   // Check the element type for i8...
@@ -1391,10 +1391,10 @@ bool ConstantArray::isCString() const {
 }
 
 
-// getAsString - If the sub-element type of this array is i8
-// then this method converts the array to an std::string and returns it.
-// Otherwise, it asserts out.
-//
+/// getAsString - If the sub-element type of this array is i8
+/// then this method converts the array to an std::string and returns it.
+/// Otherwise, it asserts out.
+///
 std::string ConstantArray::getAsString() const {
   assert(isString() && "Not a string!");
   std::string Result;