Add -L/path/to/cuda/lib if any of our inputs are CUDA files.

[tra]

lib/Driver/ToolChains.cpp

4125

We may need a new option as -nocudalib is currently used to disable linking with libdevice bitcode library.

lib/Driver/Tools.cpp

236

Perhaps you want to use isa<CudaDeviceAction>() here.

[tra]

You also need a test case for the changes.

[tra]

lib/Driver/Tools.cpp

277–279

Style nit -- no need for curly braces.

[jlebar]

Address tra's review comments.

[jlebar]

I'm sorry I sat on this for so long; I failed at email somehow, and only came back to ping this patch. :)

lib/Driver/ToolChains.cpp

4125

Hm...I don't want to over-complicated the UI. Is there prior art for what we're doing here that we could crib off?

[tra]

lib/Driver/ToolChains.cpp

4125

I'd rename -nocudalib to -nocudalibdevice (or -nocudabclib) to better reflect what it currently does -- disables linking with CUDA's libdevice bitcode.

Then you could use -nocudalib to control automatic addition of CUDA library-related options which would be closer to what '-nostdlib' does.

While you're at it, you may consider adding linker flags to link with static libcudart. nvcc always adds "-lcudart_static -lrt -lpthread -ldl" at the end. If user explicitly requests linking with dynamic version of libcudart, then it gets linked first, and linker then ignores all the symbols from static lib.

[jlebar]

lib/Driver/ToolChains.cpp

4125

Sounds like a plan. I'll send separate patches for each of these.

[jlebar]

Now also pass -lcudart_static -lcuda -ldl -lrt -pthread for CUDA compiles.

Depends on D15933.

[jlebar]

Done, please have another look.

[tra]

include/clang/Driver/Options.td

1636

include -> link with

Perhaps less implementation details would be more appropriate for a help string.
"Don't link with default CUDA runtime library"?

lib/Driver/ToolChains.cpp

4129–4137

Does this kick in before user's arguments have been added or after?
If user args have not been added yet, then you'll never find them and don't need this check at all.

Skipping -lFOO will also have problems if any of the libraries are static and one of preceding libraries needs extra symbols that were not linked in by this point yet.

Link with required libraries unconditionally. Make sure to add these libraries after user arguments have been added.

4139

-lcuda is not needed. As far as I can tell, cudart_static will open and use it via dlopen.

It would be needed only if user uses any of API calls from libcuda directly, but then it would be up to user to add -lcuda.

4142

-lpthread

[jlebar]

Address tra's review comments.

[jlebar]

Updated code; please have a look.

include/clang/Driver/Options.td

1636

include -> link with

Done.

Perhaps less implementation details would be more appropriate for a help string.

I'm not sure about that? Maybe if we were just including -lcudart_static, but given that we're pulling in other libraries and adding a library search path, I feel like we should tell users what we're doing? I mean, we should document it somewhere, and here's where people are actually going to find it...

lib/Driver/ToolChains.cpp

4129–4137

Does this kick in before user's arguments have been added or after?

After; I wrote tests. :)

Link with required libraries unconditionally.

Done.

4142

Oh, I see, -pthread is a compile-time flag, not a link-time flag. Thanks.

[jlebar]

Adding back testcase that ensures that our flags are added after user flags.

[jlebar]

lib/Driver/ToolChains.cpp

4129–4137

Although then I deleted the relevant tests... I just added new ones. :)

[tra]

Minor nit, but looks good otherwise.

include/clang/Driver/Options.td

1636

Implementation details may be different on different platforms. I.e. you may need to link with different set of libraries if/when we add missing bits for windows and your help string will make no sense there.

Specifics should be in the documentation, IMO.

lib/Driver/ToolChains.cpp

4130

{}, again.
:-)

[jlebar]

Address tra's review comments.

include/clang/Driver/Options.td

1636

OK, that's a good reason not to do it in the command-line help.

[jlebar]

Split out the bits adding an arg to AddLinkerInputs into a separate patch, D15939.

