fix documentation comments; NFC

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

Author: rotateright

include/llvm/CodeGen/MachineMemOperand.h

@@ -30,12 +30,11 @@ class raw_ostream;
 class MachineFunction;
 class ModuleSlotTracker;
 
-/// MachinePointerInfo - This class contains a discriminated union of
-/// information about pointers in memory operands, relating them back to LLVM IR
-/// or to virtual locations (such as frame indices) that are exposed during
-/// codegen.
+/// This class contains a discriminated union of information about pointers in
+/// memory operands, relating them back to LLVM IR or to virtual locations (such
+/// as frame indices) that are exposed during codegen.
 struct MachinePointerInfo {
-  /// V - This is the IR pointer value for the access, or it is null if unknown.
+  /// This is the IR pointer value for the access, or it is null if unknown.
   /// If this is null, then the access is to a pointer in the default address
   /// space.
   PointerUnion<const Value *, const PseudoSourceValue *> V;
@@ -57,34 +56,30 @@ struct MachinePointerInfo {
     return MachinePointerInfo(V.get<const PseudoSourceValue*>(), Offset+O);
   }
 
-  /// getAddrSpace - Return the LLVM IR address space number that this pointer
-  /// points into.
+  /// Return the LLVM IR address space number that this pointer points into.
   unsigned getAddrSpace() const;
 
-  /// getConstantPool - Return a MachinePointerInfo record that refers to the
-  /// constant pool.
+  /// Return a MachinePointerInfo record that refers to the constant pool.
   static MachinePointerInfo getConstantPool(MachineFunction &MF);
 
-  /// getFixedStack - Return a MachinePointerInfo record that refers to the
-  /// the specified FrameIndex.
+  /// Return a MachinePointerInfo record that refers to the specified
+  /// FrameIndex.
   static MachinePointerInfo getFixedStack(MachineFunction &MF, int FI,
                                           int64_t Offset = 0);
 
-  /// getJumpTable - Return a MachinePointerInfo record that refers to a
-  /// jump table entry.
+  /// Return a MachinePointerInfo record that refers to a jump table entry.
   static MachinePointerInfo getJumpTable(MachineFunction &MF);
 
-  /// getGOT - Return a MachinePointerInfo record that refers to a
-  /// GOT entry.
+  /// Return a MachinePointerInfo record that refers to a GOT entry.
   static MachinePointerInfo getGOT(MachineFunction &MF);
 
-  /// getStack - stack pointer relative access.
+  /// Stack pointer relative access.
   static MachinePointerInfo getStack(MachineFunction &MF, int64_t Offset);
 };
 
 
 //===----------------------------------------------------------------------===//
-/// MachineMemOperand - A description of a memory reference used in the backend.
+/// A description of a memory reference used in the backend.
 /// Instead of holding a StoreInst or LoadInst, this class holds the address
 /// Value of the reference along with a byte size and offset. This allows it
 /// to describe lowered loads and stores. Also, the special PseudoSourceValue
@@ -118,17 +113,17 @@ class MachineMemOperand {
     MOMaxBits = 8
   };
 
-  /// MachineMemOperand - Construct an MachineMemOperand object with the
-  /// specified PtrInfo, flags, size, and base alignment.
+  /// Construct a MachineMemOperand object with the specified PtrInfo, flags,
+  /// size, and base alignment.
   MachineMemOperand(MachinePointerInfo PtrInfo, unsigned flags, uint64_t s,
                     unsigned base_alignment,
                     const AAMDNodes &AAInfo = AAMDNodes(),
                     const MDNode *Ranges = nullptr);
 
   const MachinePointerInfo &getPointerInfo() const { return PtrInfo; }
 
-  /// getValue - Return the base address of the memory access. This may either
-  /// be a normal LLVM IR Value, or one of the special values used in CodeGen.
+  /// Return the base address of the memory access. This may either be a normal
+  /// LLVM IR Value, or one of the special values used in CodeGen.
   /// Special values are those obtained via
   /// PseudoSourceValue::getFixedStack(int), PseudoSourceValue::getStack, and
   /// other PseudoSourceValue member functions which return objects which stand
