[Flang][Driver]Add new flang driver main() entrypoint

[CarolineConcatto]

Summary

Depends on D73951

This work implements the "driver" part of an RFC sent to cfe-dev in [1].
The entry point adds a binary called bin/flang-tmp because ATM flang is in use
by flang.sh.
The goal is to have the old flang.sh removed from the install to make way
for flang-tmp.

bin/flang-tmp is implemented in terms of clang::Driver, defaulting to the
--driver-mode=flang added to clang in [2]. Therefore it adds libClang in
the CMake.

This patch uses a new flag ('fortran-fe' for fortran frontend) introduced
in [3], which is under review. bin/flang-tmp will select the frontend
flang-tmp -fc1 instead of flang -fc1 (in the code we set -fortran-fe=flang-tmp)
while flang is at use.

Regression tests are added in test/driver, which mirror some tests in the
clang/test/Driver directory, flang.f90 and flang.F90. The primary difference is
that the clang tests run clang --driver-mode=flang <input>, whereas these tests
run flang <input>.

[1] "RFC: Adding a fortran mode to the clang driver for flang"
http://lists.llvm.org/pipermail/cfe-dev/2019-June/062669.html
[2] [clang][driver] Add basic --driver-mode=flang support for fortran
https://reviews.llvm.org/D63607
[3][Clang][Driver]Add logic to search for flang frontend
https://reviews.llvm.org/D73951

Signed-off-by: Caroline Concatto <[e-mail]>

[CarolineConcatto]

Minor fixes on CMakeLists.txt

[sscalpone]

This change adds a build dependency on clang.

What's the level-of-effort required to extract the shared functionality into llvm/lib/Frontend?

[awarzynski]

What's the level-of-effort required to extract the shared functionality into llvm/lib/Frontend?

@sscalpone , let me chime in. This patch only really requires clang::DiagnosticsEngine (from clangBasic) and clang::driver (from clangDriver), so not that much. Extracting thess into a separate library shouldn't be too difficult on it's own. However, it would mean redefining the libraries in clang.

• This is likely to have a huge impact on a lot of mature upstream and downstream LLVM projects (these projects would have to re-define their dependencies)
• In my opinion this should be discussed with the community first (i.e. via llvm-dev, cfe-dev and flang-dev)
• It could have bigger impact on LLVM/clang that I don't see right now.

Also, as we make progress we are likely to discover that we need to repeat this exercise a few more times (i.e. refactor more clang components).

We wanted to take an alternative approach - develop a clang-based replacement for flang (the bash wrapper) and only then refactor the common bits into a dedicated library. I think that at that point we will be better informed as what exactly is required and truly _common_.

[CarolineConcatto]

@sscalpone can you tell us what is your concern? It is compiling time now that the driver is not fully functional?

If it is compiling time, what I can do to save compiler time while the driver is not functional is do the same as FIR by using a similar CMake variable as LINK_WITH_FIR.

I could create a variable for the driver, that we would only build it with clang dependencies when we want to build the new driver.

Now, if the problem is linking the driver with Clang than I agree with @awarzynski and this is a problem that we may be able to solve later in this project.

flang/CMakeLists.txt

246

This is a mistake. The patch works with -Werror. I'll revert this

[kiranchandramohan]

I think @sscalpone's point is that the following currently works but will not work after this patch since we need to build clang (add to DLLVM_ENABLE_PROJECTS) also.
cmake ../llvm -DLLVM_ENABLE_PROJECTS="mlir;flang"

[CarolineConcatto]

Ok, when the driver is fully implemented this could be true.
But for now if this is the problem I can do the same as MLIR for FIR.

[schweitz]

In D79092#2014577, @CarolineConcatto wrote:

Ok, when the driver is fully implemented this could be true.
But for now if this is the problem I can do the same as MLIR for FIR.

I would advise against making sections of the compiler build optional. It leads to mischief.

[CarolineConcatto]

@schweitz Ok, I am open to solutions for the concern @sscalpone brought.
I suggested the flag because I can see it is what is done with MLIR for FIR.
ATM it is not possible to remove clang from the libraries because the Driver class is inside clang.
Probably the Driver class will need to be refactored in the future, maybe when we have a stable flang driver.
But for now, it will only delay more flang driver functionality.

[CarolineConcatto]

Is it fine to always build clang and the driver as a standard?

[tskeith]

I like the idea of a cmake option as a temporary way to disable building the driver until the clang part can be properly extracted out. One shouldn't be forced to build all of clang just to build flang.

[sscalpone]

