Optimize printf calls that don't use 128-bit floating-point values

[sunfish]

Summary

lib/Transforms/Utils/SimplifyLibCalls.cpp currently contains an optimization where it converts calls to printf that don't have any floating-point arguments into calls to iprintf, on targets which have it, which is like printf except without support for floating-point numbers. This allows programs that don't need floating-point formatting to avoid linking in the floating-point formatting code, which can save several thousands of bytes.

This patch adds a similar optimization for when there are floating-point arguments, but no 128-bit floating-point arguments, transforming such calls to printf_no_Lf (though I'm more than happy to accept suggestions for better names). Since 128-bit floats are implemented in software, printf_no_Lf can't be quite as small as iprintf, but it still can be significantly smaller than the full printf.

[sbc100]

lib/Analysis/TargetLibraryInfo.cpp

157

This part is a separate and can be split out?

lib/Transforms/Utils/SimplifyLibCalls.cpp

2035

.. along with this?

[sunfish]

lib/Analysis/TargetLibraryInfo.cpp

157

Ok.

lib/Transforms/Utils/SimplifyLibCalls.cpp

2035

Yes, this was a cleanup that isn't strictly required by the rest of the patch. I've now reverted these cleanups.

[sunfish]

• Rename printf_no_Lf to __small_printf.
• Add more tests.
• Split out enabling the iprintf optimization for WASI, to be submitted in a separate patch later.

[sbc100]

test/Transforms/InstCombine/fprintf-1.ll

5 ↗

(On Diff #185203)

Do we need signal that this test now requires the webassembly target?

[sunfish]

test/Transforms/InstCombine/fprintf-1.ll

5 ↗

(On Diff #185203)

I don't think so; it doesn't need the whole target, just the triple. I assume this is why the test doesn't signal it needs XCore either, despite using it in the same way here.

include/llvm/Analysis/TargetLibraryInfo.def

 TLI_DEFINE_ENUM_INTERNAL(fopen64)
 TLI_DEFINE_STRING_INTERNAL("fopen64")
 /// int fork();
 TLI_DEFINE_ENUM_INTERNAL(fork)
 TLI_DEFINE_STRING_INTERNAL("fork")
 /// int fprintf(FILE *stream, const char *format, ...);
 TLI_DEFINE_ENUM_INTERNAL(fprintf)
 TLI_DEFINE_STRING_INTERNAL("fprintf")
+/// int fprintf_no_Lf(FILE *stream, const char *format, ...);
+TLI_DEFINE_ENUM_INTERNAL(fprintf_no_Lf)
+TLI_DEFINE_STRING_INTERNAL("fprintf_no_Lf")
 /// int fputc(int c, FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(fputc)
 TLI_DEFINE_STRING_INTERNAL("fputc")
 /// int fputc_unlocked(int c, FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(fputc_unlocked)
 TLI_DEFINE_STRING_INTERNAL("fputc_unlocked")
 /// int fputs(const char *s, FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(fputs)

 TLI_DEFINE_ENUM_INTERNAL(powl)
 TLI_DEFINE_STRING_INTERNAL("powl")
 /// ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset);
 TLI_DEFINE_ENUM_INTERNAL(pread)
 TLI_DEFINE_STRING_INTERNAL("pread")
 /// int printf(const char *format, ...);
 TLI_DEFINE_ENUM_INTERNAL(printf)
 TLI_DEFINE_STRING_INTERNAL("printf")
+/// int printf_no_Lf(const char *format, ...);
+TLI_DEFINE_ENUM_INTERNAL(printf_no_Lf)
+TLI_DEFINE_STRING_INTERNAL("printf_no_Lf")
 /// int putc(int c, FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(putc)
 TLI_DEFINE_STRING_INTERNAL("putc")
 /// int putc_unlocked(int c, FILE *stream);
 TLI_DEFINE_ENUM_INTERNAL(putc_unlocked)
 TLI_DEFINE_STRING_INTERNAL("putc_unlocked")
 /// int putchar(int c);
 TLI_DEFINE_ENUM_INTERNAL(putchar)

 TLI_DEFINE_ENUM_INTERNAL(siprintf)
 TLI_DEFINE_STRING_INTERNAL("siprintf")
 /// int snprintf(char *s, size_t n, const char *format, ...);
 TLI_DEFINE_ENUM_INTERNAL(snprintf)
 TLI_DEFINE_STRING_INTERNAL("snprintf")
 /// int sprintf(char *str, const char *format, ...);
 TLI_DEFINE_ENUM_INTERNAL(sprintf)
 TLI_DEFINE_STRING_INTERNAL("sprintf")
+/// int sprintf_no_Lf(char *str, const char *format, ...);
+TLI_DEFINE_ENUM_INTERNAL(sprintf_no_Lf)
+TLI_DEFINE_STRING_INTERNAL("sprintf_no_Lf")
 /// double sqrt(double x);
 TLI_DEFINE_ENUM_INTERNAL(sqrt)
 TLI_DEFINE_STRING_INTERNAL("sqrt")
 /// float sqrtf(float x);
 TLI_DEFINE_ENUM_INTERNAL(sqrtf)
 TLI_DEFINE_STRING_INTERNAL("sqrtf")
 /// long double sqrtl(long double x);
 TLI_DEFINE_ENUM_INTERNAL(sqrtl)

lib/Analysis/TargetLibraryInfo.cpp

if (T.isMacOSX() && T.getArch() == Triple::x86 &&
     // we don't care about) have two versions; on recent OSX, the one we want
     // has a $UNIX2003 suffix. The two implementations are identical except
     // for the return value in some edge cases.  However, we don't want to
     // generate code that depends on the old symbols.
     TLI.setAvailableWithName(LibFunc_fwrite, "fwrite$UNIX2003");
     TLI.setAvailableWithName(LibFunc_fputs, "fputs$UNIX2003");
   }
 
-  // iprintf and friends are only available on XCore and TCE.
-  if (T.getArch() != Triple::xcore && T.getArch() != Triple::tce) {
+  // iprintf and friends are only available on XCore, TCE, and WASI.
+  if (T.getArch() != Triple::xcore && T.getArch() != Triple::tce &&
+      T.getOS() != Triple::WASI) {
     TLI.setUnavailable(LibFunc_iprintf);
     TLI.setUnavailable(LibFunc_siprintf);
     TLI.setUnavailable(LibFunc_fiprintf);
   }
 
+  // printf_no_Lf and friends are only available on WASI.
+  if (T.getOS() != Triple::WASI) {
+    TLI.setUnavailable(LibFunc_printf_no_Lf);
+    TLI.setUnavailable(LibFunc_sprintf_no_Lf);
+    TLI.setUnavailable(LibFunc_fprintf_no_Lf);
+  }
+
   if (T.isOSWindows() && !T.isOSCygMing()) {
     // Win32 does not support long double
     TLI.setUnavailable(LibFunc_acosl);
     TLI.setUnavailable(LibFunc_asinl);
     TLI.setUnavailable(LibFunc_atanl);
     TLI.setUnavailable(LibFunc_atan2l);
     TLI.setUnavailable(LibFunc_ceill);
     TLI.setUnavailable(LibFunc_copysignl);
bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
   case LibFunc_strdup:
   case LibFunc_strndup:
     return (NumParams >= 1 && FTy.getReturnType()->isPointerTy() &&
             FTy.getParamType(0)->isPointerTy());
   case LibFunc_sscanf:
   case LibFunc_stat:
   case LibFunc_statvfs:
   case LibFunc_siprintf:
+  case LibFunc_sprintf_no_Lf:
   case LibFunc_sprintf:
     return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy() &&
             FTy.getReturnType()->isIntegerTy(32));
   case LibFunc_snprintf:
     return (NumParams == 3 && FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(2)->isPointerTy() &&
             FTy.getReturnType()->isIntegerTy(32));
bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
   case LibFunc_atof:
   case LibFunc_atoi:
   case LibFunc_atol:
   case LibFunc_atoll:
   case LibFunc_ferror:
   case LibFunc_getenv:
   case LibFunc_getpwnam:
   case LibFunc_iprintf:
+  case LibFunc_printf_no_Lf:
   case LibFunc_pclose:
   case LibFunc_perror:
   case LibFunc_printf:
   case LibFunc_puts:
   case LibFunc_uname:
   case LibFunc_under_IO_getc:
   case LibFunc_unlink:
   case LibFunc_unsetenv:
return (NumParams == 4 && FTy.getReturnType()->isIntegerTy() &&
             FTy.getParamType(2)->isIntegerTy() &&
             FTy.getParamType(3)->isPointerTy());
   case LibFunc_fputs:
   case LibFunc_fputs_unlocked:
     return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy());
   case LibFunc_fscanf:
   case LibFunc_fiprintf:
+  case LibFunc_fprintf_no_Lf:
   case LibFunc_fprintf:
     return (NumParams >= 2 && FTy.getReturnType()->isIntegerTy() &&
             FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy());
   case LibFunc_fgetpos:
     return (NumParams >= 2 && FTy.getParamType(0)->isPointerTy() &&
             FTy.getParamType(1)->isPointerTy());
   case LibFunc_getchar:

lib/Transforms/Utils/SimplifyLibCalls.cpp

 }
 
 static bool callHasFloatingPointArgument(const CallInst *CI) {
   return any_of(CI->operands(), [](const Use &OI) {
     return OI->getType()->isFloatingPointTy();
   });
 }
 
+static bool callHasFP128Argument(const CallInst *CI) {
+  return any_of(CI->operands(), [](const Use &OI) {
+    return OI->getType()->isFP128Ty();
+  });
+}
+
 static Value *convertStrToNumber(CallInst *CI, StringRef &Str, int64_t Base) {
   if (Base < 2 || Base > 36)
     // handle special zero base
     if (Base != 0)
       return nullptr;
 
   char *End;
   std::string nptr = Str.str();
if (Value *V = optimizePrintFString(CI, B)) {
     return V;
   }
 
   // printf(format, ...) -> iprintf(format, ...) if no floating point
   // arguments.
   if (TLI->has(LibFunc_iprintf) && !callHasFloatingPointArgument(CI)) {
     Module *M = B.GetInsertBlock()->getParent()->getParent();
     FunctionCallee IPrintFFn =
-        M->getOrInsertFunction("iprintf", FT, Callee->getAttributes());
+        M->getOrInsertFunction(TLI->getName(LibFunc_iprintf),
+                               FT, Callee->getAttributes());
     CallInst *New = cast<CallInst>(CI->clone());
     New->setCalledFunction(IPrintFFn);
     B.Insert(New);
     return New;
   }
+
+  // printf(format, ...) -> printf_no_Lf(format, ...) if no 128-bit floating point
+  // arguments.
+  if (TLI->has(LibFunc_printf) && !callHasFP128Argument(CI)) {
+    Module *M = B.GetInsertBlock()->getParent()->getParent();
+    auto PrintFNoLfFn =
+        M->getOrInsertFunction(TLI->getName(LibFunc_printf_no_Lf),
+                               FT, Callee->getAttributes());
+    CallInst *New = cast<CallInst>(CI->clone());
+    New->setCalledFunction(PrintFNoLfFn);
+    B.Insert(New);
+    return New;
+  }
+
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeSPrintFString(CallInst *CI, IRBuilder<> &B) {
   // Check for a fixed format string.
   StringRef FormatStr;
   if (!getConstantStringInfo(CI->getArgOperand(1), FormatStr))
     return nullptr;
if (TLI->has(LibFunc_siprintf) && !callHasFloatingPointArgument(CI)) {
     Module *M = B.GetInsertBlock()->getParent()->getParent();
     FunctionCallee SIPrintFFn =
         M->getOrInsertFunction("siprintf", FT, Callee->getAttributes());
     CallInst *New = cast<CallInst>(CI->clone());
     New->setCalledFunction(SIPrintFFn);
     B.Insert(New);
     return New;
   }
+
+  // sprintf(str, format, ...) -> sprintf_no_Lf(str, format, ...) if no 128-bit
+  // floating point arguments.
+  if (TLI->has(LibFunc_sprintf_no_Lf) && !callHasFP128Argument(CI)) {
+    Module *M = B.GetInsertBlock()->getParent()->getParent();
+    auto SPrintFNoLfFn =
+        M->getOrInsertFunction("sprintf_no_Lf", FT, Callee->getAttributes());
+    CallInst *New = cast<CallInst>(CI->clone());
+    New->setCalledFunction(SPrintFNoLfFn);
+    B.Insert(New);
+    return New;
+  }
+
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeSnPrintFString(CallInst *CI, IRBuilder<> &B) {
   // Check for a fixed format string.
   StringRef FormatStr;
   if (!getConstantStringInfo(CI->getArgOperand(2), FormatStr))
     return nullptr;
if (TLI->has(LibFunc_fiprintf) && !callHasFloatingPointArgument(CI)) {
     Module *M = B.GetInsertBlock()->getParent()->getParent();
     FunctionCallee FIPrintFFn =
         M->getOrInsertFunction("fiprintf", FT, Callee->getAttributes());
     CallInst *New = cast<CallInst>(CI->clone());
     New->setCalledFunction(FIPrintFFn);
     B.Insert(New);
     return New;
   }
+
+  // fprintf(stream, format, ...) -> fprintf_no_Lf(stream, format, ...) if no
+  // 128-bit floating point arguments.
+  if (TLI->has(LibFunc_fprintf_no_Lf) && !callHasFP128Argument(CI)) {
+    Module *M = B.GetInsertBlock()->getParent()->getParent();
+    auto FPrintFNoLfFn =
+        M->getOrInsertFunction("fprintf_no_Lf", FT, Callee->getAttributes());
+    CallInst *New = cast<CallInst>(CI->clone());
+    New->setCalledFunction(FPrintFNoLfFn);
+    B.Insert(New);
+    return New;
+  }
+
   return nullptr;
 }
 
 Value *LibCallSimplifier::optimizeFWrite(CallInst *CI, IRBuilder<> &B) {
   optimizeErrorReporting(CI, B, 3);
 
   // Get the element size and count.
   ConstantInt *SizeC = dyn_cast<ConstantInt>(CI->getArgOperand(1));

unittests/Analysis/TargetLibraryInfoTest.cpp

parseAssembly(
       "declare double @exp10(double)\n"
       "declare float @exp10f(float)\n"
       "declare x86_fp80 @exp10l(x86_fp80)\n"
 
       // These printf variants have the same prototype as the non-'i' versions.
       "declare i32 @fiprintf(%struct*, i8*, ...)\n"
       "declare i32 @iprintf(i8*, ...)\n"
       "declare i32 @siprintf(i8*, i8*, ...)\n"
+      "declare i32 @fprintf_no_Lf(%struct*, i8*, ...)\n"
+      "declare i32 @printf_no_Lf(i8*, ...)\n"
+      "declare i32 @sprintf_no_Lf(i8*, i8*, ...)\n"
 
       "declare i32 @htonl(i32)\n"
       "declare i16 @htons(i16)\n"
       "declare i32 @ntohl(i32)\n"
       "declare i16 @ntohs(i16)\n"
 
       "declare i32 @isascii(i32)\n"
       "declare i32 @isdigit(i32)\n"