Introduce a generic memset to bzero transformation in CodeGen

[gchatelet]

Summary

This is WIP and superseding D69623

[resistor]

llvm/lib/Analysis/TargetLibraryInfo.cpp

56–58

This name reads like it refers to functions that were added in 2001, not to functions that were removed after 2001.

llvm/test/CodeGen/AArch64/arm64-memset-to-bzero.ll

11 ↗

(On Diff #227294)

Can you remove these unrelated changes?

[gchatelet]

rebase and revert unrelated changes.

[gchatelet]

A bunch of tests are still failing

LLVM :: CodeGen/AArch64/arm64-memset-to-bzero-pgso.ll
LLVM :: CodeGen/AArch64/arm64-memset-to-bzero.ll
LLVM :: CodeGen/Mips/indirect-jump-hazard/long-calls.ll
LLVM :: CodeGen/Mips/micromips-target-external-symbol-reloc.ll
LLVM :: CodeGen/X86/force-align-stack-alloca.ll
LLVM :: CodeGen/X86/pr36865.ll
LLVM :: CodeGen/X86/stack-clash-unknown-call.ll
LLVM :: Transforms/InferFunctionAttrs/annotate.ll

llvm/lib/Analysis/TargetLibraryInfo.cpp

if (T.isMacOSX() && T.isMacOSXVersionLT(10, 9))
     return false;
 
   if (T.isiOS() && T.isOSVersionLT(7, 0))
     return false;
 
   return true;
 }
 
