[clang-import-test] Option to dump the IR for an expression

[spyffe]

Summary

This adds the argument --dump-ir to clang-import-test, which allows viewing of the final IR. This is useful for confirming that structure layout was correct.

I've added an XFAILed test that exercises this, checking that a struct defined inside a function body has the right fields. Currently it does not because LookupSameContext() (ExternalASTMerger.cpp) can't find the struct. This is an issue I intend to resolve separately.

[spyffe]

Added a passing test for a global struct, so we have something that'll fail if the IR dumping breaks.

[spyffe]

Eliminate sensitive dependence on sizeof(int). bool should still be rendered as i1 though.

[lhames]

LGTM!

tools/clang-import-test/clang-import-test.cpp

301–303

LLVM style says no braces for single line conditionals. :)

test/Import/local-struct/Inputs/Callee.cpp

-class Base {
-public:
-  virtual void foo() {}
+struct Bar {
+  void bar(int _a, bool _b) {
+    {
+      struct S { int a; };
+      S s = { _a };
+    }
+    {
+      struct S { bool b; };
+      S t = { _b };
+    }
   };
-
-class Derived : public Base {
-public:
-  void foo() override {}
 };

test/Import/local-struct/test.cpp

-// RUN: clang-import-test -dump-ast -import %S/Inputs/Hierarchy.cpp -expression %s | FileCheck %s
-
-// CHECK: Overrides:{{.*}}Base::foo
+// RUN: clang-import-test -dump-ir -import %S/Inputs/Callee.cpp -expression %s | FileCheck %s
+// XFAIL: *
+// CHECK: %struct.S = type { i32 }
+// CHECK: %struct.S.0 = type { i8 }
 
 void foo() {
-  Derived d;
+  return Bar().bar(3, true);
 }

tools/clang-import-test/clang-import-test.cpp

 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/MultiplexConsumer.h"
 #include "clang/Frontend/TextDiagnosticBuffer.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Parse/ParseAST.h"
 
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/Signals.h"
 
 #include <memory>
 #include <string>
 
static llvm::cl::opt<std::string>
     Input("x", llvm::cl::Optional,
           llvm::cl::desc("The language to parse (default: c++)"),
           llvm::cl::init("c++"));
 
 static llvm::cl::opt<bool>
 DumpAST("dump-ast", llvm::cl::init(false),
         llvm::cl::desc("Dump combined AST"));
 
+static llvm::cl::opt<bool>
+DumpIR("dump-ir", llvm::cl::init(false),
+        llvm::cl::desc("Dump IR from final parse"));
+
 namespace init_convenience {
 class TestDiagnosticConsumer : public DiagnosticConsumer {
 private:
   std::unique_ptr<TextDiagnosticBuffer> Passthrough;
   const LangOptions *LangOpts = nullptr;
 
 public:
   TestDiagnosticConsumer()
llvm::Error ParseSource(const std::string &Path, CompilerInstance &CI,
   SM.setMainFileID(SM.createFileID(FE, SourceLocation(), SrcMgr::C_User));
   ParseAST(CI.getPreprocessor(), &Consumer, CI.getASTContext());
   return llvm::Error::success();
 }
 
 llvm::Expected<std::unique_ptr<CompilerInstance>>
 Parse(const std::string &Path,
       llvm::ArrayRef<std::unique_ptr<CompilerInstance>> Imports,
-      bool ShouldDumpAST) {
+      bool ShouldDumpAST, bool ShouldDumpIR) {
   std::unique_ptr<CompilerInstance> CI =
       init_convenience::BuildCompilerInstance();
   auto ST = llvm::make_unique<SelectorTable>();
   auto BC = llvm::make_unique<Builtin::Context>();
   std::unique_ptr<ASTContext> AST =
       init_convenience::BuildASTContext(*CI, *ST, *BC);
   CI->setASTContext(AST.release());
   if (Imports.size())
     AddExternalSource(*CI, Imports);
 
   std::vector<std::unique_ptr<ASTConsumer>> ASTConsumers;
 
   auto LLVMCtx = llvm::make_unique<llvm::LLVMContext>();
   ASTConsumers.push_back(init_convenience::BuildCodeGen(*CI, *LLVMCtx));
+  auto &CG = *static_cast<CodeGenerator*>(ASTConsumers.back().get());
 
   if (ShouldDumpAST)
     ASTConsumers.push_back(CreateASTDumper("", true, false, false));
 
   CI->getDiagnosticClient().BeginSourceFile(CI->getLangOpts(),
                                             &CI->getPreprocessor());
   MultiplexConsumer Consumers(std::move(ASTConsumers));
   Consumers.Initialize(CI->getASTContext());
 
   if (llvm::Error PE = ParseSource(Path, *CI, Consumers)) {
     return std::move(PE);
   }
   CI->getDiagnosticClient().EndSourceFile();
+  if (ShouldDumpIR) {
+    CG.GetModule()->print(llvm::outs(), nullptr);
+  }
   if (CI->getDiagnosticClient().getNumErrors()) {
     return llvm::make_error<llvm::StringError>(
         "Errors occured while parsing the expression.", std::error_code());
   } else {
     return std::move(CI);
   }
 }
 
 } // end namespace
 
 int main(int argc, const char **argv) {
   const bool DisableCrashReporting = true;
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0], DisableCrashReporting);
   llvm::cl::ParseCommandLineOptions(argc, argv);
   std::vector<std::unique_ptr<CompilerInstance>> ImportCIs;
   for (auto I : Imports) {
     llvm::Expected<std::unique_ptr<CompilerInstance>> ImportCI =
-      Parse(I, {}, false);
+      Parse(I, {}, false, false);
     if (auto E = ImportCI.takeError()) {
       llvm::errs() << llvm::toString(std::move(E));
       exit(-1);
     } else {
       ImportCIs.push_back(std::move(*ImportCI));
     }
   }
   std::vector<std::unique_ptr<CompilerInstance>> IndirectCIs;
   if (!Direct) {
     for (auto &ImportCI : ImportCIs) {
       std::unique_ptr<CompilerInstance> IndirectCI = BuildIndirect(ImportCI);
       IndirectCIs.push_back(std::move(IndirectCI));
     }
   }
   llvm::Expected<std::unique_ptr<CompilerInstance>> ExpressionCI =
-      Parse(Expression, Direct ? ImportCIs : IndirectCIs, DumpAST);
+      Parse(Expression, Direct ? ImportCIs : IndirectCIs, DumpAST, DumpIR);
   if (auto E = ExpressionCI.takeError()) {
     llvm::errs() << llvm::toString(std::move(E));
     exit(-1);
   } else {
     return 0;
   }
 }