Revert Christopher Lamb's load/store alignment changes.

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

3 files changed, 12 insertions, 43 deletions

diff --git a/include/llvm/CodeGen/SelectionDAG.h b/include/llvm/CodeGen/SelectionDAG.h
index 9d8024b..0f17e69 100644
--- a/include/llvm/CodeGen/SelectionDAG.h
+++ b/include/llvm/CodeGen/SelectionDAG.h
@@ -311,12 +311,10 @@ public:
   /// determined by their operands, and they produce a value AND a token chain.
   ///
   SDOperand getLoad(MVT::ValueType VT, SDOperand Chain, SDOperand Ptr,
-                    const Value *SV, int SVOffset, bool isVolatile=false,
-                    unsigned Alignment=0);
+                    const Value *SV, int SVOffset, bool isVolatile=false);
   SDOperand getExtLoad(ISD::LoadExtType ExtType, MVT::ValueType VT,
                        SDOperand Chain, SDOperand Ptr, const Value *SV,
-                       int SVOffset, MVT::ValueType EVT, bool isVolatile=false,
-                       unsigned Alignment=0);
+                       int SVOffset, MVT::ValueType EVT, bool isVolatile=false);
   SDOperand getIndexedLoad(SDOperand OrigLoad, SDOperand Base,
                            SDOperand Offset, ISD::MemIndexedMode AM);
   SDOperand getVecLoad(unsigned Count, MVT::ValueType VT, SDOperand Chain, 
@@ -325,11 +323,10 @@ public:
   /// getStore - Helper function to build ISD::STORE nodes.
   ///
   SDOperand getStore(SDOperand Chain, SDOperand Val, SDOperand Ptr,
-                     const Value *SV, int SVOffset, bool isVolatile=false,
-                     unsigned Alignment=0);
+                     const Value *SV, int SVOffset, bool isVolatile=false);
   SDOperand getTruncStore(SDOperand Chain, SDOperand Val, SDOperand Ptr,
                           const Value *SV, int SVOffset, MVT::ValueType TVT,
-                          bool isVolatile=false, unsigned Alignment=0);
+                          bool isVolatile=false);
   SDOperand getIndexedStore(SDOperand OrigStoe, SDOperand Base,
                            SDOperand Offset, ISD::MemIndexedMode AM);
 