[tra]

lib/Driver/Tools.cpp

276

It just struck me that this patch may not be as useful as we'd like it to be.

For typical compilation source-to-object and object-to-executable are separate phases.
We need these flags during linking phase, but we will rarely see any CUDA inputs passed to clang. Most of the time we'll be dealing with .o files and will have no way to tell whether those were compiled from CUDA sources. :-(

[jlebar]

It just struck me that this patch may not be as useful as we'd like it to be.

Oh. Yes.

I guess I'll drop this and D15939. :(

include/clang/Driver/Options.td

def no_canonical_prefixes : Flag<["-"], "no-canonical-prefixes">, Flags<[HelpHidden]>,
   HelpText<"Use relative instead of canonical paths">;
 def no_cpp_precomp : Flag<["-"], "no-cpp-precomp">, Group<clang_ignored_f_Group>;
 def no_integrated_cpp : Flag<["-", "--"], "no-integrated-cpp">, Flags<[DriverOption]>;
 def no_pedantic : Flag<["-", "--"], "no-pedantic">, Group<pedantic_Group>;
 def no__dead__strip__inits__and__terms : Flag<["-"], "no_dead_strip_inits_and_terms">;
 def nobuiltininc : Flag<["-"], "nobuiltininc">, Flags<[CC1Option]>,
   HelpText<"Disable builtin #include directories">;
 def nocudainc : Flag<["-"], "nocudainc">;
+def nocudalib : Flag<["-"], "nocudalib">,
+  HelpText<"Don't link with libraries necessary for running CUDA">;
 def nocudalibdevice : Flag<["-"], "nocudalibdevice">,
   HelpText<"Don't link in the CUDA libdevice bitcode (libdevice.compute_xx.yy.bc)">;
 def nodefaultlibs : Flag<["-"], "nodefaultlibs">;
 def nofixprebinding : Flag<["-"], "nofixprebinding">;
 def nolibc : Flag<["-"], "nolibc">;
 def nomultidefs : Flag<["-"], "nomultidefs">;
 def nopie : Flag<["-"], "nopie">;
 def noprebind : Flag<["-"], "noprebind">;

include/clang/Driver/ToolChain.h

public:
   /// a suitable profile runtime library to the linker.
   virtual void addProfileRTLibs(const llvm::opt::ArgList &Args,
                                 llvm::opt::ArgStringList &CmdArgs) const;
 
   /// \brief Add arguments to use system-specific CUDA includes.
   virtual void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                                   llvm::opt::ArgStringList &CC1Args) const;
 
+  /// \brief Add LD arguments pointing to CUDA libraries.
+  virtual void AddCudaLinkerArgs(const llvm::opt::ArgList &DriverArgs,
+                                 llvm::opt::ArgStringList &LDArgs) const;
+
   /// \brief Return sanitizers which are available in this toolchain.
   virtual SanitizerMask getSupportedSanitizers() const;
 };
 
 } // end namespace driver
 } // end namespace clang
 
 #endif

lib/Driver/ToolChain.cpp

SanitizerMask Res = (Undefined & ~Vptr & ~Function) | (CFI & ~CFIICall) |
                       CFICastStrict | UnsignedIntegerOverflow | LocalBounds;
   if (getTriple().getArch() == llvm::Triple::x86 ||
       getTriple().getArch() == llvm::Triple::x86_64)
     Res |= CFIICall;
   return Res;
 }
 
 void ToolChain::AddCudaIncludeArgs(const ArgList &DriverArgs,
-                                   ArgStringList &CC1Args) const {}
+                                   ArgStringList &CC1Args) const {
+  // Only supported on Linux at the moment.
+}
+
+void ToolChain::AddCudaLinkerArgs(const ArgList &DriverArgs,
+                                  ArgStringList &LDArgs) const {
+  // Only supported on Linux at the moment.
+}

lib/Driver/ToolChains.h

