Revert r21707 "Remove the SIL is_nonnull instruction. It's no longer useful."

We want to be able to work around problems with non-failable
Objective-C initializers actually failing, which can happen when the
API audit data incorrectly marks an initializer as non-failable.



Swift SVN r21711

Author: DougGregor

docs/SIL.rst

@@ -3381,6 +3381,20 @@ Applying the resulting thick function value is equivalent to applying the
 original thin value. The ``thin_to_thick_function`` conversion may be
 eliminated if the context is proven not to be needed.
 
+is_nonnull
+``````````
+::
+
+  sil-instruction ::= 'is_nonnull' sil-operand
+
+  %1 = is_nonnull %0 : $C
+  // %0 must be of reference or function type $C
+  // %1 will be of type Builtin.Int1
+
+Checks whether a reference type value is null, returning 1 if
+the value is not null, or 0 if it is null.  If the value is a function
+type, it checks the function pointer (not the data pointer) for null.
+
 Checked Conversions
 ~~~~~~~~~~~~~~~~~~~
 

include/swift/SIL/PatternMatch.h

@@ -342,6 +342,7 @@ UNARY_OP_MATCH_WITH_ARG_MATCHER(ThickToObjCMetatypeInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(ObjCToThickMetatypeInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(ObjCMetatypeToObjectInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(ObjCExistentialMetatypeToObjectInst)
+UNARY_OP_MATCH_WITH_ARG_MATCHER(IsNonnullInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(RetainValueInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(ReleaseValueInst)
 UNARY_OP_MATCH_WITH_ARG_MATCHER(AutoreleaseValueInst)

include/swift/SIL/SILBuilder.h

@@ -427,6 +427,13 @@ class SILBuilder {
     return insert(new (F.getModule()) RefToUnmanagedInst(loc, op, ty));
   }
 
+  IsNonnullInst *createIsNonnull(SILLocation loc,
+                                 SILValue operand) {
+    return insert(new (F.getModule())
+                    IsNonnullInst(loc, operand,
+                      SILType::getBuiltinIntegerType(1, getASTContext())));
+  }
+
   UnconditionalCheckedCastInst *createUnconditionalCheckedCast(SILLocation loc,
                                                                SILValue op,
                                                                SILType destTy) {

include/swift/SIL/SILCloner.h

@@ -679,6 +679,14 @@ visitObjCToThickMetatypeInst(ObjCToThickMetatypeInst *Inst) {
                                            getOpType(Inst->getType())));
 }
 
+template<typename ImplClass>
+void
+SILCloner<ImplClass>::visitIsNonnullInst(IsNonnullInst *Inst) {
+  doPostProcess(Inst,
+    getBuilder().createIsNonnull(getOpLocation(Inst->getLoc()),
+                                 getOpValue(Inst->getOperand())));
+}
+  
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitUnconditionalCheckedCastInst(

include/swift/SIL/SILInstruction.h

@@ -1385,6 +1385,13 @@ class ObjCProtocolInst : public SILInstruction
   }
 };
 
+/// Test that an address or reference type is not null.
+class IsNonnullInst : public UnaryInstructionBase<ValueKind::IsNonnullInst> {
+public:
+  IsNonnullInst(SILLocation Loc, SILValue Operand, SILType BoolTy)
+    : UnaryInstructionBase(Loc, Operand, BoolTy) {}
+};
+
 /// Perform an unconditional checked cast that aborts if the cast fails.
 class UnconditionalCheckedCastInst
   : public UnaryInstructionBase<ValueKind::UnconditionalCheckedCastInst,

include/swift/SIL/SILNodes.def

@@ -196,6 +196,7 @@ ABSTRACT_VALUE(SILInstruction, ValueBase)
     INST(ObjCExistentialMetatypeToObjectInst, ConversionInst, None)
     INST(UnconditionalCheckedCastInst, ConversionInst, None)
     VALUE_RANGE(ConversionInst, UpcastInst, UnconditionalCheckedCastInst)
+  INST(IsNonnullInst, SILInstruction, None)
   INST(UnconditionalCheckedCastAddrInst, SILInstruction, MayReadWrite)
 
   // Runtime failure

lib/IRGen/IRGenSIL.cpp

@@ -694,6 +694,8 @@ class IRGenSILFunction :
   void visitObjCExistentialMetatypeToObjectInst(
                                         ObjCExistentialMetatypeToObjectInst *i);
 
+  void visitIsNonnullInst(IsNonnullInst *i);
+
   void visitIndexAddrInst(IndexAddrInst *i);
   void visitIndexRawPointerInst(IndexRawPointerInst *i);
 
@@ -3069,6 +3071,33 @@ void IRGenSILFunction::visitCheckedCastAddrBranchInst(
                        getLoweredBB(i->getFailureBB()).bb);
 }
 
+void IRGenSILFunction::visitIsNonnullInst(swift::IsNonnullInst *i) {
+  // Get the value we're testing, which may be a function, an address or an
+  // instance pointer.
+  llvm::Value *val;
+  const LoweredValue &lv = getLoweredValue(i->getOperand());
+  
+  if (i->getOperand().getType().getSwiftType()->is<SILFunctionType>()) {
+    Explosion values = lv.getExplosion(*this);
+    val = values.claimNext();   // Function pointer.
+    values.claimNext();         // Ignore the data pointer.
+  } else if (lv.isAddress()) {
+    val = lv.getAddress().getAddress();
+  } else {
+    Explosion values = lv.getExplosion(*this);
+    val = values.claimNext();
+  }
+  
+  // Check that the result isn't null.
+  auto *valTy = cast<llvm::PointerType>(val->getType());
+  llvm::Value *result = Builder.CreateICmp(llvm::CmpInst::ICMP_NE,
+                                    val, llvm::ConstantPointerNull::get(valTy));
+  
+  Explosion out;
+  out.add(result);
+  setLoweredExplosion(SILValue(i, 0), out);
+}
+
 void IRGenSILFunction::visitUpcastInst(swift::UpcastInst *i) {
   auto toTy = getTypeInfo(i->getType()).getStorageType();
 

lib/Parse/ParseSIL.cpp

@@ -1169,6 +1169,7 @@ bool SILParser::parseSILOpcode(ValueKind &Opcode, SourceLoc &OpcodeLoc,
     .Case("init_existential_ref", ValueKind::InitExistentialRefInst)
     .Case("inject_enum_addr", ValueKind::InjectEnumAddrInst)
     .Case("integer_literal", ValueKind::IntegerLiteralInst)
+    .Case("is_nonnull", ValueKind::IsNonnullInst)
     .Case("function_ref", ValueKind::FunctionRefInst)
     .Case("load", ValueKind::LoadInst)
     .Case("load_weak", ValueKind::LoadWeakInst)
@@ -2504,6 +2505,13 @@ bool SILParser::parseSILInstruction(SILBasicBlock *BB) {
     ResultVal = B.createRefElementAddr(InstLoc, Val, Field, ResultTy);
     break;
   }
+  case ValueKind::IsNonnullInst: {
+    SourceLoc Loc;
+    if (parseTypedValueRef(Val, Loc))
+      return true;
+    ResultVal = B.createIsNonnull(InstLoc, Val);
+    break;
+  }
   case ValueKind::IndexAddrInst: {
     SILValue IndexVal;
     if (parseTypedValueRef(Val) ||

lib/SIL/SILPrinter.cpp

@@ -860,6 +860,10 @@ class SILPrinter : public SILVisitor<SILPrinter> {
        << " : " << CI->getType();
   }
 
+  void visitIsNonnullInst(IsNonnullInst *I) {
+    OS << "is_nonnull " << getIDAndType(I->getOperand());
+  }
+  
   void visitRetainValueInst(RetainValueInst *I) {
     OS << "retain_value " << getIDAndType(I->getOperand());
   }

lib/SIL/Verifier.cpp

@@ -1649,6 +1649,13 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     }
   }
 
+  void checkIsNonnullInst(IsNonnullInst *II) {
+    // The operand must be a function type or a class type.
+    auto OpTy = II->getOperand().getType().getSwiftType();
+    require(OpTy->mayHaveSuperclass() || OpTy->is<SILFunctionType>(),
+            "is_nonnull operand must be a class or function type");
+  }
+
   void checkAddressToPointerInst(AddressToPointerInst *AI) {
     require(AI->getOperand().getType().isAddress(),
             "address-to-pointer operand must be an address");

lib/SILAnalysis/ValueTracking.cpp

@@ -87,6 +87,7 @@ static bool isTransitiveEscapeInst(SILInstruction *Inst) {
   case ValueKind::InjectEnumAddrInst:
   case ValueKind::DeinitExistentialInst:
   case ValueKind::UnreachableInst:
+  case ValueKind::IsNonnullInst:
   case ValueKind::CondFailInst:
   case ValueKind::DynamicMethodBranchInst:
   case ValueKind::ReturnInst:

lib/SILPasses/Utils/SILInliner.cpp

@@ -365,6 +365,7 @@ static InlineCost instructionInlineCost(SILInstruction &I,
     case ValueKind::InitExistentialInst:
     case ValueKind::InitExistentialRefInst:
     case ValueKind::InjectEnumAddrInst:
+    case ValueKind::IsNonnullInst:
     case ValueKind::LoadInst:
     case ValueKind::LoadWeakInst:
     case ValueKind::OpenExistentialInst:

lib/Serialization/DeserializeSIL.cpp

@@ -1030,6 +1030,7 @@ bool SILDeserializer::readSILInstruction(SILFunction *Fn, SILBasicBlock *BB,
   UNARY_INSTRUCTION(AutoreleaseValue)
   UNARY_INSTRUCTION(DeinitExistential)
   UNARY_INSTRUCTION(DestroyAddr)
+  UNARY_INSTRUCTION(IsNonnull)
   UNARY_INSTRUCTION(Load)
   UNARY_INSTRUCTION(Return)
   UNARY_INSTRUCTION(FixLifetime)

lib/Serialization/SerializeSIL.cpp

@@ -650,6 +650,7 @@ void SILSerializer::writeSILInstruction(const SILInstruction &SI) {
   case ValueKind::DeallocRefInst:
   case ValueKind::DeinitExistentialInst:
   case ValueKind::DestroyAddrInst:
+  case ValueKind::IsNonnullInst:
   case ValueKind::LoadInst:
   case ValueKind::LoadWeakInst:
   case ValueKind::MarkUninitializedInst:

test/IRGen/function_types.sil

@@ -70,3 +70,16 @@ entry(%x : $*X):
   return %z : $()
 }
 
+// CHECK-LABEL: define i1 @test_is_nonnull_function(i8*, %swift.refcounted*) {
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:  %2 = icmp ne i8* %0, null
+// CHECK-NEXT:  ret i1 %2
+// CHECK-NEXT:  }
+
+sil @test_is_nonnull_function : $@thin (() -> ()) -> Builtin.Int1 {
+bb0(%0 : $() -> ()):
+  %3 = is_nonnull %0 : $() -> ()
+  return %3 : $Builtin.Int1                                 // id: %5
+}
+
+

utils/sil-mode.el

@@ -108,7 +108,7 @@
                     "ref_to_raw_pointer" "raw_pointer_to_ref"
                     "convert_function"
                     "thick_to_objc_metatype" "objc_to_thick_metatype"
-                    "thin_to_thick_function"
+                    "thin_to_thick_function" "is_nonnull"
                     "unchecked_ref_bit_cast" "unchecked_trivial_bit_cast")
                   'words) . font-lock-keyword-face)
    ;; Checked Conversions

utils/vim/syntax/sil.vim

@@ -33,7 +33,7 @@ syn keyword swiftKeyword metatype value_metatype existential_metatype skipwhite
 syn keyword swiftKeyword retain_value release_value tuple tuple_extract tuple_element_addr struct struct_extract struct_element_addr ref_element_addr skipwhite
 syn keyword swiftKeyword init_enum_data_addr unchecked_enum_data unchecked_take_enum_data_addr inject_enum_addr skipwhite
 syn keyword swiftKeyword init_existential upcast_existential deinit_existential project_existential open_existential init_existential_ref upcast_existential_ref project_existential_ref open_existential_ref skipwhite
-syn keyword swiftKeyword upcast address_to_pointer pointer_to_address unchecked_addr_cast unchecked_ref_cast ref_to_raw_pointer raw_pointer_to_ref convert_function thick_to_objc_metatype objc_to_thick_metatype thin_to_thick_function unchecked_ref_bit_cast unchecked_trivial_bit_cast skipwhite
+syn keyword swiftKeyword upcast address_to_pointer pointer_to_address unchecked_addr_cast unchecked_ref_cast ref_to_raw_pointer raw_pointer_to_ref convert_function thick_to_objc_metatype objc_to_thick_metatype thin_to_thick_function is_nonnull unchecked_ref_bit_cast unchecked_trivial_bit_cast skipwhite
 syn keyword swiftKeyword unconditional_checked_cast skipwhite
 syn keyword swiftKeyword cond_fail skipwhite
 syn keyword swiftKeyword unreachable return autorelease_return br cond_br switch_int switch_enum switch_enum_addr dynamic_method_br checked_cast_br skipwhite