2 files changed, 23 insertions, 24 deletions

diff --git a/llvm/include/llvm/CodeGen/TargetSubtargetInfo.h b/llvm/include/llvm/CodeGen/TargetSubtargetInfo.h
index 0175b1e53cf..e28673de225 100644
--- a/llvm/include/llvm/CodeGen/TargetSubtargetInfo.h
+++ b/llvm/include/llvm/CodeGen/TargetSubtargetInfo.h
@@ -145,27 +145,26 @@ public:
     return 0;
   }
 
-  /// Returns true if \param MI is a dependency breaking zero-idiom instruction
-  /// for the subtarget.
+  /// Returns true if MI is a dependency breaking zero-idiom instruction for the
+  /// subtarget.
   ///
-  /// This function also sets bits in \param Mask related to input operands that
+  /// This function also sets bits in Mask related to input operands that
   /// are not in a data dependency relationship.  There is one bit for each
   /// machine operand; implicit operands follow explicit operands in the bit
-  /// representation used for \param Mask.  An empty \param Mask (i.e. a mask
-  /// with all bits cleared) means: data dependencies are "broken" for all the
-  /// explicit input machine operands of \param MI.
+  /// representation used for Mask.  An empty (i.e. a mask with all bits
+  /// cleared) means: data dependencies are "broken" for all the explicit input
+  /// machine operands of MI.
   virtual bool isZeroIdiom(const MachineInstr *MI, APInt &Mask) const {
     return false;
   }
 
-  /// Returns true if \param MI is a dependency breaking instruction for the
-  /// subtarget.
+  /// Returns true if MI is a dependency breaking instruction for the subtarget.
   ///
   /// Similar in behavior to `isZeroIdiom`. However, it knows how to identify
   /// all dependency breaking instructions (i.e. not just zero-idioms).
   /// 
   /// As for `isZeroIdiom`, this method returns a mask of "broken" dependencies.
-  /// (See method `isZeroIdiom` for a detailed description of \param Mask).
+  /// (See method `isZeroIdiom` for a detailed description of Mask).
   virtual bool isDependencyBreaking(const MachineInstr *MI, APInt &Mask) const {
     return isZeroIdiom(MI, Mask);
   }
diff --git a/llvm/include/llvm/MC/MCInstrAnalysis.h b/llvm/include/llvm/MC/MCInstrAnalysis.h
index 0e7dd86c33f..950a1afeef5 100644
--- a/llvm/include/llvm/MC/MCInstrAnalysis.h
+++ b/llvm/include/llvm/MC/MCInstrAnalysis.h
@@ -88,22 +88,22 @@ public:
                                     const MCInst &Inst,
                                     APInt &Writes) const;
 
-  /// Returns true if \param MI is a dependency breaking zero-idiom for the
-  /// given subtarget.
+  /// Returns true if MI is a dependency breaking zero-idiom for the given
+  /// subtarget.
   ///
-  /// \param Mask is used to identify input operands that have their dependency
+  /// Mask is used to identify input operands that have their dependency
   /// broken. Each bit of the mask is associated with a specific input operand.
   /// Bits associated with explicit input operands are laid out first in the
   /// mask; implicit operands come after explicit operands.
   /// 
   /// Dependencies are broken only for operands that have their corresponding bit
   /// set. Operands that have their bit cleared, or that don't have a
-  /// corresponding bit in the mask don't have their dependency broken.
-  /// Note that \param Mask may not be big enough to describe all operands.
-  /// The assumption for operands that don't have a correspondent bit in the
-  /// mask is that those are still data dependent.
+  /// corresponding bit in the mask don't have their dependency broken.  Note
+  /// that Mask may not be big enough to describe all operands.  The assumption
+  /// for operands that don't have a correspondent bit in the mask is that those
+  /// are still data dependent.
   /// 
-  /// The only exception to the rule is for when \param Mask has all zeroes.
+  /// The only exception to the rule is for when Mask has all zeroes.
   /// A zero mask means: dependencies are broken for all explicit register
   /// operands.
   virtual bool isZeroIdiom(const MCInst &MI, APInt &Mask,
@@ -111,26 +111,26 @@ public:
     return false;
   }
 
-  /// Returns true if \param MI is a dependency breaking instruction for the
-  /// subtarget associated with \param CPUID.
+  /// Returns true if MI is a dependency breaking instruction for the
+  /// subtarget associated with CPUID .
   ///
   /// The value computed by a dependency breaking instruction is not dependent
   /// on the inputs. An example of dependency breaking instruction on X86 is
   /// `XOR %eax, %eax`.
   ///
-  /// If \param MI is a dependency breaking instruction for subtarget \param
-  /// CPUID, then \param Mask can be inspected to identify independent operands.
+  /// If MI is a dependency breaking instruction for subtarget CPUID, then Mask
+  /// can be inspected to identify independent operands.
   ///
   /// Essentially, each bit of the mask corresponds to an input operand.
   /// Explicit operands are laid out first in the mask; implicit operands follow
   /// explicit operands. Bits are set for operands that are independent.
   ///
   /// Note that the number of bits in Mask may not be equivalent to the sum of
-  /// explicit and implicit operands in \param MI. Operands that don't have a
+  /// explicit and implicit operands in MI. Operands that don't have a
   /// corresponding bit in Mask are assumed "not independente".
   ///
-  /// The only exception is for when \param Mask is all zeroes. That means:
-  /// explicit input operands of \param MI are independent.
+  /// The only exception is for when Mask is all zeroes. That means: explicit
+  /// input operands of MI are independent.
   virtual bool isDependencyBreaking(const MCInst &MI, APInt &Mask,
                                     unsigned CPUID) const {
     return isZeroIdiom(MI, Mask, CPUID);