public:
   void
   AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                             llvm::opt::ArgStringList &CC1Args) const override;
   void AddClangCXXStdlibIncludeArgs(
       const llvm::opt::ArgList &DriverArgs,
       llvm::opt::ArgStringList &CC1Args) const override;
   void AddCudaIncludeArgs(const llvm::opt::ArgList &DriverArgs,
                           llvm::opt::ArgStringList &CC1Args) const override;
+  void AddCudaLinkerArgs(const llvm::opt::ArgList &DriverArgs,
+                         llvm::opt::ArgStringList &CC1Args) const override;
   bool isPIEDefault() const override;
   SanitizerMask getSupportedSanitizers() const override;
   void addProfileRTLibs(const llvm::opt::ArgList &Args,
                         llvm::opt::ArgStringList &CmdArgs) const override;
   virtual std::string computeSysRoot() const;
 
   std::vector<std::string> ExtraOpts;
 

lib/Driver/ToolChains.cpp

void Linux::AddCudaIncludeArgs(const ArgList &DriverArgs,
 
   if (CudaInstallation.isValid()) {
     addSystemInclude(DriverArgs, CC1Args, CudaInstallation.getIncludePath());
     CC1Args.push_back("-include");
     CC1Args.push_back("__clang_cuda_runtime_wrapper.h");
   }
 }
 
+void Linux::AddCudaLinkerArgs(const ArgList &DriverArgs,
+                              ArgStringList &LDArgs) const {
+  if (DriverArgs.hasArg(options::OPT_nocudalib) || !CudaInstallation.isValid())
+    return;
+
+  LDArgs.push_back("-L");
+  LDArgs.push_back(DriverArgs.MakeArgString(CudaInstallation.getLibPath()));
+  for (const char *Flag : {"-lcudart_static", "-ldl", "-lrt", "-lpthread"})
+    LDArgs.push_back(DriverArgs.MakeArgString(Flag));
+}
+
 bool Linux::isPIEDefault() const { return getSanitizerArgs().requiresPIE(); }
 
 SanitizerMask Linux::getSupportedSanitizers() const {
   const bool IsX86 = getTriple().getArch() == llvm::Triple::x86;
   const bool IsX86_64 = getTriple().getArch() == llvm::Triple::x86_64;
   const bool IsMIPS64 = getTriple().getArch() == llvm::Triple::mips64 ||
                         getTriple().getArch() == llvm::Triple::mips64el;
   const bool IsPowerPC64 = getTriple().getArch() == llvm::Triple::ppc64 ||
                            getTriple().getArch() == llvm::Triple::ppc64le;
   const bool IsAArch64 = getTriple().getArch() == llvm::Triple::aarch64 ||
                          getTriple().getArch() == llvm::Triple::aarch64_be;
   SanitizerMask Res = ToolChain::getSupportedSanitizers();
   Res |= SanitizerKind::Address;
   Res |= SanitizerKind::KernelAddress;
   Res |= SanitizerKind::Vptr;
   Res |= SanitizerKind::SafeStack;
   if (IsX86_64 || IsMIPS64 || IsAArch64)

lib/Driver/Tools.cpp

if (CombinedArg) {
       CmdArgs.push_back(Args.MakeArgString(std::string(ArgName) + Dirs));
     } else {
       CmdArgs.push_back(ArgName);
       CmdArgs.push_back(Args.MakeArgString(Dirs));
     }
   }
 }
 
