[ThinLTO] Adapt backend invocation to llvm API changes.

[tejohnson]

LGTM

cfe/trunk/lib/CodeGen/BackendUtil.cpp

void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
   }
 
   {
     PrettyStackTraceString CrashInfo("Code generation");
     CodeGenPasses.run(*TheModule);
   }
 }
 
+namespace {
+// Wrapper prodiving a stream for the ThinLTO backend.
+class ThinLTOOutputWrapper : public lto::NativeObjectOutput {
+  std::unique_ptr<raw_pwrite_stream> OS;
+
+public:
+  ThinLTOOutputWrapper(std::unique_ptr<raw_pwrite_stream> OS)
+      : OS(std::move(OS)) {}
+  std::unique_ptr<raw_pwrite_stream> getStream() override {
+    return std::move(OS);
+  }
+};
+}
+
 static void runThinLTOBackend(const CodeGenOptions &CGOpts, Module *M,
                               std::unique_ptr<raw_pwrite_stream> OS) {
   // If we are performing a ThinLTO importing compile, load the function index
   // into memory and pass it into thinBackend, which will run the function
   // importer and invoke LTO passes.
   ErrorOr<std::unique_ptr<ModuleSummaryIndex>> IndexOrErr =
       llvm::getModuleSummaryIndexForFile(
           CGOpts.ThinLTOIndexFile,
           [&](const DiagnosticInfo &DI) { M->getContext().diagnose(DI); });
   if (std::error_code EC = IndexOrErr.getError()) {
     std::string Error = EC.message();
     errs() << "Error loading index file '" << CGOpts.ThinLTOIndexFile
            << "': " << Error << "\n";
     return;
   }
   std::unique_ptr<ModuleSummaryIndex> CombinedIndex = std::move(*IndexOrErr);
 
-  auto AddStream = [&](size_t Task) { return std::move(OS); };
-
   StringMap<std::map<GlobalValue::GUID, GlobalValueSummary *>>
       ModuleToDefinedGVSummaries;
   CombinedIndex->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries);
 
   // FIXME: We could simply import the modules mentioned in the combined index
   // here.
   FunctionImporter::ImportMapTy ImportList;
   ComputeCrossModuleImportForModule(M->getModuleIdentifier(), *CombinedIndex,
                                     ImportList);
 
   std::vector<std::unique_ptr<llvm::MemoryBuffer>> OwnedImports;
   MapVector<llvm::StringRef, llvm::MemoryBufferRef> ModuleMap;
 
   for (auto &I : ImportList) {
     ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> MBOrErr =
         llvm::MemoryBuffer::getFile(I.first());
     if (!MBOrErr) {
       errs() << "Error loading imported file '" << I.first()
              << "': " << MBOrErr.getError().message() << "\n";
       return;
     }
     ModuleMap[I.first()] = (*MBOrErr)->getMemBufferRef();
     OwnedImports.push_back(std::move(*MBOrErr));
   }
-
+  auto AddOutput = [&](size_t Task) {
+    return llvm::make_unique<ThinLTOOutputWrapper>(std::move(OS));
+  };
   lto::Config Conf;
   if (Error E = thinBackend(
-          Conf, 0, AddStream, *M, *CombinedIndex, ImportList,
+          Conf, 0, AddOutput, *M, *CombinedIndex, ImportList,
           ModuleToDefinedGVSummaries[M->getModuleIdentifier()], ModuleMap)) {
     handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
       errs() << "Error running ThinLTO backend: " << EIB.message() << '\n';
     });
   }
 }
 
 void clang::EmitBackendOutput(DiagnosticsEngine &Diags,