[libclang] Add clang_Driver_getExternalActionsForCommand_v0

This function returns the equivalent of -###

<rdar://problem/49928458>
<rdar://problem/49396121>

Author: Bigcheese

clang/include/clang-c/Driver.h

@@ -0,0 +1,78 @@
+/*==-- clang-c/Driver.h - A C Interface for the Clang Driver ------*- 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 header provides a C API for extracting information from the clang     *|
+|* driver.                                                                    *|
+|*                                                                            *|
+\*===----------------------------------------------------------------------===*/
+
+
+#ifndef CLANG_CLANG_C_DRIVER
+#define CLANG_CLANG_C_DRIVER
+
+#include "clang-c/Index.h"
+#include "clang-c/Platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Contains the command line arguments for an external action.  Same format as
+ * provided to main.
+ */
+typedef struct {
+  /* Number of arguments in ArgV */
+  int ArgC;
+  /* Null terminated array of pointers to null terminated argument strings */
+  const char **ArgV;
+} CXExternalAction;
+
+/**
+ * Contains the list of external actions clang would invoke.
+ */
+typedef struct {
+  int Count;
+  CXExternalAction **Actions;
+} CXExternalActionList;
+
+/**
+ * Get the external actions that the clang driver will invoke for the given
+ * command line.
+ *
+ * \param ArgC number of arguments in \p ArgV.
+ * \param ArgV array of null terminated arguments.  Doesn't need to be null
+ *   terminated.
+ * \param Environment must be null.
+ * \param WorkingDirectory a null terminated path to the working directory to
+ *   use for this invocation.  `nullptr` to use the current working directory of
+ *   the process.
+ * \param OutDiags will be set to a \c CXDiagnosticSet if there's an error.
+ *   Must be freed by calling \c clang_disposeDiagnosticSet .
+ * \returns A pointer to a \c CXExternalActionList on success, null on failure.
+ *   The returned \c CXExternalActionList must be freed by calling
+ *   \c clang_Driver_ExternalActionList_dispose .
+ */
+CINDEX_LINKAGE CXExternalActionList *
+clang_Driver_getExternalActionsForCommand_v0(int ArgC, const char **ArgV,
+                                             const char **Environment,
+                                             const char *WorkingDirectory,
+                                             CXDiagnosticSet *OutDiags);
+
+/**
+ * Deallocate a \c CXExternalActionList
+ */
+CINDEX_LINKAGE void
+clang_Driver_ExternalActionList_dispose(CXExternalActionList *EAL);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // CLANG_CLANG_C_DRIVER

clang/tools/libclang/CMakeLists.txt

