Add possibility to specify output stream for CompilerInstance

[krisb]

Reverted unintentional changes.

[teemperor]

See the inline comments. Please run clang-format over this patch after addressing them (there are a few indentation issues).

include/clang/Frontend/CompilerInstance.h

779

"Set" -> "set", LLVM code style requires lower case first letters in function names (even though it's sadly may be inconsistent with other code that's still using the other style...)

783

LLVM convention is to call this takeX and not getX when it moves the member OutputStream to the caller. get usually doesn't reset the member variable.

lib/Frontend/CompilerInstance.cpp

65

Don't think we need that.

[krisb]

@teemperor, thanks! All comments are applied.

[krisb]

Reverted unintentional changes again. Sorry for that

[teemperor]

LGTM!

include/clang/Frontend/CompilerInstance.h

class CompilerInstance : public ModuleLoader {
   /// If the output doesn't support seeking (terminal, pipe). we switch
   /// the stream to a buffer_ostream. These are the buffer and the original
   /// stream.
   std::unique_ptr<llvm::raw_fd_ostream> NonSeekStream;
 
   /// The list of active output files.
   std::list<OutputFile> OutputFiles;
 
+  /// Force an output buffer
+  std::unique_ptr<llvm::raw_pwrite_stream> OutputStream;
+
   CompilerInstance(const CompilerInstance &) = delete;
   void operator=(const CompilerInstance &) = delete;
 public:
   explicit CompilerInstance(
       std::shared_ptr<PCHContainerOperations> PCHContainerOps =
           std::make_shared<PCHContainerOperations>(),
       MemoryBufferCache *SharedPCMCache = nullptr);
   ~CompilerInstance() override;
static bool InitializeSourceManager(const FrontendInputFile &Input,
                                       FileManager &FileMgr,
                                       SourceManager &SourceMgr,
                                       HeaderSearch *HS,
                                       DependencyOutputOptions &DepOpts,
                                       const FrontendOptions &Opts);
 
   /// }
 
+  void SetOutputStream(std::unique_ptr<llvm::raw_pwrite_stream> OutStream) {
+    OutputStream = std::move(OutStream);
+  }
+
+  std::unique_ptr<llvm::raw_pwrite_stream> GetOutputStream() {
+    return std::move(OutputStream);
+  }
+
   // Create module manager.
   void createModuleManager();
 
   bool loadModuleFile(StringRef FileName);
 
   ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path,
                               Module::NameVisibilityKind Visibility,
                               bool IsInclusionDirective) override;

lib/CodeGen/CodeGenAction.cpp

GetOutputStream(CompilerInstance &CI, StringRef InFile, BackendAction Action) {
   }
 
   llvm_unreachable("Invalid action!");
 }
 
 std::unique_ptr<ASTConsumer>
 CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
   BackendAction BA = static_cast<BackendAction>(Act);
-  std::unique_ptr<raw_pwrite_stream> OS = GetOutputStream(CI, InFile, BA);
+  std::unique_ptr<raw_pwrite_stream> OS = CI.GetOutputStream();
+  if (!OS)
+    OS = GetOutputStream(CI, InFile, BA);
+
   if (BA != Backend_EmitNothing && !OS)
     return nullptr;
 
   // Load bitcode modules to link with, if we need to.
   if (LinkModules.empty())
     for (const CodeGenOptions::BitcodeFileToLink &F :
          CI.getCodeGenOpts().LinkBitcodeFiles) {
       auto BCBuf = CI.getFileManager().getBufferForFile(F.Filename);

lib/Frontend/CompilerInstance.cpp

 using namespace clang;
 
 CompilerInstance::CompilerInstance(
     std::shared_ptr<PCHContainerOperations> PCHContainerOps,
     MemoryBufferCache *SharedPCMCache)
     : ModuleLoader(/* BuildingModule = */ SharedPCMCache),
       Invocation(new CompilerInvocation()),
       PCMCache(SharedPCMCache ? SharedPCMCache : new MemoryBufferCache),
-      ThePCHContainerOperations(std::move(PCHContainerOps)) {
+      ThePCHContainerOperations(std::move(PCHContainerOps)),
+      OutputStream(nullptr) {
   // Don't allow this to invalidate buffers in use by others.
   if (SharedPCMCache)
     getPCMCache().finalizeCurrentBuffers();
 }
 
 CompilerInstance::~CompilerInstance() {
   assert(OutputFiles.empty() && "Still output files in flight?");
 }

unittests/Frontend/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(FrontendTests
   ASTUnitTest.cpp
   CompilerInstanceTest.cpp
   FrontendActionTest.cpp
   CodeGenActionTest.cpp
   ParsedSourceLocationTest.cpp
   PCHPreambleTest.cpp
+  OutputStreamTest.cpp
   )
 target_link_libraries(FrontendTests
   PRIVATE
   clangAST
   clangBasic
   clangFrontend
   clangLex
   clangSema
   clangCodeGen
+  clangFrontendTool
   )

unittests/Frontend/OutputStreamTest.cpp

+//===- unittests/Frontend/OutputStreamTest.cpp --- FrontendAction tests --===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/CodeGen/BackendUtil.h"
+#include "clang/CodeGen/CodeGenAction.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/FrontendTool/Utils.h"
+#include "clang/Lex/PreprocessorOptions.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+using namespace clang;
+using namespace clang::frontend;
+
+namespace {
+
+TEST(FrontendOutputTests, TestOutputStream) {
+  auto Invocation = std::make_shared<CompilerInvocation>();
+  Invocation->getPreprocessorOpts().addRemappedFile(
+      "test.cc",
+      MemoryBuffer::getMemBuffer("").release());
+  Invocation->getFrontendOpts().Inputs.push_back(
+      FrontendInputFile("test.cc", InputKind::CXX));
+  Invocation->getFrontendOpts().ProgramAction = EmitBC;
+  Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
+  CompilerInstance Compiler;
+
+  SmallVector<char, 256> IRBuffer;
+  std::unique_ptr<raw_pwrite_stream>
+      IRStream(new raw_svector_ostream(IRBuffer));
+
+  Compiler.SetOutputStream(std::move(IRStream));
+  Compiler.setInvocation(std::move(Invocation));
+  Compiler.createDiagnostics();
+
+  bool Success = ExecuteCompilerInvocation(&Compiler);
+  EXPECT_TRUE(Success);
+  EXPECT_TRUE(!IRBuffer.empty());
+  EXPECT_TRUE(StringRef(IRBuffer.data()).startswith("BC"));
+}
+}