[CUDA] Add support for CUDA 8 and sm_60-62.

[jlebar]

Summary

Also add sm_32, which was missing.

[tra]

The changes look good.
They will need to wait for corresponding patch on LLVM side to deal with new SM variants, though.

lib/Driver/ToolChains.cpp

1715

This is a bit premature as we can't compile CUDA-8 headers yet. Let's drop it until we're ready.

[jlebar]

Don't pull in the cuda 8 headers by default.

[jlebar]

They will need to wait for corresponding patch on LLVM side to deal with new SM variants, though.

This is in now, D22068.

lib/Driver/ToolChains.cpp

1715

sgtm, removed.

lib/Basic/Targets.cpp

class NVPTXTargetInfo : public TargetInfo {
   static const Builtin::Info BuiltinInfo[];
 
   // The GPU profiles supported by the NVPTX backend
   enum GPUKind {
     GK_NONE,
     GK_SM20,
     GK_SM21,
     GK_SM30,
+    GK_SM32,
     GK_SM35,
     GK_SM37,
     GK_SM50,
     GK_SM52,
     GK_SM53,
+    GK_SM60,
+    GK_SM61,
+    GK_SM62,
   } GPU;
 
 public:
   NVPTXTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : TargetInfo(Triple) {
     BigEndian = false;
     TLSSupported = false;
     LongWidth = LongAlign = 64;
NVPTXTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
     //   do the same.
   }
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     Builder.defineMacro("__PTX__");
     Builder.defineMacro("__NVPTX__");
     if (Opts.CUDAIsDevice) {
       // Set __CUDA_ARCH__ for the GPU specified.
-      std::string CUDAArchCode;
+      std::string CUDAArchCode = [this] {
         switch (GPU) {
+        case GK_NONE:
+          assert(false && "No GPU arch when compiling CUDA device code.");
+          return "";
         case GK_SM20:
-        CUDAArchCode = "200";
-        break;
+          return "200";
         case GK_SM21:
-        CUDAArchCode = "210";
-        break;
+          return "210";
         case GK_SM30:
-        CUDAArchCode = "300";
-        break;
+          return "300";
+        case GK_SM32:
+          return "320";
         case GK_SM35:
-        CUDAArchCode = "350";
-        break;
+          return "350";
         case GK_SM37:
-        CUDAArchCode = "370";
-        break;
+          return "370";
         case GK_SM50:
-        CUDAArchCode = "500";
-        break;
+          return "500";
         case GK_SM52:
-        CUDAArchCode = "520";
-        break;
+          return "520";
         case GK_SM53:
-        CUDAArchCode = "530";
-        break;
-      default:
-        llvm_unreachable("Unhandled target CPU");
+          return "530";
+        case GK_SM60:
+          return "600";
+        case GK_SM61:
+          return "610";
+        case GK_SM62:
+          return "620";
         }
+      }();
       Builder.defineMacro("__CUDA_ARCH__", CUDAArchCode);
     }
   }
   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
     return llvm::makeArrayRef(BuiltinInfo,
                          clang::NVPTX::LastTSBuiltin - Builtin::FirstTSBuiltin);
   }
   bool hasFeature(StringRef Feature) const override {
BuiltinVaListKind getBuiltinVaListKind() const override {
     // FIXME: implement
     return TargetInfo::CharPtrBuiltinVaList;
   }
   bool setCPU(const std::string &Name) override {
     GPU = llvm::StringSwitch<GPUKind>(Name)
               .Case("sm_20", GK_SM20)
               .Case("sm_21", GK_SM21)
               .Case("sm_30", GK_SM30)
+              .Case("sm_32", GK_SM32)
               .Case("sm_35", GK_SM35)
               .Case("sm_37", GK_SM37)
               .Case("sm_50", GK_SM50)
               .Case("sm_52", GK_SM52)
               .Case("sm_53", GK_SM53)
+              .Case("sm_60", GK_SM60)
+              .Case("sm_61", GK_SM61)
+              .Case("sm_62", GK_SM62)
               .Default(GK_NONE);
 
     return GPU != GK_NONE;
   }
 };
 
 const Builtin::Info NVPTXTargetInfo::BuiltinInfo[] = {
 #define BUILTIN(ID, TYPE, ATTRS)                                               \

lib/Driver/Action.cpp

return llvm::StringSwitch<const char *>(ArchName)
       .Cases("sm_20", "sm_21", "compute_20")
       .Case("sm_30", "compute_30")
       .Case("sm_32", "compute_32")
       .Case("sm_35", "compute_35")
       .Case("sm_37", "compute_37")
       .Case("sm_50", "compute_50")
       .Case("sm_52", "compute_52")
       .Case("sm_53", "compute_53")
+      .Case("sm_60", "compute_60")
+      .Case("sm_61", "compute_61")
+      .Case("sm_62", "compute_62")
       .Default(nullptr);
 }
 
 void CudaDeviceAction::anchor() {}
 
 CudaDeviceAction::CudaDeviceAction(Action *Input, const char *ArchName,
                                    bool AtTopLevel)
     : Action(CudaDeviceClass, Input), GpuArchName(ArchName),

lib/Driver/ToolChains.cpp

void Generic_GCC::CudaInstallationDetector::init(
     const llvm::Triple &TargetTriple, const llvm::opt::ArgList &Args) {
   SmallVector<std::string, 4> CudaPathCandidates;
 
   if (Args.hasArg(options::OPT_cuda_path_EQ))
     CudaPathCandidates.push_back(
         Args.getLastArgValue(options::OPT_cuda_path_EQ));
   else {
     CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda");
+    CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-8.0");
     CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-7.5");
     CudaPathCandidates.push_back(D.SysRoot + "/usr/local/cuda-7.0");
   }
 
   for (const auto &CudaPath : CudaPathCandidates) {
     if (CudaPath.empty() || !D.getVFS().exists(CudaPath))
       continue;
 
for (llvm::sys::fs::directory_iterator LI(CudaLibDevicePath, EC), LE;
         CudaLibDeviceMap["sm_32"] = FilePath;
       } else if (GpuArch == "compute_35") {
         CudaLibDeviceMap["sm_35"] = FilePath;
         CudaLibDeviceMap["sm_37"] = FilePath;
       } else if (GpuArch == "compute_50") {
         CudaLibDeviceMap["sm_50"] = FilePath;
         CudaLibDeviceMap["sm_52"] = FilePath;
         CudaLibDeviceMap["sm_53"] = FilePath;
+        CudaLibDeviceMap["sm_60"] = FilePath;
+        CudaLibDeviceMap["sm_61"] = FilePath;
+        CudaLibDeviceMap["sm_62"] = FilePath;
       }
     }
 
     IsValid = true;
     break;
   }
 }