@@ -142,34 +137,33 @@ class MachineMemOperand {
 
   const void *getOpaqueValue() const { return PtrInfo.V.getOpaqueValue(); }
 
-  /// getFlags - Return the raw flags of the source value, \see MemOperandFlags.
+  /// Return the raw flags of the source value, \see MemOperandFlags.
   unsigned int getFlags() const { return Flags & ((1 << MOMaxBits) - 1); }
 
   /// Bitwise OR the current flags with the given flags.
   void setFlags(unsigned f) { Flags |= (f & ((1 << MOMaxBits) - 1)); }
 
-  /// getOffset - For normal values, this is a byte offset added to the base
-  /// address. For PseudoSourceValue::FPRel values, this is the FrameIndex
-  /// number.
+  /// For normal values, this is a byte offset added to the base address.
+  /// For PseudoSourceValue::FPRel values, this is the FrameIndex number.
   int64_t getOffset() const { return PtrInfo.Offset; }
 
   unsigned getAddrSpace() const { return PtrInfo.getAddrSpace(); }
 
-  /// getSize - Return the size in bytes of the memory reference.
+  /// Return the size in bytes of the memory reference.
   uint64_t getSize() const { return Size; }
 
-  /// getAlignment - Return the minimum known alignment in bytes of the
-  /// actual memory reference.
+  /// Return the minimum known alignment in bytes of the actual memory
+  /// reference.
   uint64_t getAlignment() const;
 
-  /// getBaseAlignment - Return the minimum known alignment in bytes of the
-  /// base address, without the offset.
+  /// Return the minimum known alignment in bytes of the base address, without
+  /// the offset.
   uint64_t getBaseAlignment() const { return (1u << (Flags >> MOMaxBits)) >> 1; }
 
-  /// getAAInfo - Return the AA tags for the memory reference.
+  /// Return the AA tags for the memory reference.
   AAMDNodes getAAInfo() const { return AAInfo; }
 
-  /// getRanges - Return the range tag for the memory reference.
+  /// Return the range tag for the memory reference.
   const MDNode *getRanges() const { return Ranges; }
 
   bool isLoad() const { return Flags & MOLoad; }
@@ -178,23 +172,23 @@ class MachineMemOperand {
   bool isNonTemporal() const { return Flags & MONonTemporal; }
   bool isInvariant() const { return Flags & MOInvariant; }
 
-  /// isUnordered - Returns true if this memory operation doesn't have any
-  /// ordering constraints other than normal aliasing. Volatile and atomic
-  /// memory operations can't be reordered.
+  /// Returns true if this memory operation doesn't have any ordering
+  /// constraints other than normal aliasing. Volatile and atomic memory
+  /// operations can't be reordered.
   ///
   /// Currently, we don't model the difference between volatile and atomic
   /// operations. They should retain their ordering relative to all memory
   /// operations.
   bool isUnordered() const { return !isVolatile(); }
 
-  /// refineAlignment - Update this MachineMemOperand to reflect the alignment
-  /// of MMO, if it has a greater alignment. This must only be used when the
-  /// new alignment applies to all users of this MachineMemOperand.
+  /// Update this MachineMemOperand to reflect the alignment of MMO, if it has a
+  /// greater alignment. This must only be used when the new alignment applies
+  /// to all users of this MachineMemOperand.
   void refineAlignment(const MachineMemOperand *MMO);
 
-  /// setValue - Change the SourceValue for this MachineMemOperand. This
-  /// should only be used when an object is being relocated and all references
-  /// to it are being updated.
+  /// Change the SourceValue for this MachineMemOperand. This should only be
+  /// used when an object is being relocated and all references to it are being
+  /// updated.
   void setValue(const Value *NewSV) { PtrInfo.V = NewSV; }
   void setValue(const PseudoSourceValue *NewSV) { PtrInfo.V = NewSV; }
   void setOffset(int64_t NewOffset) { PtrInfo.Offset = NewOffset; }