[clang][Driver] Implement AddClangSystemIncludeArgs and HasNativeLLVMSupport for the OpenBSD clang driver.

[3405691582]

Summary

If not overridden, AddClangSystemIncludeArgs's implementation is empty, so by default, no system include args are added to the clang driver. This means that invoking clang without the frontend must include a manual -I /usr/include flag, which is inconsistent behavior. Therefore, override and implement this method to match. Some boilerplate is also borrowed for handling of the other driver flags.

While we are here, also override and enable HasNativeLLVMSupport.

[3405691582]

Finally got the formatting fixed properly.

[brad]

Looks reasonable. I'm a little surprised I don't see this in the FreeBSD driver. What about FreeBSD, NetBSD and DragonFly?

[3405691582]

Those platforms still use the legacy mechanism in InitHeaderSearch.cpp. For platforms which have moved include handling to the driver, the mechanism in InitHeaderSearch::AddDefaultIncludePaths becomes a noop.

This reminds me of a couple of things: we should also ensure that include management gets delegated in the same way -- it doesn't cause an immediate problem, which is why I missed it here -- so I've updated the diff and summary here to do that. Furthermore, as I understand it, the lack of /usr/include is only applicable when something is invoking clang programatically[1] rather than with the frontend.

[1] In the concrete that motivated this, this is exposed with the Swift programming language and its clang-based C interop. When swiftc tries to build a module, despite absolute path references to platform header files, those headers may include ongoing references with angle brackets, which fails because the invoked preprocessor doesn't have the search paths set up.

[brad]

I was wondering why we had not seen any issues like this but your followup post clarified the situation.

Thank you.

LGTM.

[3405691582]

Thanks! please commit on my behalf as appropriate.

clang/lib/Driver/ToolChains/OpenBSD.h

public:
 
   RuntimeLibType GetDefaultRuntimeLibType() const override {
     return ToolChain::RLT_CompilerRT;
   }
   CXXStdlibType GetDefaultCXXStdlibType() const override {
     return ToolChain::CST_Libcxx;
   }
 
+  void
+  AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
+                            llvm::opt::ArgStringList &CC1Args) const override;
+
+  bool HasNativeLLVMSupport() const override;
+
   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
                            llvm::opt::ArgStringList &CmdArgs) const override;
 
   unsigned GetDefaultStackProtectorLevel(bool KernelOrKext) const override {
     return 2;
   }
   unsigned GetDefaultDwarfVersion() const override { return 2; }
 

clang/lib/Driver/ToolChains/OpenBSD.cpp

 //===--- OpenBSD.cpp - OpenBSD ToolChain Implementations --------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "OpenBSD.h"
 #include "Arch/Mips.h"
 #include "Arch/Sparc.h"
 #include "CommonArgs.h"
+#include "clang/Config/config.h"
 #include "clang/Driver/Compilation.h"
 #include "clang/Driver/Options.h"
 #include "clang/Driver/SanitizerArgs.h"
 #include "llvm/Option/ArgList.h"
+#include "llvm/Support/Path.h"
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
 
 void openbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,

 void OpenBSD::addClangTargetOptions(const ArgList &DriverArgs,
                                     ArgStringList &CC1Args,
                                     Action::OffloadKind) const {
   // Support for .init_array is still new (Aug 2016).
   if (!DriverArgs.hasFlag(options::OPT_fuse_init_array,
                           options::OPT_fno_use_init_array, false))
     CC1Args.push_back("-fno-use-init-array");
 }
+
+void OpenBSD::AddClangSystemIncludeArgs(
+    const llvm::opt::ArgList &DriverArgs,
+    llvm::opt::ArgStringList &CC1Args) const {
+  const Driver &D = getDriver();
+
+  if (DriverArgs.hasArg(clang::driver::options::OPT_nostdinc))
+    return;
+
+  if (!DriverArgs.hasArg(options::OPT_nobuiltininc)) {
+    SmallString<128> Dir(D.ResourceDir);
+    llvm::sys::path::append(Dir, "include");
+    addSystemInclude(DriverArgs, CC1Args, Dir.str());
+  }
+
+  if (DriverArgs.hasArg(options::OPT_nostdlibinc))
+    return;
+
+  // Check for configure-time C include directories.
+  StringRef CIncludeDirs(C_INCLUDE_DIRS);
+  if (CIncludeDirs != "") {
+    SmallVector<StringRef, 5> dirs;
+    CIncludeDirs.split(dirs, ":");
+    for (StringRef dir : dirs) {
+      StringRef Prefix =
+          llvm::sys::path::is_absolute(dir) ? StringRef(D.SysRoot) : "";
+      addExternCSystemInclude(DriverArgs, CC1Args, Prefix + dir);
+    }
+    return;
+  }
+
+  addExternCSystemInclude(DriverArgs, CC1Args, D.SysRoot + "/usr/include");
+}
+
+bool OpenBSD::HasNativeLLVMSupport() const { return true; }

clang/lib/Frontend/InitHeaderSearch.cpp

for (StringRef dir : dirs)
       AddPath(dir, ExternCSystem, false);
     return;
   }
 
   switch (os) {
   case llvm::Triple::Linux:
   case llvm::Triple::Hurd:
   case llvm::Triple::Solaris:
+  case llvm::Triple::OpenBSD:
     llvm_unreachable("Include management is handled in the driver.");
 
   case llvm::Triple::CloudABI: {
     // <sysroot>/<triple>/include
     SmallString<128> P = StringRef(HSOpts.ResourceDir);
     llvm::sys::path::append(P, "../../..", triple.str(), "include");
     AddPath(P, System, false);
     break;
void InitHeaderSearch::AddDefaultIncludePaths(const LangOptions &Lang,
   // exempted from this logic here until we can delete the entire pile of code.
   switch (triple.getOS()) {
   default:
     break; // Everything else continues to use this routine's logic.
 
   case llvm::Triple::Emscripten:
   case llvm::Triple::Linux:
   case llvm::Triple::Hurd:
+  case llvm::Triple::OpenBSD:
   case llvm::Triple::Solaris:
   case llvm::Triple::WASI:
   case llvm::Triple::AIX:
     return;
 
   case llvm::Triple::Win32:
     if (triple.getEnvironment() != llvm::Triple::Cygnus ||
         triple.isOSBinFormatMachO())