Replace 'isProvablyNonNull' with existing utility llvm::IsKnownNonNull.

[nlewycky]

Summary

Replace 'isProvablyNonNull' with existing utility llvm::IsKnownNonNull which handles more cases. Noticed by inspection.

It looks like this is only used in 'writeback's which appears to be an obj-c / swift ABI feature. All the existing tests pass, but a testcase for this change is not included, since I'm not sure exactly how to exercise the difference.

[rjmccall]

The formation restrictions on ARC writeback conversions probably make this more-or-less impossible to test, but I can try to explain when they happen. They happen when you have an argument of type "id strong *" and pass it as a parameter of type "id autoreleasing *". strong is the default for variables, and autoreleasing is the default for pointer-to-id parameters, so basically you need something like:

void test(int opaque) {
  extern void foo(id*);
  id x;
  id y;
  foo(opaque ? &x : &y);
}

or any other expression that forms a sufficiently complex argument of type "id __strong *" prior to writeback conversion.

[rjmccall]

Actually, that should demonstrate the difference, assuming the LLVM function looks through selects, since IRGen should generate that as a select.

[rjmccall]

Oh. One danger with invoking a generic LLVM routine is that they often expect a well-formed function, not something that is plausibly still being emitted.

[rjmccall]

In that case, you probably will not be able to test this difference, because the argument is basically required to be the address of a local variable, a parameter, or null (or a various things that propagate such values). And our IR-generation scheme for parameters will never make them just an llvm::Argument.

LGTM, then.

[Eugene.Zelenko]

Committed in rL281979.

lib/CodeGen/CGCall.cpp

 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/Basic/TargetBuiltins.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
 #include "clang/CodeGen/SwiftCallingConv.h"
 #include "clang/Frontend/CodeGenOptions.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/Transforms/Utils/Local.h"
void CodeGenFunction::EmitDelegateCallArg(CallArgList &args,
   else
     args.add(convertTempToRValue(local, type, loc), type);
 }
 
 static bool isProvablyNull(llvm::Value *addr) {
   return isa<llvm::ConstantPointerNull>(addr);
 }
 
-static bool isProvablyNonNull(llvm::Value *addr) {
-  return isa<llvm::AllocaInst>(addr);
-}
-
 /// Emit the actual writing-back of a writeback.
 static void emitWriteback(CodeGenFunction &CGF,
                           const CallArgList::Writeback &writeback) {
   const LValue &srcLV = writeback.Source;
   Address srcAddr = srcLV.getAddress();
   assert(!isProvablyNull(srcAddr.getPointer()) &&
          "shouldn't have writeback for provably null argument");
 
   llvm::BasicBlock *contBB = nullptr;
 
   // If the argument wasn't provably non-null, we need to null check
   // before doing the store.
-  bool provablyNonNull = isProvablyNonNull(srcAddr.getPointer());
+  bool provablyNonNull = llvm::isKnownNonNull(srcAddr.getPointer());
   if (!provablyNonNull) {
     llvm::BasicBlock *writebackBB = CGF.createBasicBlock("icr.writeback");
     contBB = CGF.createBasicBlock("icr.done");
 
     llvm::Value *isNull =
       CGF.Builder.CreateIsNull(srcAddr.getPointer(), "icr.isnull");
     CGF.Builder.CreateCondBr(isNull, contBB, writebackBB);
     CGF.EmitBlock(writebackBB);
static void emitWritebackArg(CodeGenFunction &CGF, CallArgList &args,
   }
 
   llvm::BasicBlock *contBB = nullptr;
   llvm::BasicBlock *originBB = nullptr;
 
   // If the address is *not* known to be non-null, we need to switch.
   llvm::Value *finalArgument;
 
-  bool provablyNonNull = isProvablyNonNull(srcAddr.getPointer());
+  bool provablyNonNull = llvm::isKnownNonNull(srcAddr.getPointer());
   if (provablyNonNull) {
     finalArgument = temp.getPointer();
   } else {
     llvm::Value *isNull =
       CGF.Builder.CreateIsNull(srcAddr.getPointer(), "icr.isnull");
 
     finalArgument = CGF.Builder.CreateSelect(isNull, 
                                    llvm::ConstantPointerNull::get(destType),