+// Is the given action, or any of its inputs, a CUDA action?
+static bool isCudaAction(const Action* A) {
+  return isa<CudaDeviceAction>(A) || isa<CudaHostAction>(A) ||
+         std::any_of(A->getInputs().begin(), A->getInputs().end(),
+                     isCudaAction);
+}
+
 static void AddLinkerInputs(const Compilation &C, const ToolChain &TC,
                             const InputInfoList &Inputs, const ArgList &Args,
                             ArgStringList &CmdArgs) {
   const Driver &D = TC.getDriver();
 
   // Add extra linker input arguments which are not treated as inputs
   // (constructed via -Xarch_).
   Args.AddAllArgValues(CmdArgs, options::OPT_Zlinker_input);
 
   for (const auto &II : Inputs) {
     if (!TC.HasNativeLLVMSupport() && types::isLLVMIR(II.getType()))
else if (A.getOption().matches(options::OPT_z)) {
       A.renderAsInput(Args, CmdArgs);
     }
   }
 
   // LIBRARY_PATH - included following the user specified library paths.
   //                and only supported on native toolchains.
   if (!TC.isCrossCompiling())
     addDirectoryList(Args, CmdArgs, "-L", "LIBRARY_PATH");
+
+  // Add -L/path/to/cuda/lib if any of our inputs are .cu files.
+  if (std::any_of(C.getActions().begin(), C.getActions().end(), isCudaAction))
+    TC.AddCudaLinkerArgs(Args, CmdArgs);
 }
 
 /// \brief Determine whether Objective-C automated reference counting is
 /// enabled.
 static bool isObjCAutoRefCount(const ArgList &Args) {
   return Args.hasFlag(options::OPT_fobjc_arc, options::OPT_fno_objc_arc, false);
 }
 
 /// \brief Determine whether we are linking the ObjC runtime.

test/Driver/cuda-default-libs.cu

+// Checks that we add -L /path/to/cuda/lib{,64} and -lcudart_static -ldl -lrt
+// -lpthread as appropriate when compiling CUDA code.
+
+// REQUIRES: clang-driver
+// REQUIRES: x86-registered-target
+// REQUIRES: nvptx-registered-target
+
+// RUN: %clang -### -v --target=i386-unknown-linux \
+// RUN:   -lfoo --sysroot=%S/Inputs/CUDA %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix CUDA -check-prefix CUDA-x86_32
+//
+// RUN: %clang -### -v --target=x86_64-unknown-linux \
+// RUN:   -lfoo --sysroot=%S/Inputs/CUDA %s 2>&1 \
+// RUN:   | FileCheck %s -check-prefix CUDA -check-prefix CUDA-x86_64
+//
+// # Our new flags should come after user-specified flags.
+// CUDA: -lfoo
+// CUDA-x86_32: "-L" "{{.*}}/Inputs/CUDA/usr/local/cuda/lib"
+// CUDA-x86_64: "-L" "{{.*}}/Inputs/CUDA/usr/local/cuda/lib64"
+// CUDA-x86_32-NOT: "-L" "{{.*}}/Inputs/CUDA/usr/local/cuda/lib64"
+// CUDA-x86_64-NOT: "-L" "{{.*}}/Inputs/CUDA/usr/local/cuda/lib"
+// CUDA-DAG: "-lcudart_static"
+// CUDA-DAG: "-ldl"
+// CUDA-DAG: "-lrt"
+// CUDA-DAG: "-lpthread"
+
+// If we can't find CUDA, don't include it in our library search path, and
+// don't include any additional libraries via -l.
+// RUN: %clang -### -v --target=i386-unknown-linux \
+// RUN:   --sysroot=%S/Inputs/no-cuda-there %s 2>&1 | FileCheck %s -check-prefix NOCUDA
+//
+// Also don't add anything if we pass -nocudalib.
+// RUN: %clang -### -v --target=x86_64-unknown-linux -nocudalib \
+// RUN:   --sysroot=%S/Inputs/CUDA %s 2>&1 | FileCheck %s -check-prefix NOCUDA
+//
+// NOCUDA-NOT: "-L" "{{.*}}/no-cuda-there/{{.*}}"
+// NOCUDA-NOT: "-lcudart_static"
+// NOCUDA-NOT: "-ldl"
+// NOCUDA-NOT: "-lrt"
+// NOCUDA-NOT: "-lpthread"
+// NOCUDA-NOT: "-L" "{{.*}}/Inputs/CUDA/usr/local/cuda/lib"
+// NOCUDA-NOT: "-L" "{{.*}}/Inputs/CUDA/usr/local/cuda/lib64"