-static bool hasBcmp(const Triple &TT) {
-  // Posix removed support from bcmp() in 2001, but the glibc and several
-  // implementations of the libc still have it.
+static bool hasPosix2001LibCFunctions(const Triple &TT) {
+  // Posix removed support from some libc functions in 2001 (bcmp, bzero), but
+  // the glibc and several implementations of the libc still have it.
   if (TT.isOSLinux())
     return TT.isGNUEnvironment() || TT.isMusl();
   // Both NetBSD and OpenBSD are planning to remove the function. Windows does
   // not have it.
   return TT.isOSFreeBSD() || TT.isOSSolaris();
 }
 
 /// Initialize the set of available library functions based on the specified
if (!hasSinCosPiStret(T)) {
     TLI.setUnavailable(LibFunc_sinpi);
     TLI.setUnavailable(LibFunc_sinpif);
     TLI.setUnavailable(LibFunc_cospi);
     TLI.setUnavailable(LibFunc_cospif);
     TLI.setUnavailable(LibFunc_sincospi_stret);
     TLI.setUnavailable(LibFunc_sincospif_stret);
   }
 
-  if (!hasBcmp(T))
+  if (!hasPosix2001LibCFunctions(T)) {
+    TLI.setUnavailable(LibFunc_bzero);
     TLI.setUnavailable(LibFunc_bcmp);
+  }
 
   if (T.isMacOSX() && T.getArch() == Triple::x86 &&
       !T.isMacOSXVersionLT(10, 7)) {
     // x86-32 OSX has a scheme where fwrite and fputs (and some other functions
     // 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.

llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/MemoryLocation.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
+#include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/CodeGen/ISDOpcodes.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
 #include "llvm/CodeGen/RuntimeLibcalls.h"
CLI.setDebugLoc(dl)
       .setDiscardResult()
       .setTailCall(isTailCall);
 
   std::pair<SDValue, SDValue> CallResult = TLI->LowerCallTo(CLI);
   return CallResult.second;
 }
 
 SDValue SelectionDAG::getMemset(SDValue Chain, const SDLoc &dl, SDValue Dst,
-                                SDValue Src, SDValue Size, Align Alignment,
-                                bool isVol, bool isTailCall,
+                                SDValue ByteValue, SDValue Size,
+                                Align Alignment, bool isVol, bool isTailCall,
                                 MachinePointerInfo DstPtrInfo) {
   // Check to see if we should lower the memset to stores first.
   // For cases within the target-specified limits, this is the best choice.
   ConstantSDNode *ConstantSize = dyn_cast<ConstantSDNode>(Size);
   if (ConstantSize) {
     // Memset with size zero? Just return the original chain.
     if (ConstantSize->isNullValue())
       return Chain;
 
-    SDValue Result = getMemsetStores(*this, dl, Chain, Dst, Src,
+    SDValue Result = getMemsetStores(*this, dl, Chain, Dst, ByteValue,
                                      ConstantSize->getZExtValue(), Alignment,
                                      isVol, DstPtrInfo);
 
     if (Result.getNode())
       return Result;
   }
 
   // Then check to see if we should lower the memset with target-specific
   // code. If the target chooses to do this, this is the next best.
   if (TSI) {
     SDValue Result = TSI->EmitTargetCodeForMemset(
-        *this, dl, Chain, Dst, Src, Size, Alignment, isVol, DstPtrInfo);
+        *this, dl, Chain, Dst, ByteValue, Size, Alignment, isVol, DstPtrInfo);
     if (Result.getNode())
       return Result;
   }
 
   checkAddrSpaceIsValidForLibcall(TLI, DstPtrInfo.getAddrSpace());
 
-  // Emit a library call.
-  TargetLowering::ArgListTy Args;
+  const auto MakeArg = [](Type *Ty, SDValue Node) {
     TargetLowering::ArgListEntry Entry;
-  Entry.Node = Dst; Entry.Ty = Type::getInt8PtrTy(*getContext());
-  Args.push_back(Entry);
-  Entry.Node = Src;
-  Entry.Ty = Src.getValueType().getTypeForEVT(*getContext());
-  Args.push_back(Entry);
-  Entry.Node = Size;
-  Entry.Ty = getDataLayout().getIntPtrType(*getContext());
-  Args.push_back(Entry);
+    Entry.Node = Node;
+    Entry.Ty = Ty;
+    return Entry;
+  };
+
+  // Emit a library call.
+  llvm::LLVMContext &Ctx = *getContext();
+  const llvm::DataLayout &DL = getDataLayout();
+  ConstantSDNode *ConstantByteValue = dyn_cast<ConstantSDNode>(ByteValue);
+  if (ConstantByteValue && ConstantByteValue->isNullValue() &&
+      LibInfo->has(LibFunc_bzero)) {
+    TargetLowering::CallLoweringInfo CLI(*this);
+    CLI.setDebugLoc(dl)
+        .setChain(Chain)
+        .setLibCallee(CallingConv::C, Dst.getValueType().getTypeForEVT(Ctx),
+                      getExternalSymbol(LibInfo->getName(LibFunc_bzero).data(),
+                                        TLI->getPointerTy(DL)),
+                      {MakeArg(Type::getInt8PtrTy(Ctx), Dst),
+                       MakeArg(DL.getIntPtrType(Ctx), Size)})
+        .setDiscardResult();
+
+    return TLI->LowerCallTo(CLI).second;
+  }
 
   // FIXME: pass in SDLoc
   TargetLowering::CallLoweringInfo CLI(*this);
   CLI.setDebugLoc(dl)
       .setChain(Chain)
-      .setLibCallee(TLI->getLibcallCallingConv(RTLIB::MEMSET),
-                    Dst.getValueType().getTypeForEVT(*getContext()),
-                    getExternalSymbol(TLI->getLibcallName(RTLIB::MEMSET),
-                                      TLI->getPointerTy(getDataLayout())),
-                    std::move(Args))
+      .setLibCallee(
+          TLI->getLibcallCallingConv(RTLIB::MEMSET),
+          Dst.getValueType().getTypeForEVT(Ctx),
+                            TLI->getPointerTy(DL)),
+          {MakeArg(Type::getInt8PtrTy(Ctx), Dst),
+           MakeArg(ByteValue.getValueType().getTypeForEVT(Ctx), ByteValue),
+           MakeArg(DL.getIntPtrType(Ctx), Size)})
       .setDiscardResult()
       .setTailCall(isTailCall);
 
-  std::pair<SDValue,SDValue> CallResult = TLI->LowerCallTo(CLI);
-  return CallResult.second;
+  return TLI->LowerCallTo(CLI).second;
 }
 
 SDValue SelectionDAG::getAtomicMemset(SDValue Chain, const SDLoc &dl,
                                       SDValue Dst, unsigned DstAlign,
                                       SDValue Value, SDValue Size, Type *SizeTy,
                                       unsigned ElemSz, bool isTailCall,
                                       MachinePointerInfo DstPtrInfo) {
   // Emit a library call.