Subzero: Implement InstList in terms of llvm::ilist<> .

src/IceTargetLowering.cpp

 //===- subzero/src/IceTargetLowering.cpp - Basic lowering implementation --===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the skeleton of the TargetLowering class,
@@ skipping 44 matching lines @@
   skipDeleted(Cur);
   Next = Cur;
 }
 
 void LoweringContext::insert(Inst *Inst) {
   getNode()->getInsts().insert(Next, Inst);
   LastInserted = Inst;
 }
 
 void LoweringContext::skipDeleted(InstList::iterator &I) const {
-  while (I != End && (*I)->isDeleted())
+  while (I != End && I->isDeleted())
     ++I;
 }
 
 void LoweringContext::advanceForward(InstList::iterator &I) const {
   if (I != End) {
     ++I;
     skipDeleted(I);
   }
 }
 
@@ skipping 33 matching lines @@
     doAddressOptLoad();
   else if (llvm::isa<InstStore>(*Context.getCur()))
     doAddressOptStore();
   Context.advanceCur();
   Context.advanceNext();
 }
 
 bool TargetLowering::shouldDoNopInsertion() const { return DoNopInsertion; }
 
 void TargetLowering::doNopInsertion() {
-  Inst *I = *Context.getCur();
+  Inst *I = Context.getCur();
   bool ShouldSkip = llvm::isa<InstFakeUse>(I) || llvm::isa<InstFakeDef>(I) ||
                     llvm::isa<InstFakeKill>(I) || I->isRedundantAssign() ||
                     I->isDeleted();
   if (!ShouldSkip) {
     for (int I = 0; I < MaxNopsPerInstruction; ++I) {
       randomlyInsertNop(NopProbabilityAsPercentage / 100.0);
     }
   }
 }
 
 // Lowers a single instruction according to the information in
 // Context, by checking the Context.Cur instruction kind and calling
 // the appropriate lowering method.  The lowering method should insert
 // target instructions at the Cur.Next insertion point, and should not
 // delete the Context.Cur instruction or advance Context.Cur.
 //
 // The lowering method may look ahead in the instruction stream as
 // desired, and lower additional instructions in conjunction with the
 // current one, for example fusing a compare and branch.  If it does,
 // it should advance Context.Cur to point to the next non-deleted
 // instruction to process, and it should delete any additional
 // instructions it consumes.
 void TargetLowering::lower() {
   assert(!Context.atEnd());
-  Inst *Inst = *Context.getCur();
+  Inst *Inst = Context.getCur();
   // Mark the current instruction as deleted before lowering,
   // otherwise the Dest variable will likely get marked as non-SSA.
   // See Variable::setDefinition().
   Inst->setDeleted();
   switch (Inst->getKind()) {
   case Inst::Alloca:
     lowerAlloca(llvm::dyn_cast<InstAlloca>(Inst));
     break;
   case Inst::Arithmetic:
     lowerArithmetic(llvm::dyn_cast<InstArithmetic>(Inst));
@@ skipping 98 matching lines @@
   if (Target == Target_ARM64)
     return IceTargetGlobalInitARM64::create(Ctx);
 #endif
   llvm_unreachable("Unsupported target");
   return NULL;
 }
 
 TargetGlobalInitLowering::~TargetGlobalInitLowering() {}
 
 } // end of namespace Ice