[Clang] Mutate printf bulitin names under IEEE128 on PPC64

[qiucf]

Summary

Glibc uses these new symbol names to support IEEE-754 128-bit float support.

[jsji]

clang/lib/CodeGen/CGBuiltin.cpp

100

Why only these printf builtins? I think there are full list of similar libcalls in GLIBC_2.32 and later?

120

How do we deal with the glibc version? Do we assume that user has glibc newer than GLIBC_2.32?

122

Do we have to do it here? Can we just update the libcall names in RuntimeLibcalls.def or setLibcallName similar to others?

[qiucf]

Add nexttoward

[qiucf]

clang/lib/CodeGen/CGBuiltin.cpp

100

Yes, Glibc redirects all these functions depending on long double semantics, and GCC has corresponding builtins for almost all library functions (https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html).

But currently clang doesn't have all of these builtins (for example, __builtin_scanf). It seems beyond this patch's scope to make the list complete.

120

I notice not all libcall symbols are implemented in compiler-rt, which means we don't need to always expect all libcalls emitted are available in current libc?

It's surprising that libc version are not checked in clang/driver/toolchain part. The only place checking libc version is in sanitizer. Maybe we can use that to emit warnings, like D112906.

122

I think we cannot fill these calls in backend's runtime libcall list, because it contains supplementary routine names for legalizing IR instruction/intrinsics. Here the builtins are just converted into normal function calls in IR.

[jsji]

LGTM. Please hold a few days to see whether there are inputs from other reviewers. Thanks.

clang/lib/CodeGen/CGBuiltin.cpp

100

OK. Thanks. Can we add a TODO note.

clang/lib/CodeGen/CGBuiltin.cpp

 llvm::Constant *CodeGenModule::getBuiltinLibFunction(const FunctionDecl *FD,
                                                      unsigned BuiltinID) {
   assert(Context.BuiltinInfo.isLibFunction(BuiltinID));
 
   // Get the name, skip over the __builtin_ prefix (if necessary).
   StringRef Name;
   GlobalDecl D(FD);
 
+  // TODO: This list should be expanded or refactored after all GCC-compatible
+  // std libcall builtins are implemented.
+  static SmallDenseMap<unsigned, StringRef, 8> F128Builtins{
+      {Builtin::BI__builtin_printf, "__printfieee128"},
+      {Builtin::BI__builtin_vsnprintf, "__vsnprintfieee128"},
+      {Builtin::BI__builtin_vsprintf, "__vsprintfieee128"},
+      {Builtin::BI__builtin_sprintf, "__sprintfieee128"},
+      {Builtin::BI__builtin_snprintf, "__snprintfieee128"},
+      {Builtin::BI__builtin_fprintf, "__fprintfieee128"},
+      {Builtin::BI__builtin_nexttowardf128, "__nexttowardieee128"},
+  };
+
   // If the builtin has been declared explicitly with an assembler label,
   // use the mangled name. This differs from the plain label on platforms
   // that prefix labels.
   if (FD->hasAttr<AsmLabelAttr>())
     Name = getMangledName(D);
+  else {
+    // TODO: This mutation should also be applied to other targets other than
+    // PPC, after backend supports IEEE 128-bit style libcalls.
+    if (getTriple().isPPC64() &&
+        &getTarget().getLongDoubleFormat() == &llvm::APFloat::IEEEquad() &&
+        F128Builtins.find(BuiltinID) != F128Builtins.end())
+      Name = F128Builtins[BuiltinID];
     else
       Name = Context.BuiltinInfo.getName(BuiltinID) + 10;
+  }
 
   llvm::FunctionType *Ty =
     cast<llvm::FunctionType>(getTypes().ConvertType(FD->getType()));
 
   return GetOrCreateLLVMFunction(Name, Ty, D, /*ForVTable=*/false);
 }
 
 /// Emit the conversions required to turn the given value into an

clang/test/CodeGen/math-builtins-long.c

