Rename MemOperand to MachineMemOperand. This was suggested by

review feedback from Chris quite a while ago. No functionality
change.


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

include/llvm/CodeGen/MachineInstr.h

@@ -17,7 +17,7 @@
 #define LLVM_CODEGEN_MACHINEINSTR_H
 
 #include "llvm/CodeGen/MachineOperand.h"
-#include "llvm/CodeGen/MemOperand.h"
+#include "llvm/CodeGen/MachineMemOperand.h"
 
 namespace llvm {
 
@@ -37,7 +37,7 @@ class MachineInstr {
                                         // are determined at construction time).
 
   std::vector<MachineOperand> Operands; // the operands
-  std::vector<MemOperand> MemOperands;  // information on memory references
+  std::vector<MachineMemOperand> MemOperands;// information on memory references
   MachineInstr *Prev, *Next;            // Links for MBB's intrusive list.
   MachineBasicBlock *Parent;            // Pointer to the owning basic block.
 
@@ -100,11 +100,11 @@ public:
   /// Access to memory operands of the instruction
   unsigned getNumMemOperands() const { return MemOperands.size(); }
 
-  const MemOperand& getMemOperand(unsigned i) const {
+  const MachineMemOperand& getMemOperand(unsigned i) const {
     assert(i < getNumMemOperands() && "getMemOperand() out of range!");
     return MemOperands[i];
   }
-  MemOperand& getMemOperand(unsigned i) {
+  MachineMemOperand& getMemOperand(unsigned i) {
     assert(i < getNumMemOperands() && "getMemOperand() out of range!");
     return MemOperands[i];
   }
@@ -268,9 +268,9 @@ public:
   ///
   void RemoveOperand(unsigned i);
 
-  /// addMemOperand - Add a MemOperand to the machine instruction, referencing
-  /// arbitrary storage.
-  void addMemOperand(const MemOperand &MO) {
+  /// addMemOperand - Add a MachineMemOperand to the machine instruction,
+  /// referencing arbitrary storage.
+  void addMemOperand(const MachineMemOperand &MO) {
     MemOperands.push_back(MO);
   }
 

include/llvm/CodeGen/MachineInstrBuilder.h

@@ -85,7 +85,7 @@ public:
   }
 
   /// addMemOperand - Add a memory operand to the machine instruction.
-  const MachineInstrBuilder &addMemOperand(const MemOperand &MO) const {
+  const MachineInstrBuilder &addMemOperand(const MachineMemOperand &MO) const {
     MI->addMemOperand(MO);
     return *this;
   }

include/llvm/CodeGen/MachineMemOperand.h

@@ -1,4 +1,4 @@
-//===-- llvm/CodeGen/MemOperand.h - MemOperand class ------------*- C++ -*-===//
+//==- llvm/CodeGen/MachineMemOperand.h - MachineMemOperand class -*- C++ -*-==//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file contains the declaration of the MemOperand class, which is a
+// This file contains the declaration of the MachineMemOperand class, which is a
 // description of a memory reference. It is used to help track dependencies
 // in the backend.
 //
@@ -21,14 +21,14 @@ namespace llvm {
 class Value;
 
 //===----------------------------------------------------------------------===//
-/// MemOperand - A description of a memory reference used in the backend.
+/// MachineMemOperand - 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
 /// objects can be used to represent loads and stores to memory locations
 /// that aren't explicit in the regular LLVM IR.
 ///
-class MemOperand {
+class MachineMemOperand {
   const Value *V;
   unsigned int Flags;
   int64_t Offset;
@@ -46,10 +46,10 @@ public:
     MOVolatile = 4
   };
 
-  /// MemOperand - Construct an MemOperand object with the specified
-  /// address Value, flags, offset, size, and alignment.
-  MemOperand(const Value *v, unsigned int f, int64_t o, uint64_t s,
-             unsigned int a)
+  /// MachineMemOperand - Construct an MachineMemOperand object with the
+  /// specified address Value, flags, offset, size, and alignment.
+  MachineMemOperand(const Value *v, unsigned int f, int64_t o, uint64_t s,
+                    unsigned int a)
     : V(v), Flags(f), Offset(o), Size(s), Alignment(a) {}
 
   /// getValue - Return the base address of the memory access.

include/llvm/CodeGen/ScheduleDAG.h

@@ -365,7 +365,7 @@ namespace llvm {
                     const TargetInstrDesc *II,
                     DenseMap<SDOperandImpl, unsigned> &VRBaseMap);
 
-    void AddMemOperand(MachineInstr *MI, const MemOperand &MO);
+    void AddMemOperand(MachineInstr *MI, const MachineMemOperand &MO);
 
     void EmitCrossRCCopy(SUnit *SU, DenseMap<SUnit*, unsigned> &VRBaseMap);
 

include/llvm/CodeGen/SelectionDAG.h

@@ -401,7 +401,7 @@ public:
 
   // getMemOperand - Construct a node to track a memory reference
   // through the backend.
-  SDOperand getMemOperand(const MemOperand &MO);
+  SDOperand getMemOperand(const MachineMemOperand &MO);
 
   /// UpdateNodeOperands - *Mutate* the specified node in-place to have the
   /// specified operands.  If the resultant node already exists in the DAG,

include/llvm/CodeGen/SelectionDAGNodes.h

@@ -26,7 +26,7 @@
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APInt.h"
 #include "llvm/CodeGen/ValueTypes.h"
-#include "llvm/CodeGen/MemOperand.h"
+#include "llvm/CodeGen/MachineMemOperand.h"
 #include "llvm/Support/DataTypes.h"
 #include <cassert>
 
@@ -530,9 +530,9 @@ namespace ISD {
     // make reference to a value in the LLVM IR.
     SRCVALUE,
 
-    // MEMOPERAND - This is a node that contains a MemOperand which records
-    // information about a memory reference. This is used to make AliasAnalysis
-    // queries from the backend.
+    // MEMOPERAND - This is a node that contains a MachineMemOperand which
+    // records information about a memory reference. This is used to make
+    // AliasAnalysis queries from the backend.
     MEMOPERAND,
 
     // PCMARKER - This corresponds to the pcmarker intrinsic.
@@ -1645,7 +1645,7 @@ public:
 };
 
 
-/// MemOperandSDNode - An SDNode that holds a MemOperand. This is
+/// MemOperandSDNode - An SDNode that holds a MachineMemOperand. This is
 /// used to represent a reference to memory after ISD::LOAD
 /// and ISD::STORE have been lowered.
 ///
@@ -1653,13 +1653,13 @@ class MemOperandSDNode : public SDNode {
   virtual void ANCHOR();  // Out-of-line virtual method to give class a home.
 protected:
   friend class SelectionDAG;
-  /// Create a MemOperand node
-  explicit MemOperandSDNode(const MemOperand &mo)
+  /// Create a MachineMemOperand node
+  explicit MemOperandSDNode(const MachineMemOperand &mo)
     : SDNode(ISD::MEMOPERAND, getSDVTList(MVT::Other)), MO(mo) {}
 
 public:
-  /// MO - The contained MemOperand.
-  const MemOperand MO;
+  /// MO - The contained MachineMemOperand.
+  const MachineMemOperand MO;
 
   static bool classof(const MemOperandSDNode *) { return true; }
   static bool classof(const SDNode *N) {
@@ -1906,9 +1906,9 @@ public:
   /// isUnindexed - Return true if this is NOT a pre/post inc/dec load/store.
   bool isUnindexed() const { return AddrMode == ISD::UNINDEXED; }
 
-  /// getMemOperand - Return a MemOperand object describing the memory
+  /// getMemOperand - Return a MachineMemOperand object describing the memory
   /// reference performed by this load or store.
-  MemOperand getMemOperand() const;
+  MachineMemOperand getMemOperand() const;
 
   static bool classof(const LSBaseSDNode *N) { return true; }
   static bool classof(const SDNode *N) {