Subzero: Fix build errors with LLVM trunk.

src/IceTargetLoweringX86BaseImpl.h

 //===- subzero/src/IceTargetLoweringX86BaseImpl.h - x86 lowering -*- C++ -*-==//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 791 matching lines @@
   return false;
 }
 
 template <typename TraitsType> void TargetX86Base<TraitsType>::doLoadOpt() {
   TimerMarker _(TimerStack::TT_loadOpt, Func);
   for (CfgNode *Node : Func->getNodes()) {
     Context.init(Node);
     while (!Context.atEnd()) {
       Variable *LoadDest = nullptr;
       Operand *LoadSrc = nullptr;
-      Inst *CurInst = Context.getCur();
+      Inst *CurInst = iteratorToInst(Context.getCur());

[Eric Holk, 2016/08/17 00:33:46]

Would just `*Context.getCur()` work?

[Jim Stichnoth, 2016/08/17 04:43:30]

Given that the original code was:
  Inst *CurInst = Context.getCur();
I wouldn't expect adding a '*' to work:
  Inst *CurInst = *Context.getCur();

This does work though:
  Inst *CurInst = &*Context.getCur();
but it's really ugly and is in fact how iteratorToInst() is defined in
IceInst.h.

       Inst *Next = Context.getNextInst();
       // Determine whether the current instruction is a Load instruction or
       // equivalent.
       if (auto *Load = llvm::dyn_cast<InstLoad>(CurInst)) {
         // An InstLoad always qualifies.
         LoadDest = Load->getDest();
         constexpr bool DoLegalize = false;
         LoadSrc = formMemoryOperand(Load->getSourceAddress(),
                                     LoadDest->getType(), DoLegalize);
       } else if (auto *Intrin = llvm::dyn_cast<InstIntrinsicCall>(CurInst)) {
@@ skipping 4850 matching lines @@
   Operand *Src0 = formMemoryOperand(Load->getSourceAddress(), Ty);
   doMockBoundsCheck(Src0);
   auto *Assign = InstAssign::create(Func, DestLoad, Src0);
   lowerAssign(Assign);
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::doAddressOptOther() {
   // Inverts some Icmp instructions which helps doAddressOptLoad later.
   // TODO(manasijm): Refactor to unify the conditions for Var0 and Var1
-  Inst *Instr = Context.getCur();
+  Inst *Instr = iteratorToInst(Context.getCur());
   auto *VMetadata = Func->getVMetadata();
   if (auto *Icmp = llvm::dyn_cast<InstIcmp>(Instr)) {
     if (llvm::isa<Constant>(Icmp->getSrc(0)) ||
         llvm::isa<Constant>(Icmp->getSrc(1)))
       return;
     auto *Var0 = llvm::dyn_cast<Variable>(Icmp->getSrc(0));
     if (Var0 == nullptr)
       return;
     if (!VMetadata->isTracked(Var0))
       return;
@@ skipping 10 matching lines @@
           llvm::isa<InstLoad>(Op1Def)) {
         return; // Both are loads
       }
     }
     Icmp->reverseConditionAndOperands();
   }
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::doAddressOptLoad() {
-  Inst *Instr = Context.getCur();
+  Inst *Instr = iteratorToInst(Context.getCur());
   Operand *Addr = Instr->getSrc(0);
   Variable *Dest = Instr->getDest();
   if (auto *OptAddr = computeAddressOpt(Instr, Dest->getType(), Addr)) {
     Instr->setDeleted();
     Context.insert<InstLoad>(Dest, OptAddr);
   }
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::randomlyInsertNop(float Probability,
@@ skipping 2365 matching lines @@
         emitGlobal(*Var, SectionSuffix);
       }
     }
   } break;
   }
 }
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H