[llvm] r342640 - Fix -Wdocumentation warnings introduced by r342555. NFC
Andrea Di Biagio via llvm-commits
llvm-commits at lists.llvm.org
Thu Sep 20 04:07:57 PDT 2018
Author: adibiagio
Date: Thu Sep 20 04:07:57 2018
New Revision: 342640
URL: http://llvm.org/viewvc/llvm-project?rev=342640&view=rev
Log:
Fix -Wdocumentation warnings introduced by r342555. NFC
These were reported by buildbot llvm-clang-lld-x86_64-scei-ps4-ubuntu-fast (see
build #36798).
Modified:
llvm/trunk/include/llvm/CodeGen/TargetSubtargetInfo.h
llvm/trunk/include/llvm/MC/MCInstrAnalysis.h
Modified: llvm/trunk/include/llvm/CodeGen/TargetSubtargetInfo.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/TargetSubtargetInfo.h?rev=342640&r1=342639&r2=342640&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/TargetSubtargetInfo.h (original)
+++ llvm/trunk/include/llvm/CodeGen/TargetSubtargetInfo.h Thu Sep 20 04:07:57 2018
@@ -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);
}
Modified: llvm/trunk/include/llvm/MC/MCInstrAnalysis.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/MC/MCInstrAnalysis.h?rev=342640&r1=342639&r2=342640&view=diff
==============================================================================
--- llvm/trunk/include/llvm/MC/MCInstrAnalysis.h (original)
+++ llvm/trunk/include/llvm/MC/MCInstrAnalysis.h Thu Sep 20 04:07:57 2018
@@ -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);
More information about the llvm-commits
mailing list