diff --git a/include/llvm/CodeGen/SelectionDAGNodes.h b/include/llvm/CodeGen/SelectionDAGNodes.h
index f617800..77d607a 100644
--- a/include/llvm/CodeGen/SelectionDAGNodes.h
+++ b/include/llvm/CodeGen/SelectionDAGNodes.h
@@ -1448,7 +1448,7 @@ protected:
   friend class SelectionDAG;
   LoadSDNode(SDOperand *ChainPtrOff, SDVTList VTs,
              ISD::MemIndexedMode AM, ISD::LoadExtType ETy, MVT::ValueType LVT,
-             const Value *SV, int O=0, unsigned Align=0, bool Vol=false)
+             const Value *SV, int O=0, unsigned Align=1, bool Vol=false)
     : SDNode(ISD::LOAD, VTs),
       AddrMode(AM), ExtType(ETy), LoadedVT(LVT), SrcValue(SV), SVOffset(O),
       Alignment(Align), IsVolatile(Vol) {
@@ -1456,7 +1456,6 @@ protected:
     Ops[1] = ChainPtrOff[1]; // Ptr
     Ops[2] = ChainPtrOff[2]; // Off
     InitOperands(Ops, 3);
-    assert(Align != 0 && "Loads should have non-zero aligment");
     assert((getOffset().getOpcode() == ISD::UNDEF ||
             AddrMode != ISD::UNINDEXED) &&
            "Only indexed load has a non-undef offset operand");
@@ -1519,7 +1518,6 @@ protected:
     Ops[2] = ChainValuePtrOff[2]; // Ptr
     Ops[3] = ChainValuePtrOff[3]; // Off
     InitOperands(Ops, 4);
-    assert(Align != 0 && "Stores should have non-zero aligment");
     assert((getOffset().getOpcode() == ISD::UNDEF || 
             AddrMode != ISD::UNINDEXED) &&
            "Only indexed store has a non-undef offset operand");
diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index 40e3174..2387739 100644
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -211,11 +211,9 @@ public:
 /// SubclassData field in Value to store whether or not the load is volatile.
 ///
 class LoadInst : public UnaryInstruction {
-
   LoadInst(const LoadInst &LI)
     : UnaryInstruction(LI.getType(), Load, LI.getOperand(0)) {
     setVolatile(LI.isVolatile());
-    setAlignment(LI.getAlignment());
 
 #ifndef NDEBUG
     AssertOK();
@@ -225,16 +223,14 @@ class LoadInst : public UnaryInstruction {
 public:
   LoadInst(Value *Ptr, const std::string &Name, Instruction *InsertBefore);
   LoadInst(Value *Ptr, const std::string &Name, BasicBlock *InsertAtEnd);
-  LoadInst(Value *Ptr, const std::string &Name, bool isVolatile = false, 
-           Instruction *InsertBefore = 0);
-  LoadInst(Value *Ptr, const std::string &Name, bool isVolatile, unsigned Align,
+  LoadInst(Value *Ptr, const std::string &Name, bool isVolatile = false,
            Instruction *InsertBefore = 0);
   LoadInst(Value *Ptr, const std::string &Name, bool isVolatile,
            BasicBlock *InsertAtEnd);
 
   LoadInst(Value *Ptr, const char *Name, Instruction *InsertBefore);
   LoadInst(Value *Ptr, const char *Name, BasicBlock *InsertAtEnd);
-  explicit LoadInst(Value *Ptr, const char *Name = 0, bool isVolatile = false, 
+  explicit LoadInst(Value *Ptr, const char *Name = 0, bool isVolatile = false,
                     Instruction *InsertBefore = 0);
   LoadInst(Value *Ptr, const char *Name, bool isVolatile,
            BasicBlock *InsertAtEnd);
@@ -242,23 +238,14 @@ public:
   /// isVolatile - Return true if this is a load from a volatile memory
   /// location.
   ///
-  bool isVolatile() const { return SubclassData & 1; }
+  bool isVolatile() const { return SubclassData; }
 
   /// setVolatile - Specify whether this is a volatile load or not.
   ///
-  void setVolatile(bool V) { SubclassData = (SubclassData & ~1) | unsigned(V); }
+  void setVolatile(bool V) { SubclassData = V; }
 
   virtual LoadInst *clone() const;
 
-  /// getAlignment - Return the alignment of the access that is being performed
-  ///
-  unsigned getAlignment() const {
-    signed Log2AlignVal = ((SubclassData>>1)-1);
-    return ((Log2AlignVal < 0) ? 0 : 1<<Log2AlignVal);
-  }
-  
-  void setAlignment(unsigned Align);
-
   Value *getPointerOperand() { return getOperand(0); }
   const Value *getPointerOperand() const { return getOperand(0); }
   static unsigned getPointerOperandIndex() { return 0U; }
@@ -282,13 +269,10 @@ public:
 ///
 class StoreInst : public Instruction {
   Use Ops[2];
-  
   StoreInst(const StoreInst &SI) : Instruction(SI.getType(), Store, Ops, 2) {
     Ops[0].init(SI.Ops[0], this);
     Ops[1].init(SI.Ops[1], this);
     setVolatile(SI.isVolatile());
-    setAlignment(SI.getAlignment());
-    
 #ifndef NDEBUG
     AssertOK();
 #endif
@@ -299,19 +283,17 @@ public:
   StoreInst(Value *Val, Value *Ptr, BasicBlock *InsertAtEnd);
   StoreInst(Value *Val, Value *Ptr, bool isVolatile = false,
             Instruction *InsertBefore = 0);
-  StoreInst(Value *Val, Value *Ptr, bool isVolatile,
-            unsigned Align, Instruction *InsertBefore = 0);
   StoreInst(Value *Val, Value *Ptr, bool isVolatile, BasicBlock *InsertAtEnd);
 
 
   /// isVolatile - Return true if this is a load from a volatile memory
   /// location.
   ///
-  bool isVolatile() const { return SubclassData & 1; }
+  bool isVolatile() const { return SubclassData; }
 
   /// setVolatile - Specify whether this is a volatile load or not.
   ///
-  void setVolatile(bool V) { SubclassData = (SubclassData & ~1) | unsigned(V); }
+  void setVolatile(bool V) { SubclassData = V; }
 
   /// Transparently provide more efficient getOperand methods.
   Value *getOperand(unsigned i) const {
@@ -324,15 +306,7 @@ public:
   }
   unsigned getNumOperands() const { return 2; }
 
-  /// getAlignment - Return the alignment of the access that is being performed
-  ///
-  unsigned getAlignment() const {
-    signed Log2AlignVal = ((SubclassData>>1)-1);
-    return ((Log2AlignVal < 0) ? 0 : 1<<Log2AlignVal);
-  }
-  
-  void setAlignment(unsigned Align);
-  
+
   virtual StoreInst *clone() const;
 
   Value *getPointerOperand() { return getOperand(1); }