Extracting these into a separate library shouldn't be too difficult

@CarolineConcatto @awarzynski llvm/lib/Frontend was created exactly for this kind of work. I recommend that you plan to refactor the components that are required & share your proposal with cfe-dev and llvm-dev. The long-range plan shared with cfe-dev [1] may need to be updated.

[1] http://lists.llvm.org/pipermail/cfe-dev/2019-June/062669.html

[schweitz]

In D79092#2017168, @CarolineConcatto wrote:

@schweitz Ok, I am open to solutions for the concern @sscalpone brought.
I suggested the flag because I can see it is what is done with MLIR for FIR.
ATM it is not possible to remove clang from the libraries because the Driver class is inside clang.
Probably the Driver class will need to be refactored in the future, maybe when we have a stable flang driver.
But for now, it will only delay more flang driver functionality.

My point is that if you make it optional, others may understand that to mean it is not a first-class part of the compiler. You risk having changes that simply do not consider it. I believe "optional FIR" was a mistake and it should have been removed.

[CarolineConcatto]

Thank you all for your inputs!
This discussion has raised some valuable points and we’d like to address all of them.
Thank you for the suggestion @sscalpone! Yes, we will send and updated RFC shortly and continue the discussion on the mailing list.
The older RFC sent by Peter Waller was done before flang landed in llvm-project monorepo and needs some re-thinking and pruning.

[CarolineConcatto]

I'll close this PR as we believe we will not need this flag for Flang driver.
There are some development happening in:
https://github.com/banach-space/llvm-project
for now.

flang/CMakeLists.txt

if (NOT LLVM_CXX_STD EQUAL "c++17")
       message("    removing '-std=${LLVM_CXX_STD}'")
       message("    CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}'")
       string(REPLACE " -std=${LLVM_CXX_STD}" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
       message("    [NEW] CMAKE_CXX_FLAGS='${CMAKE_CXX_FLAGS}'")
     endif()
   endif()
 
   link_directories("${LLVM_LIBRARY_DIR}")
-
-  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
   set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
     ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX})
   set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
     ${CMAKE_BINARY_DIR}/lib${LLVM_LIBDIR_SUFFIX})
 
   set(BACKEND_PACKAGE_STRING "LLVM ${LLVM_PACKAGE_VERSION}")
   set(LLVM_EXTERNAL_LIT "${LLVM_TOOLS_BINARY_DIR}/llvm-lit" CACHE STRING "Command used to spawn lit")
 
if (LINK_WITH_FIR)
     set(MLIR_INCLUDE_DIR ${LLVM_MAIN_SRC_DIR}/../mlir/include ) # --includedir
     set(MLIR_TABLEGEN_OUTPUT_DIR ${CMAKE_BINARY_DIR}/tools/mlir/include)
     set(MLIR_TABLEGEN_EXE $<TARGET_FILE:mlir-tblgen>)
     include_directories(SYSTEM ${MLIR_INCLUDE_DIR})
     include_directories(SYSTEM ${MLIR_TABLEGEN_OUTPUT_DIR})
   endif()
 endif()
 
+# Add Clang libraries used by the flang-tmp driver
+set(CLANG_MAIN_SRC_DIR ${LLVM_MAIN_SRC_DIR}/../clang/include ) # --src-root
+set(CLANG_INCLUDE_DIR ${LLVM_MAIN_SRC_DIR}/../clang/include ) # --includedir
+set(CLANG_TABLEGEN_OUTPUT_DIR ${CMAKE_BINARY_DIR}/tools/clang/include)
+set(CLANG_TABLEGEN_EXE $<TARGET_FILE:clang-tblgen>)
+include_directories(SYSTEM ${CLANG_INCLUDE_DIR})
+include_directories(SYSTEM ${CLANG_TABLEGEN_OUTPUT_DIR})
+
 if(LINK_WITH_FIR)
   # tco tool and FIR lib output directories
   set(LLVM_RUNTIME_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/bin)
   set(LLVM_LIBRARY_OUTPUT_INTDIR ${CMAKE_BINARY_DIR}/lib)
   # Always build tco tool
   set(LLVM_BUILD_TOOLS ON)
   message(STATUS "Linking driver with FIR and LLVM")
   llvm_map_components_to_libnames(LLVM_COMMON_LIBS support)
configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/include/flang/Version.inc.in
   ${CMAKE_CURRENT_BINARY_DIR}/include/flang/Version.inc)
 # Configure Flang's version info header file.
 configure_file(
   ${FLANG_SOURCE_DIR}/include/flang/Config/config.h.cmake
   ${FLANG_BINARY_DIR}/include/flang/Config/config.h)
 
 # Add global F18 flags.
