Subzero: Update for LLVM 3.9 (trunk).

src/IceConverter.cpp

 //===- subzero/src/IceConverter.cpp - Converts LLVM to Ice  ---------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 93 matching lines @@
       NodeMap.clear();
       Func->setFunctionName(
           Ctx->getGlobalString(Ice::mangleName(F->getName())));
       Func->setReturnType(convertToIceType(F->getReturnType()));
       Func->setInternal(F->hasInternalLinkage());
       Ice::TimerMarker T(Ice::TimerStack::TT_llvmConvert, Func.get());
 
       // The initial definition/use of each arg is the entry node.
       for (auto ArgI = F->arg_begin(), ArgE = F->arg_end(); ArgI != ArgE;
            ++ArgI) {
-        Func->addArg(mapValueToIceVar(ArgI));
+        Func->addArg(mapValueToIceVar(&*ArgI));
       }
 
       // Make an initial pass through the block list just to resolve the blocks
       // in the original linearized order. Otherwise the ICE linearized order
       // will be affected by branch targets in terminator instructions.
       for (const BasicBlock &BBI : *F)
         mapBasicBlockToNode(&BBI);
       for (const BasicBlock &BBI : *F)
         convertBasicBlock(&BBI);
       Func->setEntryNode(mapBasicBlockToNode(&F->getEntryBlock()));
@@ skipping 576 matching lines @@
   }
 
   Ice::VariableDeclarationList *GlobalPool;
 };
 
 void LLVM2ICEGlobalsConverter::convertGlobalsToIce(Module *Mod) {
   for (Module::const_global_iterator I = Mod->global_begin(),
                                      E = Mod->global_end();
        I != E; ++I) {
 
-    const GlobalVariable *GV = I;
+    const GlobalVariable *GV = &*I;
 
     Ice::GlobalDeclaration *Var = getConverter().getGlobalDeclaration(GV);
     auto *VarDecl = cast<Ice::VariableDeclaration>(Var);
     GlobalPool->push_back(VarDecl);
 
     if (!GV->hasInternalLinkage() && GV->hasInitializer()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Can't define external global declaration: " << GV->getName();
       report_fatal_error(StrBuf.str());
@@ skipping 159 matching lines @@
       report_fatal_error(StrBuf.str());
     }
     if (!IceFunc->validateTypeSignature(Ctx))
       report_fatal_error(IceFunc->getTypeSignatureError(Ctx));
     GlobalDeclarationMap[&Func] = IceFunc;
   }
   // Install global variable declarations.
   for (Module::const_global_iterator I = Mod->global_begin(),
                                      E = Mod->global_end();
        I != E; ++I) {
-    const GlobalVariable *GV = I;
+    const GlobalVariable *GV = &*I;
     constexpr bool NoSuppressMangling = false;
     auto *Var = VariableDeclaration::create(
         GlobalDeclarationsPool.get(), NoSuppressMangling, GV->getLinkage());
     Var->setAlignment(GV->getAlignment());
     Var->setIsConstant(GV->isConstant());
     Var->setName(Ctx, GV->getName());
     if (!Var->verifyLinkageCorrect()) {
       std::string Buffer;
       raw_string_ostream StrBuf(Buffer);
       StrBuf << "Global " << Var->getName()
@@ skipping 16 matching lines @@
   for (const Function &I : *Mod) {
     if (I.empty())
       continue;
     TimerMarker _(Ctx, I.getName());
     LLVM2ICEFunctionConverter FunctionConverter(*this);
     FunctionConverter.convertFunction(&I);
   }
 }
 
 } // end of namespace Ice