[CUDA] Copy host builtin types to NVPTXTargetInfo.

[jlebar]

Summary

Host and device types must match, otherwise when we pass values back and
forth between the host and device, we will get the wrong result.

This patch makes NVPTXTargetInfo inherit most of its type information
from the host's target info.

[jlebar]

Richard, friendly ping?

[tra]

lib/Basic/Targets.cpp

1642

You may want to make sure we don't recurse here if someone specifies host triple to be one of NVPTX variants.

[rsmith]

lib/Basic/Targets.cpp

1648–1684

I think we need to do more to make sure this list of fields is kept up to date as more of these values are added or changed.

Possible idea: could we have a test that builds with -E -dM in both host and device mode, greps for the __*_TYPE__, __*_MAX__ (etc) predefines, and compares them across the two runs?

[jlebar]

Add more comprehensive test.

[jlebar]

Add test for host == nvptx.

[jlebar]

<strike>Richard, friendly ping?</strike>

(Sorry, not sure why phabricator decided to repeat my last comment.)

lib/Basic/Targets.cpp

1642

Done and added a test, thank you for noticing this.

1648–1684

OK, done. I did TYPE, MAX, SIZEOF, and WIDTH, and I'm checking i386, x86_64, and ppc.

[rsmith]

test/Preprocessor/cuda-types.cu

7–9 ↗

(On Diff #55648)

I expect you'll also need a REQUIRES: shell for this stuff.

include/clang/Basic/TargetOptions.h

 
 /// \brief Options for controlling the target.
 class TargetOptions {
 public:
   /// If given, the name of the target triple to compile for. If not given the
   /// target will be selected to match the host.
   std::string Triple;
 
+  /// When compiling for the device side, contains the triple used to compile
+  /// for the host.
+  std::string HostTriple;
+
   /// If given, the name of the target CPU to generate code for.
   std::string CPU;
 
   /// If given, the unit to use for floating point math.
   std::string FPMath;
 
   /// If given, the name of the target ABI to use.
   std::string ABI;

lib/Basic/Targets.cpp

 static void defineCPUMacros(MacroBuilder &Builder, StringRef CPUName,
                             bool Tuning = true) {
   Builder.defineMacro("__" + CPUName);
   Builder.defineMacro("__" + CPUName + "__");
   if (Tuning)
     Builder.defineMacro("__tune_" + CPUName + "__");
 }
 
+static TargetInfo *AllocateTarget(const llvm::Triple &Triple,
+                                  const TargetOptions &Opts);
+
 //===----------------------------------------------------------------------===//
 // Defines specific to certain operating systems.
 //===----------------------------------------------------------------------===//
 
 namespace {
 template<typename TgtInfo>
 class OSTargetInfo : public TgtInfo {
 protected:
enum GPUKind {
     GK_SM20,
     GK_SM21,
     GK_SM30,
     GK_SM35,
     GK_SM37,
   } GPU;
 
 public:
-  NVPTXTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
+  NVPTXTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : TargetInfo(Triple) {
     BigEndian = false;
     TLSSupported = false;
     LongWidth = LongAlign = 64;
     AddrSpaceMap = &NVPTXAddrSpaceMap;
     UseAddrSpaceMapMangling = true;
     // Define available target features
     // These must be defined in sorted order!
     NoAsmVariants = true;
     // Set the default GPU to sm20
     GPU = GK_SM20;
+
+    std::unique_ptr<TargetInfo> HostTarget(
+        AllocateTarget(llvm::Triple(Opts.HostTriple), Opts));
+    if (!HostTarget) {
+      return;
+    }
+
+    // Match the host's types.
+    PointerWidth = HostTarget->getPointerWidth(/* AddrSpace = */ 0);
+    PointerAlign = HostTarget->getPointerAlign(/* AddrSpace = */ 0);
+    BoolWidth = HostTarget->getBoolWidth();
+    BoolAlign = HostTarget->getBoolAlign();
+    IntWidth = HostTarget->getIntWidth();
+    IntWidth = HostTarget->getIntWidth();
+    HalfWidth = HostTarget->getHalfWidth();
+    HalfWidth = HostTarget->getHalfWidth();
+    FloatWidth = HostTarget->getFloatWidth();
+    FloatWidth = HostTarget->getFloatWidth();
+    DoubleWidth = HostTarget->getDoubleWidth();
+    DoubleWidth = HostTarget->getDoubleWidth();
+    LongWidth = HostTarget->getLongWidth();
+    LongAlign = HostTarget->getLongAlign();
+    LongLongWidth = HostTarget->getLongLongWidth();
+    LongLongAlign = HostTarget->getLongLongAlign();
+    MinGlobalAlign = HostTarget->getMinGlobalAlign();
+    DefaultAlignForAttributeAligned =
+        HostTarget->getDefaultAlignForAttributeAligned();
+    SizeType = HostTarget->getSizeType();
+    IntMaxType = HostTarget->getIntMaxType();
+    PtrDiffType = HostTarget->getPtrDiffType(/* AddrSpace = */ 0);
+    IntPtrType = HostTarget->getIntPtrType();
+    WCharType = HostTarget->getWCharType();
+    WIntType = HostTarget->getWIntType();
+    Char16Type = HostTarget->getChar16Type();
+    Char32Type = HostTarget->getChar32Type();
+    Int64Type = HostTarget->getInt64Type();
+    SigAtomicType = HostTarget->getSigAtomicType();
+    ProcessIDType = HostTarget->getProcessIDType();
+
+    UseBitFieldTypeAlignment = HostTarget->useBitFieldTypeAlignment();
+    UseZeroLengthBitfieldAlignment =
+        HostTarget->useZeroLengthBitfieldAlignment();
+    UseExplicitBitFieldAlignment = HostTarget->useExplicitBitFieldAlignment();
+    ZeroLengthBitfieldBoundary = HostTarget->getZeroLengthBitfieldBoundary();
+
+    // Properties intentionally not copied from host:
+    // - LargeArrayMinWidth, LargeArrayAlign: Not visible across the
+    //   host/device boundary.
+    // - SuitableAlign: Not visible across the host/device boundary, and may
+    //   correctly be different on host/device, e.g. if host has wider vector
+    //   types than device.
+    // - LongDoubleWidth, LongDoubleAlign: nvptx's long double type is the same
+    //   as its double type, but that's not necessarily true on the host.
+    //   TODO: nvcc emits a warning when using long double on device; we should
+    //   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;

lib/Frontend/CompilerInstance.cpp

bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
   // Create the target instance.
   setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(),
                                          getInvocation().TargetOpts));
   if (!hasTarget())
     return false;
 
   // Create TargetInfo for the other side of CUDA compilation.
   if (getLangOpts().CUDA && !getFrontendOpts().AuxTriple.empty()) {
-    std::shared_ptr<TargetOptions> TO(new TargetOptions);
+    auto TO = std::make_shared<TargetOptions>();
     TO->Triple = getFrontendOpts().AuxTriple;
+    TO->HostTriple = getTarget().getTriple().str();
     setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO));
   }
 
   // Inform the target of the language options.
   //
   // FIXME: We shouldn't need to do this, the target should be immutable once
   // created. This complexity should be lifted elsewhere.
   getTarget().adjust(getLangOpts());

lib/Frontend/CompilerInvocation.cpp

parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
                         Diags, LangOpts.Sanitize);
   } else {
     // Other LangOpts are only initialzed when the input is not AST or LLVM IR.
     ParseLangArgs(LangOpts, Args, DashX, Res.getTargetOpts(), Diags);
     if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
       LangOpts.ObjCExceptions = 1;
   }
 
