Load & StoreInst no longer derive from MemAccessInst, so we don't have

to handle indexing anymore


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

lib/Analysis/DataStructure/Local.cpp

@@ -263,13 +263,13 @@ void GraphBuilder::visitGetElementPtrInst(GetElementPtrInst &GEP) {
 }
 
 void GraphBuilder::visitLoadInst(LoadInst &LI) {
-  DSNode *Ptr = getSubscriptedNode(LI, getValueNode(*LI.getOperand(0)));
+  DSNode *Ptr = getValueNode(*LI.getOperand(0));
-  if (!isa<PointerType>(LI.getType())) return; // Only pointer PHIs
+  if (!isa<PointerType>(LI.getType())) return;   // only loads OF pointers
   getValueNode(LI)->addEdgeTo(getLink(Ptr, 0));
 }
 
 void GraphBuilder::visitStoreInst(StoreInst &SI) {
-  DSNode *DestPtr = getSubscriptedNode(SI, getValueNode(*SI.getOperand(1)));
+  DSNode *DestPtr = getValueNode(*SI.getOperand(1));
   if (!isa<PointerType>(SI.getOperand(0)->getType())) return;
   DSNode *Value   = getValueNode(*SI.getOperand(0));
   DestPtr->addEdgeTo(getLink(Value, 0));

lib/Bytecode/Reader/InstructionReader.cpp

@@ -444,7 +444,7 @@ bool BytecodeParser::ParseInstruction(const uchar *&Buf, const uchar *EndBuf,
       cerr << "WARNING: Bytecode contains load instruction with indices.  "
            << "Replacing with getelementptr/load pair\n";
 
-      const Type *ElType = StoreInst::getIndexedType(Raw.Ty, Idx);
+      const Type *ElType = GetElementPtrInst::getIndexedType(Raw.Ty, Idx);
       if (ElType == 0) return true;
 
       Ptr = new GetElementPtrInst(Ptr, Idx);

lib/ExecutionEngine/Interpreter/Execution.cpp

@@ -765,9 +765,9 @@ static void executeFreeInst(FreeInst &I, ExecutionContext &SF) {
 }
 
 
-// getElementOffset - The workhorse for getelementptr, load and store.  This 
+// getElementOffset - The workhorse for getelementptr.  This function returns
-// function returns the offset that arguments ArgOff+1 -> NumArgs specify for
+// the offset that arguments ArgOff+1 -> NumArgs specify for the pointer type
-// the pointer type specified by argument Arg.
+// specified by argument Arg.
 //
 static PointerTy getElementOffset(MemAccessInst &I, ExecutionContext &SF) {
   assert(isa<PointerType>(I.getPointerOperand()->getType()) &&
@@ -832,11 +832,7 @@ static void executeGEPInst(GetElementPtrInst &I, ExecutionContext &SF) {
 
 static void executeLoadInst(LoadInst &I, ExecutionContext &SF) {
   GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
-  PointerTy SrcPtr = SRC.PointerVal;
+  GenericValue *Ptr = (GenericValue*)SRC.PointerVal;
-  PointerTy Offset = getElementOffset(I, SF);  // Handle any structure indices
-  SrcPtr += Offset;
-
-  GenericValue *Ptr = (GenericValue*)SrcPtr;
   GenericValue Result;
 
   switch (I.getType()->getPrimitiveID()) {
@@ -861,10 +857,7 @@ static void executeLoadInst(LoadInst &I, ExecutionContext &SF) {
 
 static void executeStoreInst(StoreInst &I, ExecutionContext &SF) {
   GenericValue SRC = getOperandValue(I.getPointerOperand(), SF);
-  PointerTy SrcPtr = SRC.PointerVal;
+  GenericValue *Ptr = (GenericValue *)SRC.PointerVal;
-  SrcPtr += getElementOffset(I, SF);  // Handle any structure indices
-
-  GenericValue *Ptr = (GenericValue *)SrcPtr;
   GenericValue Val = getOperandValue(I.getOperand(0), SF);
 
   switch (I.getOperand(0)->getType()->getPrimitiveID()) {

lib/Transforms/Scalar/DecomposeMultiDimRefs.cpp

@@ -49,7 +49,7 @@ DecomposePass::runOnBasicBlock(BasicBlock &BB)
   for (BasicBlock::iterator II = BB.begin(); II != BB.end(); ) {
     if (MemAccessInst *MAI = dyn_cast<MemAccessInst>(&*II))
       if (MAI->getNumIndices() >= 2) {
-        Changed = decomposeArrayRef(II) || Changed; // always modifies II
+        Changed |= decomposeArrayRef(II); // always modifies II
         continue;
       }
     ++II;
@@ -88,19 +88,7 @@ IsZero(Value* idx)
 bool
 DecomposePass::decomposeArrayRef(BasicBlock::iterator &BBI)
 {
-  // FIXME: If condition below
   MemAccessInst &MAI = cast<MemAccessInst>(*BBI);
-  // FIXME: If condition below
-
-  // If this instr has no indexes, then the decomposed version is identical to
-  // the instruction itself.  FIXME: this should go away once GEP is the only
-  // MAI
-  //
-  if (MAI.getNumIndices() == 0) {
-    ++BBI;
-    return false;
-  }
-
   BasicBlock *BB = MAI.getParent();
   Value *LastPtr = MAI.getPointerOperand();
 
@@ -141,12 +129,6 @@ DecomposePass::decomposeArrayRef(BasicBlock::iterator &BBI)
 
   Instruction *NewI = 0;
   switch(MAI.getOpcode()) {
-  case Instruction::Load:
-    NewI = new LoadInst(LastPtr, Indices, MAI.getName());
-    break;
-  case Instruction::Store:
-    NewI = new StoreInst(MAI.getOperand(0), LastPtr, Indices);
-    break;
   case Instruction::GetElementPtr:
     NewI = new GetElementPtrInst(LastPtr, Indices, MAI.getName());
     break;

lib/Transforms/Scalar/GCSE.cpp

@@ -381,8 +381,6 @@ bool GCSE::TryToRemoveALoad(LoadInst *L1, LoadInst *L2) {
     return false;  // Neither instruction dominates the other one...
 
   BasicBlock *BB1 = L1->getParent(), *BB2 = L2->getParent();
-
-  assert(!L1->hasIndices());
   Value *LoadAddress = L1->getOperand(0);
 
   // L1 now dominates L2.  Check to see if the intervening instructions between

lib/Transforms/Scalar/LICM.cpp

@@ -105,7 +105,6 @@ namespace {
     void visitShiftInst(ShiftInst &I) { visitBinaryOperator((Instruction&)I); }
 
     void visitLoadInst(LoadInst &LI) {
-      assert(!LI.hasIndices());
       if (isLoopInvariant(LI.getOperand(0)) &&
           !pointerInvalidatedByLoop(LI.getOperand(0)))
         hoist(LI);

lib/VMCore/Verifier.cpp

@@ -330,18 +330,16 @@ void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
 }
 
 void Verifier::visitLoadInst(LoadInst &LI) {
-  const Type *ElTy = LoadInst::getIndexedType(LI.getOperand(0)->getType(),
+  const Type *ElTy =
-                                              LI.copyIndices());
+    cast<PointerType>(LI.getOperand(0)->getType())->getElementType();
-  Assert1(ElTy, "Invalid indices for load pointer type!", &LI);
   Assert2(ElTy == LI.getType(),
           "Load is not of right type for indices!", &LI, ElTy);
   visitInstruction(LI);
 }
 
 void Verifier::visitStoreInst(StoreInst &SI) {
-  const Type *ElTy = StoreInst::getIndexedType(SI.getOperand(1)->getType(),
+  const Type *ElTy =
-                                               SI.copyIndices());
+    cast<PointerType>(SI.getOperand(1)->getType())->getElementType();
-  Assert1(ElTy, "Invalid indices for store pointer type!", &SI);
   Assert2(ElTy == SI.getOperand(0)->getType(),
           "Stored value is not of right type for indices!", &SI, ElTy);
   visitInstruction(SI);