-set(CMAKE_CXX_FLAGS "-fno-rtti -fno-exceptions -pedantic -Wall -Wextra -Werror -Wcast-qual -Wimplicit-fallthrough -Wdelete-non-virtual-dtor ${CMAKE_CXX_FLAGS}")
+set(CMAKE_CXX_FLAGS "-fno-rtti -fno-exceptions -pedantic -Wall -Wextra -Wcast-qual -Wimplicit-fallthrough -Wdelete-non-virtual-dtor ${CMAKE_CXX_FLAGS}")
 
 # Builtin check_cxx_compiler_flag doesn't seem to work correctly
 macro(check_compiler_flag flag resultVar)
   unset(${resultVar} CACHE)
   check_cxx_compiler_flag("${flag}" ${resultVar})
 endmacro()
 
 check_compiler_flag("-Werror -Wno-deprecated-copy" CXX_SUPPORTS_NO_DEPRECATED_COPY_FLAG)

flang/include/flang/Frontend/TextDiagnosticPrinter.h

+//===--- TextDiagnosticPrinter.h - Text Diagnostic Client -------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is a dummy implemenation of concrete diagnostic client for flang.
+// TODO: Print diagnostics to standard error.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/Diagnostic.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+
+class TextDiagnosticPrinter : public clang::DiagnosticConsumer {
+  llvm::raw_ostream &OS;
+  clang::IntrusiveRefCntPtr<clang::DiagnosticOptions> DiagOpts;
+
+  unsigned OwnsOutputStream : 1;
+
+public:
+  TextDiagnosticPrinter(llvm::raw_ostream &os, clang::DiagnosticOptions *diags,
+                        bool OwnsOutputStream = false);
+  ~TextDiagnosticPrinter() override;
+};

flang/lib/CMakeLists.txt

 add_subdirectory(Common)
 add_subdirectory(Evaluate)
 add_subdirectory(Decimal)
+add_subdirectory(Frontend)
 add_subdirectory(Lower)
 add_subdirectory(Parser)
 add_subdirectory(Semantics)
 
 if(LINK_WITH_FIR)
   add_subdirectory(Optimizer)
 endif()

flang/lib/Frontend/CMakeLists.txt

+add_library(flangFrontend
+  TextDiagnosticPrinter.cpp
+ )
+
+target_link_libraries(flangFrontend
+  LLVMOption
+  LLVMSupport
+  clangBasic
+  clangDriver
+)
+
+install (TARGETS flangFrontend
+  ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib
+  RUNTIME DESTINATION bin
+)

flang/lib/Frontend/TextDiagnosticPrinter.cpp

+//===--- TextDiagnosticPrinter.cpp - Diagnostic Printer -------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This diagnostic client ATM only creates and destroys the object.
+// TODO: Diagnostic client should print the diagnostic messages for flang.
+//
+//===----------------------------------------------------------------------===//
+
+#include "flang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "llvm/Support/raw_ostream.h"
+
+TextDiagnosticPrinter::TextDiagnosticPrinter(llvm::raw_ostream &os,
+                                             clang::DiagnosticOptions *diags,
+                                             bool _OwnsOutputStream)
+    : OS(os), DiagOpts(diags), OwnsOutputStream(_OwnsOutputStream) {}
+
+TextDiagnosticPrinter::~TextDiagnosticPrinter() {
+  if (OwnsOutputStream)
+    delete &OS;
+}

flang/test/Driver/flang.F90