@@ -20,6 +20,7 @@ set(SOURCES
   CXStoredDiagnostic.cpp
   CXString.cpp
   CXType.cpp
+  Driver.cpp
   Indexing.cpp
   FatalErrorHandler.cpp
 

clang/tools/libclang/Driver.cpp

@@ -0,0 +1,125 @@
+//===- Driver.cpp - A C Interface for the Clang 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 file provides a C API for extracting information from the clang driver.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-c/Driver.h"
+
+#include "CIndexDiagnostic.h"
+
+#include "clang/Driver/Compilation.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/DriverDiagnostic.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "llvm/ADT/ArrayRef.h"
+
+using namespace clang;
+
+class CXDiagnosticSetDiagnosticConsumer : public DiagnosticConsumer {
+  SmallVector<StoredDiagnostic, 4> Errors;
+public:
+
+  void HandleDiagnostic(DiagnosticsEngine::Level level,
+  const Diagnostic &Info) override {
+    if (level >= DiagnosticsEngine::Error)
+      Errors.push_back(StoredDiagnostic(level, Info));
+  }
+
+  CXDiagnosticSet getDiagnosticSet() {
+    return cxdiag::createStoredDiags(Errors, LangOptions());
+  }
+};
+
+CXExternalActionList *
+clang_Driver_getExternalActionsForCommand_v0(int ArgC, const char **ArgV,
+                                             const char **Environment,
+                                             const char *WorkingDirectory,
+                                             CXDiagnosticSet *OutDiags) {
+  if (OutDiags)
+    *OutDiags = nullptr;
+
+  // Non empty environments are not currently supported.
+  if (Environment)
+    return nullptr;
+
+  // ArgV must at least include the compiler executable name.
+  if (ArgC < 1)
+    return nullptr;
+
+  CXDiagnosticSetDiagnosticConsumer DiagConsumer;
+  auto Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions,
+                                                   &DiagConsumer, false);
+
+  // Use createPhysicalFileSystem instead of getRealFileSystem so that
+  // setCurrentWorkingDirectory doesn't change the working directory of the
+  // process.
+  std::unique_ptr<llvm::vfs::FileSystem> VFS =
+      llvm::vfs::createPhysicalFileSystem();
+  if (WorkingDirectory)
+    if (std::error_code EC =
+          VFS->setCurrentWorkingDirectory(WorkingDirectory)) {
+      Diags->Report(diag::err_drv_unable_to_set_working_directory) <<
+          WorkingDirectory;
+      if (OutDiags)
+        *OutDiags = DiagConsumer.getDiagnosticSet();
+      return nullptr;
+    }
+
+  driver::Driver TheDriver(ArgV[0], llvm::sys::getDefaultTargetTriple(), *Diags,
+                           VFS.release());
+  TheDriver.setCheckInputsExist(false);
+  std::unique_ptr<driver::Compilation> C(
+      TheDriver.BuildCompilation(llvm::makeArrayRef(ArgV, ArgC)));
+  if (!C) {
+    if (OutDiags)
+      *OutDiags = DiagConsumer.getDiagnosticSet();
+    return nullptr;
+  }
+
+  const driver::JobList &Jobs = C->getJobs();
+  CXExternalAction **Actions = new CXExternalAction *[Jobs.size()];
+  int AI = 0;
+  for (auto &&J : Jobs) {
+    // First calculate the total space we'll need for this action's arguments.
+    llvm::opt::ArgStringList Args = J.getArguments();
+    Args.insert(Args.begin(), J.getExecutable());
+    int ArgSpace = (Args.size() + 1) * sizeof(const char *);
+    for (auto &&Arg : Args)
+      ArgSpace += strlen(Arg) + 1; // Null terminator
+
+    // Tail allocate the space for the strings.
+    auto Action =
+        new ((CXExternalAction *)malloc(sizeof(CXExternalAction) + ArgSpace))
+            CXExternalAction;
+    Action->ArgC = Args.size();
+    Action->ArgV = reinterpret_cast<const char **>(Action + 1);
+    Action->ArgV[Args.size()] = nullptr;
+    char *StrTable = ((char *)Action) + sizeof(CXExternalAction) +
+                     (Args.size() + 1) * sizeof(const char *);
+    int I = 0;
+    for (auto &&Arg : Args) {
+      Action->ArgV[I++] = strcpy(StrTable, Arg);
+      StrTable += strlen(Arg) + 1;
+    }
+    Actions[AI++] = Action;
+  }
+
+  return new CXExternalActionList{(int)Jobs.size(), Actions};
+}
+
+void clang_Driver_ExternalActionList_dispose(CXExternalActionList *EAL) {
+  if (!EAL)
+    return;
+
+  for (int I = 0; I < EAL->Count; ++I)
+    free(EAL->Actions[I]);
+  delete[] EAL->Actions;
+  delete EAL;
+}

clang/tools/libclang/libclang.exports

@@ -49,6 +49,8 @@ clang_Cursor_isObjCOptional
 clang_Cursor_isVariadic
 clang_Cursor_getModule
 clang_Cursor_getStorageClass
+clang_Driver_ExternalActionList_dispose
+clang_Driver_getExternalActionsForCommand_v0
 clang_File_isEqual
 clang_File_tryGetRealPathName
 clang_Module_getASTFile