+  // During CUDA device-side compilation, the aux triple is the triple used for
+  // host compilation.
+  if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
+    Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple;
+  }
+
   // FIXME: Override value name discarding when asan or msan is used because the
   // backend passes depend on the name of the alloca in order to print out
   // names.
   Res.getCodeGenOpts().DiscardValueNames &=
       !LangOpts.Sanitize.has(SanitizerKind::Address) &&
       !LangOpts.Sanitize.has(SanitizerKind::Memory);
 
   // FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of

test/SemaCUDA/wint_t.cu

+// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-linux-gnu \
+// RUN:   -aux-triple nvptx-nvidia-cuda -verify %s
+// RUN: %clang_cc1 -std=c++11 -fcuda-is-device -triple nvptx-nvidia-cuda \
+// RUN:   -aux-triple x86_64-unknown-linux-gnu -verify %s
+
+// expected-no-diagnostics
+
+// Check that __WINT_TYPE__ is unsigned int on both x86-64 and nvptx.
+
+template<typename T, typename U>
+struct IsSame {
+  static constexpr bool value = false;
+};
+
+template<typename T>
+struct IsSame<T, T> {
+  static constexpr bool value = true;
+};
+
+__attribute__((host)) __attribute__((device)) void foo() {
+  static_assert(IsSame<__WINT_TYPE__, unsigned int>::value,
+                "Wrong __WINT_TYPE__.");
+}