+! Check that flang -fc1 is invoke.
+
+! This is a copy of flang.f90 because the driver has logic in it which
+! differentiates between F90 and f90 files. Flang will not treat these files
+! differently.
+
+! Test various output types:
+! * -E
+! * -fsyntax-only
+! * -emit-llvm -S
+! * -emit-llvm
+! * -S
+! * (no type specified, resulting in an object file)
+
+! All invocations should begin with flang-tmp -fc1.
+! ALL-LABEL: "{{[^"]*}}flang-tmp" "-fc1"
+
+! Check that f90 files are not treated as "previously preprocessed".
+
+! RUN: %flang-tmp -### -E                  %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-E %s
+! CHECK-E-NOT: previously preprocessed input
+! CHECK-E-DAG: "-E"
+! CHECK-E-DAG: "-o" "-"
+
+! RUN: %flang-tmp -### -emit-ast           %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-AST %s
+! CHECK-EMIT-AST-DAG: "-triple"
+! CHECK-EMIT-AST-DAG: "-emit-ast"
+! CHECK-EMIT-AST-DAG: "-o" "{{[^"]*}}.ast"
+
+! RUN: %flang-tmp -### -fsyntax-only       %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-SYNTAX-ONLY %s
+! CHECK-SYNTAX-ONLY-NOT: "-o"
+! CHECK-SYNTAX-ONLY-DAG: "-fsyntax-only"
+
+! RUN: %flang-tmp -### -emit-llvm -S       %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-LLVM-IR %s
+! CHECK-EMIT-LLVM-IR-DAG: "-emit-llvm"
+! CHECK-EMIT-LLVM-IR-DAG: "-o" "{{[^"]*}}.ll"
+
+! RUN: %flang-tmp -### -emit-llvm          %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-LLVM-BC %s
+! CHECK-EMIT-LLVM-BC-DAG: "-emit-llvm-bc"
+! CHECK-EMIT-LLVM-BC-DAG: "-o" "{{[^"]*}}.bc"
+
+! RUN: %flang-tmp -### -S                  %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-S %s
+! CHECK-S-DAG: "-S"
+! CHECK-S-DAG: "-o" "{{[^"]*}}.s"
+
+! RUN: %flang-tmp -###                     %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-OBJ %s
+! CHECK-EMIT-OBJ-DAG: "-emit-obj"
+! CHECK-EMIT-OBJ-DAG: "-o" "{{[^"]*}}.o"
+
+! Should end in the input file.
+! ALL: "{{.*}}flang.F90"{{$}}

flang/test/Driver/flang.f90

+! Check that flang -fc1 is invoked when in.
+
+! This is a copy of flang.F90 because the driver has logic in it which
+! differentiates between F90 and f90 files. Flang will not treat these files
+! differently.
+
+! Test various output types:
+! * -E
+! * -fsyntax-only
+! * -emit-llvm -S
+! * -emit-llvm
+! * -S
+! * (no type specified, resulting in an object file)
+
+! All invocations should begin with flang-tmp -fc1.
+! ALL-LABEL: "{{[^"]*}}flang-tmp" "-fc1"
+
+! Check that f90 files are not treated as "previously preprocessed"
+
+! RUN: %flang-tmp -### -E                  %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-E %s
+! CHECK-E-NOT: previously preprocessed input
+! CHECK-E-DAG: "-E"
+! CHECK-E-DAG: "-o" "-"
+
+! RUN: %flang-tmp -### -emit-ast           %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-AST %s
+! CHECK-EMIT-AST-DAG: "-triple"
+! CHECK-EMIT-AST-DAG: "-emit-ast"
+! CHECK-EMIT-AST-DAG: "-o" "{{[^"]*}}.ast"
+
+! RUN: %flang-tmp -### -fsyntax-only       %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-SYNTAX-ONLY %s
+! CHECK-SYNTAX-ONLY-NOT: "-o"
+! CHECK-SYNTAX-ONLY-DAG: "-fsyntax-only"
+
+! RUN: %flang-tmp -### -emit-llvm -S       %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-LLVM-IR %s
+! CHECK-EMIT-LLVM-IR-DAG: "-emit-llvm"
+! CHECK-EMIT-LLVM-IR-DAG: "-o" "{{[^"]*}}.ll"
+
+! RUN: %flang-tmp -### -emit-llvm          %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-LLVM-BC %s
+! CHECK-EMIT-LLVM-BC-DAG: "-emit-llvm-bc"
+! CHECK-EMIT-LLVM-BC-DAG: "-o" "{{[^"]*}}.bc"
+
+! RUN: %flang-tmp -### -S                  %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-S %s
+! CHECK-S-DAG: "-S"
+! CHECK-S-DAG: "-o" "{{[^"]*}}.s"
+
+! RUN: %flang-tmp -###                     %s 2>&1 | FileCheck --check-prefixes=ALL,CHECK-EMIT-OBJ %s
+! CHECK-EMIT-OBJ-DAG: "-emit-obj"
+! CHECK-EMIT-OBJ-DAG: "-o" "{{[^"]*}}.o"
+
+! Should end in the input file.
+! ALL: "{{.*}}flang.f90"{{$}}

