Subzero: Update for LLVM 3.9 (trunk).

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.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 320 matching lines @@
   }
 }
 
 void TargetLowering::genTargetHelperCalls() {
   TimerMarker T(TimerStack::TT_genHelpers, Func);
   Utils::BoolFlagSaver _(GeneratingTargetHelpers, true);
   for (CfgNode *Node : Func->getNodes()) {
     Context.init(Node);
     while (!Context.atEnd()) {
       PostIncrLoweringContext _(Context);
-      genTargetHelperCallFor(Context.getCur());
+      genTargetHelperCallFor(iteratorToInst(Context.getCur()));
     }
   }
 }
 
 void TargetLowering::doAddressOpt() {
   if (llvm::isa<InstLoad>(*Context.getCur()))
     doAddressOptLoad();
   else if (llvm::isa<InstStore>(*Context.getCur()))
     doAddressOptStore();
   Context.advanceCur();
   Context.advanceNext();
 }
 
 void TargetLowering::doNopInsertion(RandomNumberGenerator &RNG) {
-  Inst *I = Context.getCur();
+  Inst *I = iteratorToInst(Context.getCur());
   bool ShouldSkip = llvm::isa<InstFakeUse>(I) || llvm::isa<InstFakeDef>(I) ||
                     llvm::isa<InstFakeKill>(I) || I->isRedundantAssign() ||
                     I->isDeleted();
   if (!ShouldSkip) {
     int Probability = getFlags().getNopProbabilityAsPercentage();
     for (int I = 0; I < getFlags().getMaxNopsPerInstruction(); ++I) {
       randomlyInsertNop(Probability / 100.0, RNG);
     }
   }
 }
 
 // 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 *Instr = Context.getCur();
+  Inst *Instr = iteratorToInst(Context.getCur());
   Instr->deleteIfDead();
   if (!Instr->isDeleted() && !llvm::isa<InstFakeDef>(Instr) &&
       !llvm::isa<InstFakeUse>(Instr)) {
     // Mark the current instruction as deleted before lowering, otherwise the
     // Dest variable will likely get marked as non-SSA. See
     // Variable::setDefinition(). However, just pass-through FakeDef and
     // FakeUse instructions that might have been inserted prior to lowering.
     Instr->setDeleted();
     switch (Instr->getKind()) {
     case Inst::Alloca:
@@ skipping 74 matching lines @@
 
 void TargetLowering::lowerInst(CfgNode *Node, InstList::iterator Next,
                                InstHighLevel *Instr) {
   // TODO(stichnot): Consider modifying the design/implementation to avoid
   // multiple init() calls when using lowerInst() to lower several instructions
   // in the same node.
   Context.init(Node);
   Context.setNext(Next);
   Context.insert(Instr);
   --Next;
-  assert(&*Next == Instr);
+  assert(iteratorToInst(Next) == Instr);
   Context.setCur(Next);
   lower();
 }
 
 void TargetLowering::lowerOther(const Inst *Instr) {
   (void)Instr;
   Func->setError("Can't lower unsupported instruction type");
 }
 
 // Drives register allocation, allowing all physical registers (except perhaps
@@ skipping 416 matching lines @@
   case TARGET_LOWERING_CLASS_FOR(X):                                           \
     return ::X::createTargetHeaderLowering(Ctx);
 #include "SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice