[SimplifyLibCalls] Teach the Fortified libcall simplifier to look through objectsize.

[ab]

Summary

It used to only try to fold fortified (_chk) libcalls with a constant objectsize.
However, in most cases, the @llvm.objectsize intrinsic is used. Teach the
LibCallSimplifier to ask for the objectsize to handle the latter case.

Three-ish (one, really) new optimizations opportunities were created in the tests.

[ab]

Note that this + D498 seem to have caused two major differences in
the testsuite, lowercase and sqlite3.

The execution time for SingleSource/Benchmarks/Misc/lowercase went
down by 99.98% (!), because the actual lowercasing logic was optimized
out, leaving only the iteration printfs. At first glance, the change
seems correct; I'll look into it in more detail.

MultiSource/Applications/sqlite3 has seen its compile time grow by
~25% to 20s. Interestingly, a ~1.5% execution slowdown is also
incurred (seems unrelated to D498, only caused by moving stuff around
because of the _chk -> intrinsic optimizations enabled by this patch).

getObjectSize, which is used in the objectsize patch, is somewhat
expensive. But profiling shows that there are two slowdown sources: a
little more everywhere, and MemDepAnalysis::getNonLocalPointerDependency.
Both seem to be caused by the transformation of most _chk calls to
intrinsics (enabled by the objectsize patch).

At this point I'm not sure whether it's currently worth it to do this
_chk+llvm.objectsize -> intrinsic lowering, earlier than CGP.
If not I think the D498 optimization would be pretty useless on
fortified targets (like the rest of memcpyopt, one might add.)

I'll try to isolate the impact of this specific patch. Meanwhile, feedback
would be much appreciated!

include/llvm/Transforms/Utils/SimplifyLibCalls.h

private:
   void classifyArgUse(Value *Val, BasicBlock *BB, bool IsFloat,
                       SmallVectorImpl<CallInst *> &SinCalls,
                       SmallVectorImpl<CallInst *> &CosCalls,
                       SmallVectorImpl<CallInst *> &SinCosCalls);
   void replaceTrigInsts(SmallVectorImpl<CallInst *> &Calls, Value *Res);
   Value *optimizePrintFString(CallInst *CI, IRBuilder<> &B);
   Value *optimizeSPrintFString(CallInst *CI, IRBuilder<> &B);
   Value *optimizeFPrintFString(CallInst *CI, IRBuilder<> &B);
+  bool isFortifiedCallFoldable(CallInst *CI, unsigned SizeCIOp,
+                               unsigned SizeArgOp, bool isString);
 
   /// hasFloatVersion - Checks if there is a float version of the specified
   /// function by checking for an existing function with name FuncName + f
   bool hasFloatVersion(StringRef FuncName);
 };
 } // End llvm namespace
 
 #endif

lib/Transforms/Utils/SimplifyLibCalls.cpp

 // that performs serious instruction folding, use the instcombine pass instead.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/SimplifyLibCalls.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/Triple.h"
+#include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
default:
     return TLI->has(LongDoubleFn);
   }
 }
 
 //===----------------------------------------------------------------------===//
 // Fortified Library Call Optimizations
 //===----------------------------------------------------------------------===//
 