flang/test/lit.cfg.py

 # For each occurrence of a flang tool name, replace it with the full path to
 # the build directory holding that tool.  We explicitly specify the directories
 # to search to ensure that we get the tools just built and not some random
 # tools that might happen to be in the user's PATH.
 tool_dirs = [config.llvm_tools_dir, config.flang_tools_dir]
 flang_includes = "-I" + config.flang_intrinsic_modules_dir
 
 tools = [ToolSubst('%flang', command=FindTool('flang'), unresolved='fatal'),
+         ToolSubst('%flang-tmp', command=FindTool('flang-tmp'), unresolved='fatal'),
          ToolSubst('%f18', command=FindTool('f18'), unresolved='fatal'),
          ToolSubst('%f18_with_includes', command=FindTool('f18'),
          extra_args=[flang_includes], unresolved='fatal')]
 
 llvm_config.add_tool_substitutions(tools, tool_dirs)
 
 # Enable libpgmath testing
 result = lit_config.params.get("LIBPGMATH")
 if result:
     config.environment["LIBPGMATH"] = True

flang/tools/CMakeLists.txt

 #===-- tools/CMakeLists.txt ------------------------------------------------===#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 #===------------------------------------------------------------------------===#
 
 add_subdirectory(f18)
+add_subdirectory(flang)
 if(LINK_WITH_FIR)
   add_subdirectory(tco)
 endif()
 add_subdirectory(f18-parse-demo)

flang/tools/flang/CMakeLists.txt

+# Infrastructure to build flang driver entry point. Flang driver dependes on
+# LLVM libraries.
+
+# Set your project compile flags.
+link_directories(${LLVM_LIBRARY_DIR})
+
+add_executable(flang-tmp
+  driver.cpp
+)
+
+# Link against LLVM and Clang libraries
+target_link_libraries(flang-tmp
+  PRIVATE
+  ${LLVM_COMMON_LIBS}
+  flangFrontend
+  clangDriver
+  clangBasic
+  LLVMSupport
+  LLVMTarget
+  LLVMOption
+)
+
+install(TARGETS flang-tmp DESTINATION bin)

flang/tools/flang/driver.cpp

+//===-- main.cpp - Flang e Driver -----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This is the entry point to the flang driver; it is a thin wrapper
+// for functionality in the Driver flang library.
+//
+//===----------------------------------------------------------------------===//
+#include "flang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticIDs.h"
+#include "clang/Basic/DiagnosticOptions.h"
+#include "clang/Driver/Compilation.h"
+#include "clang/Driver/Driver.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/Option/ArgList.h"
+#include "llvm/Support/Host.h"
+#include "llvm/Support/InitLLVM.h"
+#include "llvm/Support/VirtualFileSystem.h"
+
+std::string GetExecutablePath(const char *Argv0) {
+  // This just needs to be some symbol in the binary; C++ doesn't
+  // allow taking the address of ::main however.
+  void *P = (void *)(intptr_t)GetExecutablePath;
+  return llvm::sys::fs::getMainExecutable(Argv0, P);
+}
+
+// This lets us create the DiagnosticsEngine with a properly-filled-out
+// DiagnosticOptions instance
+static clang::DiagnosticOptions *
+CreateAndPopulateDiagOpts(llvm::ArrayRef<const char *> argv) {
+  auto *DiagOpts = new clang::DiagnosticOptions;
+  return DiagOpts;
+}
+
+int main(int argc_, const char **argv_) {
+
+  llvm::InitLLVM X(argc_, argv_);
+  llvm::SmallVector<const char *, 256> argv(argv_, argv_ + argc_);
+
+  clang::driver::ParsedClangName TargetandMode("flang", "--driver-mode=flang");
+  std::string Path = GetExecutablePath(argv[0]);
+
+  // Give to the driver the name of the frontend
+  // It is a temporary solution for a temporary problem
+  // To be removed when flang-tmp is the main driver
+  argv.push_back("-fortran-fe");
+  argv.push_back(basename(argv[0]));
+
+  llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> DiagOpts =
+      CreateAndPopulateDiagOpts(argv);
+  llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> DiagID(
+      new clang::DiagnosticIDs());
+  TextDiagnosticPrinter *DiagClient =
+      new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
+  clang::DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);
+
+  clang::driver::Driver TheDriver(Path, llvm::sys::getDefaultTargetTriple(),
+                                  Diags);
+  TheDriver.setTargetAndMode(TargetandMode);
+  std::unique_ptr<clang::driver::Compilation> C(
+      TheDriver.BuildCompilation(argv));
+  llvm::SmallVector<std::pair<int, const clang::driver::Command *>, 4>
+      FailingCommands;
+  return TheDriver.ExecuteCompilation(*C, FailingCommands);
+}