[Builtins][FIX] Allow targets to opt-out of `long double` builtins

[jdoerfert]

Summary

If a target doesn't support long double, e.g., a GPU, it should not
expose the builtins that deal with them in the first place. This patch
also adjusts __has_builtin to return false in those cases.

This is a first step to fix PR48923, second is to adjust libcxx and
add the __has_builtin guards.

[erichkeane]

Can you show any tests where this builtin would be a part of the aux-triple, and not in active code? So an nvptx triple, x86_64 aux-triple, and in non-device code? (such as in a CUDA app)?

[yaxunl]

I tried this patch with our CI and it breaks HIP and OpenMP. I suspect it may also break CUDA. It seems in device compilation, when a host function calls a builtin with long double argument, the builtin is not found. My guess is that the target for checking builtin needs to be caller dependent. E.g. in device compilation, when checking builtin called by a host function, aux-target and aux-cpu should be used. Then this raises another question: what to use for host device function? It seems for this to work, the dianostic about missing builtin needs to be also deferred diagnostics.

[erichkeane]

For target-specific builtins I ended up implementing this: https://github.com/llvm/llvm-project/commit/81a73fde5cea304d31294fd26c2f051f1685e97c at one point to make sure that 'host' builtins get looked up in the aux-target if necessary.

[jdoerfert]

I guess this doesn't work then.

clang/include/clang/Basic/Builtins.h

public:
 
   /// Perform target-specific initialization
   /// \param AuxTarget Target info to incorporate builtins from. May be nullptr.
   void InitializeTarget(const TargetInfo &Target, const TargetInfo *AuxTarget);
 
   /// Mark the identifiers for all the builtins with their
   /// appropriate builtin ID # and mark any non-portable builtin identifiers as
   /// such.
-  void initializeBuiltins(IdentifierTable &Table, const LangOptions& LangOpts);
+  void initializeBuiltins(IdentifierTable &Table, const LangOptions &LangOpts,
+                          const TargetInfo &Target);
 
   /// Return the identifier name for the specified builtin,
   /// e.g. "__builtin_abs".
   const char *getName(unsigned ID) const {
     return getRecord(ID).Name;
   }
 
   /// Get the type descriptor string for the specified builtin.
public:
 
   /// Return true if this builtin has a result or any arguments which are
   /// reference types.
   bool hasReferenceArgsOrResult(unsigned ID) const {
     return strchr(getRecord(ID).Type, '&') != nullptr ||
            strchr(getRecord(ID).Type, 'A') != nullptr;
   }
 
+  /// Return true if this builtin has a result or any arguments which are
+  /// long double types (or long long double, or __float128).
+  bool hasLongDouble(unsigned ID) const {
+    return strstr(getRecord(ID).Type, "Ld") != nullptr;
+  }
+
   /// Completely forget that the given ID was ever considered a builtin,
   /// e.g., because the user provided a conflicting signature.
   void forgetBuiltin(unsigned ID, IdentifierTable &Table);
 
   /// If this is a library function that comes from a specific
   /// header, retrieve that header name.
   const char *getHeaderName(unsigned ID) const {
     return getRecord(ID).HeaderName;
public:
   /// for non-builtins.
   bool canBeRedeclared(unsigned ID) const;
 
 private:
   const Info &getRecord(unsigned ID) const;
 
   /// Is this builtin supported according to the given language options?
   bool builtinIsSupported(const Builtin::Info &BuiltinInfo,
-                          const LangOptions &LangOpts);
+                          const LangOptions &LangOpts,
+                          const TargetInfo &Target);
 
   /// Helper function for isPrintfLike and isScanfLike.
   bool isLike(unsigned ID, unsigned &FormatIdx, bool &HasVAListArg,
               const char *Fmt) const;
 };
 
 }
 

clang/include/clang/Basic/TargetInfo.h

protected:
   bool VLASupported;
   bool NoAsmVariants;  // True if {|} are normal characters.
   bool HasLegalHalfType; // True if the backend supports operations on the half
                          // LLVM IR type.
   bool HasFloat128;
   bool HasFloat16;
   bool HasBFloat16;
   bool HasStrictFP;
+  bool HasLongDouble;
 
   unsigned char MaxAtomicPromoteWidth, MaxAtomicInlineWidth;
   unsigned short SimdDefaultAlign;
   std::unique_ptr<llvm::DataLayout> DataLayout;
   const char *MCountName;
   unsigned char RegParmMax, SSERegParmMax;
   TargetCXXABI TheCXXABI;
   const LangASMap *AddrSpaceMap;