-static bool isFortifiedCallFoldable(CallInst *CI, unsigned SizeCIOp, unsigned SizeArgOp,
+bool LibCallSimplifier::isFortifiedCallFoldable(CallInst *CI, unsigned SizeCIOp,
+                                                unsigned SizeArgOp,
                                                 bool isString) {
-  if (CI->getArgOperand(SizeCIOp) == CI->getArgOperand(SizeArgOp))
+  // The destination operand is always the first.
+  Value *Dest = CI->getArgOperand(0);
+  Value *SizeCIVal = CI->getArgOperand(SizeCIOp);
+  Value *SizeArg = CI->getArgOperand(SizeArgOp);
+
+  // If the argument size and known object size are the same value, we can
+  // remove the check.
+  if (SizeCIVal == SizeArg)
     return true;
-  if (ConstantInt *SizeCI =
-          dyn_cast<ConstantInt>(CI->getArgOperand(SizeCIOp))) {
-    if (SizeCI->isAllOnesValue())
-      return true;
-    if (isString) {
-      uint64_t Len = GetStringLength(CI->getArgOperand(SizeArgOp));
-      // If the length is 0 we don't know how long it is and so we can't
-      // remove the check.
-      if (Len == 0)
-        return false;
-      return SizeCI->getZExtValue() >= Len;
-    }
-    if (ConstantInt *Arg = dyn_cast<ConstantInt>(CI->getArgOperand(SizeArgOp)))
-      return SizeCI->getZExtValue() >= Arg->getZExtValue();
+
+  uint64_t ObjectSizeInt = 0;
+  APInt SizeCIAPInt = APInt::getAllOnesValue(64U);
+
+  if (ConstantInt *SizeCI = dyn_cast<ConstantInt>(SizeCIVal))
+    SizeCIAPInt = SizeCI->getValue();
+  else if (getObjectSize(Dest, ObjectSizeInt, DL, TLI))
+    SizeCIAPInt = APInt(64U, ObjectSizeInt);
+
+  // If the object size is unknown (-1), we can remove the check.
+  if (SizeCIAPInt.isAllOnesValue())
+    uint64_t Len = GetStringLength(SizeArg);
+    return SizeCIAPInt.getZExtValue() >= Len;
   }
+  // If the libcall is known not to overflow, we can remove the check.
+  if (ConstantInt *Arg = dyn_cast<ConstantInt>(SizeArg))
+    return SizeCIAPInt.getZExtValue() >= Arg->getZExtValue();
   return false;
 }
 
 Value *LibCallSimplifier::optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B) {
   Function *Callee = CI->getCalledFunction();
   FunctionType *FT = Callee->getFunctionType();
   LLVMContext &Context = CI->getContext();
 

test/CodeGen/X86/2011-02-21-VirtRegRewriter-KillSubReg.ll

if.then758:
   %add763 = add i32 %add761, %call747
   %add.ptr768 = getelementptr inbounds [516 x i8]* null, i32 0, i32 %add761
   br i1 undef, label %cond.false783, label %cond.true771
 
 cond.true771:
   %call782 = call i8* @__memmove_chk(i8* %add.ptr768, i8* undef, i32 %call747, i32 undef)
   br label %cond.end791
 
-; CHECK: calll __memmove_chk
+; CHECK: calll memmove@PLT
 cond.false783:
   %call.i1035 = call i8* @__memmove_chk(i8* %add.ptr768, i8* undef, i32 %call747, i32 undef) nounwind
   br label %cond.end791
 
 cond.end791:
   %conv801 = trunc i32 %call747 to i8
   %add.ptr822.sum = add i32 %call747, 3
   %arrayidx833 = getelementptr inbounds [516 x i8]* null, i32 0, i32 %add.ptr822.sum

test/Transforms/InstCombine/stpcpy_chk-1.ll

 
 ; Check case where the string length is not constant.
 
 define i8* @test_simplify5() {
 ; CHECK-LABEL: @test_simplify5(
   %dst = getelementptr inbounds [60 x i8]* @a, i32 0, i32 0
   %src = getelementptr inbounds [12 x i8]* @.str, i32 0, i32 0
 
-; CHECK: @__memcpy_chk
+; CHECK: call void @llvm.memcpy.p0i8.p0i8.i32
   %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false)
   %ret = call i8* @__stpcpy_chk(i8* %dst, i8* %src, i32 %len)
 ; CHECK: ret i8* getelementptr inbounds ([60 x i8]* @a, i32 0, i32 11)
   ret i8* %ret
 }
 
 ; Check case where the source and destination are the same.
 

test/Transforms/InstCombine/strcpy_chk-1.ll

 
 ; Check case where the string length is not constant.
 
 define void @test_simplify5() {
 ; CHECK-LABEL: @test_simplify5(
   %dst = getelementptr inbounds [60 x i8]* @a, i32 0, i32 0
   %src = getelementptr inbounds [12 x i8]* @.str, i32 0, i32 0
 
-; CHECK: @__memcpy_chk
+; CHECK: call void @llvm.memcpy.p0i8.p0i8.i32
   %len = call i32 @llvm.objectsize.i32.p0i8(i8* %dst, i1 false)
   call i8* @__strcpy_chk(i8* %dst, i8* %src, i32 %len)
   ret void
 }
 
 ; Check case where the source and destination are the same.
 
 define i8* @test_simplify6() {