clang/unittests/libclang/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_clang_unittest(libclangTests
   LibclangTest.cpp
+  DriverTest.cpp
   )
 
 target_link_libraries(libclangTests

clang/unittests/libclang/DriverTest.cpp

@@ -0,0 +1,75 @@
+//===---- DriverTest.cpp --------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-c/Driver.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Debug.h"
+#include "gtest/gtest.h"
+
+#define DEBUG_TYPE "driver-test"
+
+TEST(DriverTests, Basic) {
+  const char *ArgV[] = {"clang", "-w", "t.cpp", "-o", "t.ll"};
+
+  CXExternalActionList *EAL = clang_Driver_getExternalActionsForCommand_v0(
+      GTEST_ARRAY_SIZE_(ArgV), ArgV, nullptr, nullptr, nullptr);
+  ASSERT_NE(EAL, nullptr);
+  ASSERT_EQ(EAL->Count, 2);
+  auto *CompileAction = EAL->Actions[0];
+  ASSERT_GE(CompileAction->ArgC, 2);
+  EXPECT_STREQ(CompileAction->ArgV[0], "clang");
+  EXPECT_STREQ(CompileAction->ArgV[1], "-cc1");
+
+  clang_Driver_ExternalActionList_dispose(EAL);
+}
+
+TEST(DriverTests, WorkingDirectory) {
+  const char *ArgV[] = {"clang", "-c", "t.cpp", "-o", "t.o"};
+
+  CXExternalActionList *EAL = clang_Driver_getExternalActionsForCommand_v0(
+      GTEST_ARRAY_SIZE_(ArgV), ArgV, nullptr, "/", nullptr);
+  ASSERT_NE(EAL, nullptr);
+  ASSERT_EQ(EAL->Count, 1);
+  auto *CompileAction = EAL->Actions[0];
+
+  const char **FDCD = std::find(CompileAction->ArgV, CompileAction->ArgV +
+                                                     CompileAction->ArgC,
+                                llvm::StringRef("-fdebug-compilation-dir"));
+  ASSERT_NE(FDCD, CompileAction->ArgV + CompileAction->ArgC);
+  ASSERT_NE(FDCD + 1, CompileAction->ArgV + CompileAction->ArgC);
+  EXPECT_STREQ(*(FDCD + 1), "/");
+
+  clang_Driver_ExternalActionList_dispose(EAL);
+}
+
+TEST(DriverTests, Diagnostics) {
+  const char *ArgV[] = {"clang", "-c", "nosuchfile.cpp", "-o", "t.o"};
+
+  CXExternalActionList *EAL = clang_Driver_getExternalActionsForCommand_v0(
+    GTEST_ARRAY_SIZE_(ArgV), ArgV, nullptr, "/no/such/working/dir", nullptr);
+  EXPECT_EQ(nullptr, EAL);
+  clang_Driver_ExternalActionList_dispose(EAL);
+
+  CXDiagnosticSet Diags;
+  EAL = clang_Driver_getExternalActionsForCommand_v0(
+    GTEST_ARRAY_SIZE_(ArgV), ArgV, nullptr, "/no/such/working/dir", &Diags);
+  EXPECT_EQ(nullptr, EAL);
+  ASSERT_NE(nullptr, Diags);
+
+  unsigned NumDiags = clang_getNumDiagnosticsInSet(Diags);
+  ASSERT_EQ(1u, NumDiags);
+  CXDiagnostic Diag = clang_getDiagnosticInSet(Diags, 0);
+  CXString Str = clang_formatDiagnostic(Diag, 0);
+  EXPECT_STREQ(clang_getCString(Str),
+               "error: unable to set working directory: /no/such/working/dir");
+  clang_disposeString(Str);
+
+  clang_disposeDiagnosticSet(Diags);
+  clang_Driver_ExternalActionList_dispose(EAL);
+}