void foo(long double f, long double *l, int *i, const char *c) {
   // PPC: call ppc_fp128 @nextafterl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @nextafterl(fp128 %{{.+}}, fp128 %{{.+}})
   // PPCF128: call fp128 @nextafterf128(fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_nextafterl(f,f);
 
   // F80: call x86_fp80 @nexttowardl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @nexttowardl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @nexttowardl(fp128 %{{.+}}, fp128 %{{.+}})
-  // PPCF128: call fp128 @nexttowardf128(fp128 %{{.+}}, fp128 %{{.+}})
+  // PPCF128: call fp128 @__nexttowardieee128(fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_nexttowardl(f,f);
 
   // F80: call x86_fp80 @remainderl(x86_fp80 %{{.+}}, x86_fp80 %{{.+}})
   // PPC: call ppc_fp128 @remainderl(ppc_fp128 %{{.+}}, ppc_fp128 %{{.+}})
   // X86F128: call fp128 @remainderl(fp128 %{{.+}}, fp128 %{{.+}})
   // PPCF128: call fp128 @remainderf128(fp128 %{{.+}}, fp128 %{{.+}})
   __builtin_remainderl(f,f);
 

clang/test/CodeGen/ppc64-f128-builtins.c

+// RUN: %clang_cc1 -triple powerpc64le-linux-gnu -emit-llvm -o - %s \
+// RUN:   -mabi=ieeelongdouble | FileCheck --check-prefix=IEEE128 %s
+// RUN: %clang_cc1 -triple powerpc64le-linux-gnu -emit-llvm -o - %s \
+// RUN:   | FileCheck --check-prefix=PPC128 %s
+
+long double x;
+char buf[20];
+
+// IEEE128-LABEL: define dso_local void @test_printf
+// IEEE128: call signext i32 (i8*, ...) @__printfieee128
+// PPC128-LABEL: define dso_local void @test_printf
+// PPC128: call signext i32 (i8*, ...) @printf
+void test_printf() {
+  __builtin_printf("%.Lf", x);
+}
+
+// IEEE128-LABEL: define dso_local void @test_vsnprintf
+// IEEE128: call signext i32 @__vsnprintfieee128
+// PPC128-LABEL: define dso_local void @test_vsnprintf
+// PPC128: call signext i32 @vsnprintf
+void test_vsnprintf(int n, ...) {
+  __builtin_va_list va;
+  __builtin_va_start(va, n);
+  __builtin_vsnprintf(buf, 20, "%.Lf", va);
+  __builtin_va_end(va);
+}
+
+// IEEE128-LABEL: define dso_local void @test_vsprintf
+// IEEE128: call signext i32 @__vsprintfieee128
+// PPC128-LABEL: define dso_local void @test_vsprintf
+// PPC128: call signext i32 @vsprintf
+void test_vsprintf(int n, ...) {
+  __builtin_va_list va;
+  __builtin_va_start(va, n);
+  __builtin_vsprintf(buf, "%.Lf", va);
+  __builtin_va_end(va);
+}
+
+// IEEE128-LABEL: define dso_local void @test_sprintf
+// IEEE128: call signext i32 (i8*, i8*, ...) @__sprintfieee128
+// PPC128-LABEL: define dso_local void @test_sprintf
+// PPC128: call signext i32 (i8*, i8*, ...) @sprintf
+void test_sprintf() {
+  __builtin_sprintf(buf, "%.Lf", x);
+}
+
+// IEEE128-LABEL: define dso_local void @test_snprintf
+// IEEE128: call signext i32 (i8*, i64, i8*, ...) @__snprintfieee128
+// PPC128-LABEL: define dso_local void @test_snprintf
+// PPC128: call signext i32 (i8*, i64, i8*, ...) @snprintf
+void test_snprintf() {
+  __builtin_snprintf(buf, 20, "%.Lf", x);
+}
+
+// GLIBC has special handling of 'nexttoward'
+
+// IEEE128-LABEL: define dso_local fp128 @test_nexttoward
+// IEEE128: call fp128 @__nexttowardieee128
+// PPC128-LABEL: define dso_local ppc_fp128 @test_nexttoward
+// PPC128: call ppc_fp128 @nexttowardl
+long double test_nexttoward(long double a, long double b) {
+  return __builtin_nexttowardl(a, b);
+}