public:
   /// limitation is put into place for ABI reasons.
   virtual bool hasExtIntType() const {
     return false;
   }
 
   /// Determine whether _Float16 is supported on this target.
   virtual bool hasLegalHalfType() const { return HasLegalHalfType; }
 
+  /// Determine whether `long double` type is supported on this target.
+  virtual bool hasLongDouble() const { return HasLongDouble; }
+
   /// Determine whether the __float128 type is supported on this target.
   virtual bool hasFloat128Type() const { return HasFloat128; }
 
   /// Determine whether the _Float16 type is supported on this target.
   virtual bool hasFloat16Type() const { return HasFloat16; }
 
   /// Determine whether the _BFloat16 type is supported on this target.
   virtual bool hasBFloat16Type() const { return HasBFloat16; }

clang/lib/Basic/Builtins.cpp

bool Builtin::Context::isBuiltinFunc(llvm::StringRef FuncName) {
   for (unsigned i = Builtin::NotBuiltin + 1; i != Builtin::FirstTSBuiltin; ++i)
     if (FuncName.equals(BuiltinInfo[i].Name))
       return strchr(BuiltinInfo[i].Attributes, 'f') != nullptr;
 
   return false;
 }
 
 bool Builtin::Context::builtinIsSupported(const Builtin::Info &BuiltinInfo,
-                                          const LangOptions &LangOpts) {
+                                          const LangOptions &LangOpts,
+                                          const TargetInfo &Target) {
   bool BuiltinsUnsupported =
       (LangOpts.NoBuiltin || LangOpts.isNoBuiltinFunc(BuiltinInfo.Name)) &&
       strchr(BuiltinInfo.Attributes, 'f');
   bool MathBuiltinsUnsupported =
     LangOpts.NoMathBuiltin && BuiltinInfo.HeaderName &&
     llvm::StringRef(BuiltinInfo.HeaderName).equals("math.h");
   bool GnuModeUnsupported = !LangOpts.GNUMode && (BuiltinInfo.Langs & GNU_LANG);
   bool MSModeUnsupported =
       !LangOpts.MicrosoftExt && (BuiltinInfo.Langs & MS_LANG);
   bool ObjCUnsupported = !LangOpts.ObjC && BuiltinInfo.Langs == OBJC_LANG;
   bool OclC1Unsupported = (LangOpts.OpenCLVersion / 100) != 1 &&
                           (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES ) ==  OCLC1X_LANG;
   bool OclC2Unsupported =
       (LangOpts.OpenCLVersion != 200 && !LangOpts.OpenCLCPlusPlus) &&
       (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES) == OCLC20_LANG;
   bool OclCUnsupported = !LangOpts.OpenCL &&
                          (BuiltinInfo.Langs & ALL_OCLC_LANGUAGES);
   bool OpenMPUnsupported = !LangOpts.OpenMP && BuiltinInfo.Langs == OMP_LANG;
   bool CPlusPlusUnsupported =
       !LangOpts.CPlusPlus && BuiltinInfo.Langs == CXX_LANG;
+  bool LongDoubleUnsupported =
+      !Target.hasLongDouble() && strstr(BuiltinInfo.Type, "Ld") != nullptr;
   return !BuiltinsUnsupported && !MathBuiltinsUnsupported && !OclCUnsupported &&
          !OclC1Unsupported && !OclC2Unsupported && !OpenMPUnsupported &&
          !GnuModeUnsupported && !MSModeUnsupported && !ObjCUnsupported &&
-         !CPlusPlusUnsupported;
+         !CPlusPlusUnsupported && !LongDoubleUnsupported;
 }
 
 /// initializeBuiltins - Mark the identifiers for all the builtins with their
 /// appropriate builtin ID # and mark any non-portable builtin identifiers as
 /// such.
 void Builtin::Context::initializeBuiltins(IdentifierTable &Table,
-                                          const LangOptions& LangOpts) {
+                                          const LangOptions &LangOpts,
+                                          const TargetInfo &Target) {
   // Step #1: mark all target-independent builtins with their ID's.
   for (unsigned i = Builtin::NotBuiltin+1; i != Builtin::FirstTSBuiltin; ++i)
-    if (builtinIsSupported(BuiltinInfo[i], LangOpts)) {
+    if (builtinIsSupported(BuiltinInfo[i], LangOpts, Target)) {
       Table.get(BuiltinInfo[i].Name).setBuiltinID(i);
     }
 
   // Step #2: Register target-specific builtins.
   for (unsigned i = 0, e = TSRecords.size(); i != e; ++i)
-    if (builtinIsSupported(TSRecords[i], LangOpts))
+    if (builtinIsSupported(TSRecords[i], LangOpts, Target))
       Table.get(TSRecords[i].Name).setBuiltinID(i + Builtin::FirstTSBuiltin);
 
   // Step #3: Register target-specific builtins for AuxTarget.
   for (unsigned i = 0, e = AuxTSRecords.size(); i != e; ++i)
     Table.get(AuxTSRecords[i].Name)
         .setBuiltinID(i + Builtin::FirstTSBuiltin + TSRecords.size());
 }
 

clang/lib/Basic/TargetInfo.cpp

TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
   TLSSupported = true;
   VLASupported = true;
   NoAsmVariants = false;
   HasLegalHalfType = false;
   HasFloat128 = false;
   HasFloat16 = false;
   HasBFloat16 = false;
   HasStrictFP = false;
+  HasLongDouble = true;
   PointerWidth = PointerAlign = 32;
   BoolWidth = BoolAlign = 8;
   IntWidth = IntAlign = 32;
   LongWidth = LongAlign = 32;
   LongLongWidth = LongLongAlign = 64;
 
   // Fixed point default bit widths
   ShortAccumWidth = ShortAccumAlign = 16;

clang/lib/Basic/Targets/AMDGPU.cpp

AMDGPUTargetInfo::AMDGPUTargetInfo(const llvm::Triple &Triple,
   GridValues = llvm::omp::AMDGPUGpuGridValues;
 
   setAddressSpaceMap(Triple.getOS() == llvm::Triple::Mesa3D ||
                      !isAMDGCN(Triple));
   UseAddrSpaceMapMangling = true;
 
   HasLegalHalfType = true;
   HasFloat16 = true;
+  HasLongDouble = false;
   WavefrontSize = GPUFeatures & llvm::AMDGPU::FEATURE_WAVE32 ? 32 : 64;
   AllowAMDGPUUnsafeFPAtomics = Opts.AllowAMDGPUUnsafeFPAtomics;
 
   // Set pointer width and alignment for target address space 0.
   PointerWidth = PointerAlign = DataLayout->getPointerSizeInBits();
   if (getMaxPointerWidth() == 64) {
     LongWidth = LongAlign = 64;
     SizeType = UnsignedLong;

clang/lib/Basic/Targets/NVPTX.cpp

PTXVersion = llvm::StringSwitch<unsigned>(Feature)
                      .Case("+ptx41", 41)
                      .Case("+ptx40", 40)
                      .Case("+ptx32", 32)
                      .Default(32);
   }
 
   TLSSupported = false;
   VLASupported = false;
+  HasLongDouble = false;
   AddrSpaceMap = &NVPTXAddrSpaceMap;
   GridValues = llvm::omp::NVPTXGpuGridValues;
   UseAddrSpaceMapMangling = true;
 
   // Define available target features
   // These must be defined in sorted order!
   NoAsmVariants = true;
   GPU = CudaArch::SM_20;

clang/lib/Frontend/ChainedIncludesSource.cpp

auto consumer = std::make_unique<PCHGenerator>(
         Buffer, Extensions, /*AllowASTWithErrors=*/true);
     Clang->getASTContext().setASTMutationListener(
                                             consumer->GetASTMutationListener());
     Clang->setASTConsumer(std::move(consumer));
     Clang->createSema(TU_Prefix, nullptr);
 
     if (firstInclude) {
       Preprocessor &PP = Clang->getPreprocessor();
-      PP.getBuiltinInfo().initializeBuiltins(PP.getIdentifierTable(),
-                                             PP.getLangOpts());
+      PP.getBuiltinInfo().initializeBuiltins(
+          PP.getIdentifierTable(), PP.getLangOpts(), PP.getTargetInfo());
     } else {
       assert(!SerialBufs.empty());
       SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 4> Bufs;
       // TODO: Pass through the existing MemoryBuffer instances instead of
       // allocating new ones.
       for (auto &SB : SerialBufs)
         Bufs.push_back(llvm::MemoryBuffer::getMemBuffer(SB->getBuffer()));
       std::string pchName = includes[i-1];

clang/lib/Frontend/FrontendAction.cpp

if (Input.getKind().getFormat() == InputKind::Precompiled) {
     HasBegunSourceFile = true;
 
     // Set the shared objects, these are reset when we finish processing the
     // file, otherwise the CompilerInstance will happily destroy them.
     CI.setFileManager(&AST->getFileManager());
     CI.setSourceManager(&AST->getSourceManager());
     CI.setPreprocessor(AST->getPreprocessorPtr());
     Preprocessor &PP = CI.getPreprocessor();
-    PP.getBuiltinInfo().initializeBuiltins(PP.getIdentifierTable(),
-                                           PP.getLangOpts());
+    PP.getBuiltinInfo().initializeBuiltins(
+        PP.getIdentifierTable(), PP.getLangOpts(), PP.getTargetInfo());
     CI.setASTContext(&AST->getASTContext());
 
     setCurrentInput(Input, std::move(AST));
 
     // Initialize the action.
     if (!BeginSourceFileAction(CI))
       goto failure;
 
if (!CI.hasASTConsumer())
       goto failure;
   }
 
   // Initialize built-in info as long as we aren't using an external AST
   // source.
   if (CI.getLangOpts().Modules || !CI.hasASTContext() ||
       !CI.getASTContext().getExternalSource()) {
     Preprocessor &PP = CI.getPreprocessor();
-    PP.getBuiltinInfo().initializeBuiltins(PP.getIdentifierTable(),
-                                           PP.getLangOpts());
+    PP.getBuiltinInfo().initializeBuiltins(
+        PP.getIdentifierTable(), PP.getLangOpts(), PP.getTargetInfo());
   } else {
     // FIXME: If this is a problem, recover from it by creating a multiplex
     // source.
     assert((!CI.getLangOpts().Modules || CI.getASTReader()) &&
            "modules enabled but created an external source that "
            "doesn't support modules");
   }
 

clang/lib/Lex/PPMacroExpansion.cpp

EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
         else if (II->getBuiltinID() != 0) {
           switch (II->getBuiltinID()) {
           case Builtin::BI__builtin_operator_new:
           case Builtin::BI__builtin_operator_delete:
             // denotes date of behavior change to support calling arbitrary
             // usual allocation and deallocation functions. Required by libc++
             return 201802;
           default:
+            // If we are looking at a long double (or similar) builtin and the
+            // target doesn't support long double we do not pretend we could use
+            // the builtin.
+            if (!getTargetInfo().hasLongDouble() &&
+                getBuiltinInfo().hasLongDouble(II->getBuiltinID()))
+              return false;
             return true;
           }
           return true;
         } else if (II->getTokenID() != tok::identifier ||
                    II->hasRevertedTokenIDToIdentifier()) {
           // Treat all keywords that introduce a custom syntax of the form
           //
           //   '__some_keyword' '(' [...] ')'

clang/test/Parser/builtin_long_double.c

+// RUN: %clang_cc1 -triple arm-unknown-linux -verify=CPU -fsyntax-only %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux -verify=CPU -fsyntax-only %s
+// RUN: %clang_cc1 -triple powerpc64le-unknown-linux -verify=CPU -fsyntax-only %s
+// RUN: %clang_cc1 -triple nvptx-unknown-linux -verify=GPU -fsyntax-only %s
+// RUN: %clang_cc1 -triple amdgcn-unknown-linux -verify=GPU -fsyntax-only %s
+// CPU-no-diagnostics
+
+double fn(void) {
+  double d = 0.;
+  // regular builtin
+  d += __builtin_canonicalizel(0.0); // GPU-error{{use of unknown builtin}}
+  // library builtin
+  d += __builtin_atan2l(0., 0.);     // GPU-error{{use of unknown builtin}}
+  return d;
+}

clang/test/Preprocessor/has_builtin_long_double.c

+// RUN: %clang_cc1 -triple arm-unknown-linux -verify -E %s -o - | FileCheck %s --check-prefix=ARM
+// RUN: %clang_cc1 -triple x86_64-unknown-linux -verify -E %s -o - | FileCheck %s --check-prefix=X86
+// RUN: %clang_cc1 -triple powerpc64le-unknown-linux -verify -E %s -o - | FileCheck %s --check-prefix=PPC
+// RUN: %clang_cc1 -triple nvptx-unknown-linux -verify -E %s -o - | FileCheck %s --check-prefix=GPU
+// RUN: %clang_cc1 -triple amdgcn-unknown-linux -verify -E %s -o - | FileCheck %s --check-prefix=GPU
+// expected-no-diagnostics
+
+// ARM: has_fabs
+// X86: has_fabs
+// PPC: has_fabs
+// PTX: has_fabs
+#if __has_builtin(fabs)
+  void has_fabs(void);
+#endif
+
+// ARM:     has_fabsl
+// X86:     has_fabsl
+// PPC:     has_fabsl
+// GPU-NOT: has_fabsl
+#if __has_builtin(fabsl)
+  void has_fabsl(void);
+#endif