SIL: remove unused instructions thin_function_to_pointer and pointer_to_thin_function

Author: eeckstein

docs/SIL.rst

@@ -6632,16 +6632,6 @@ passed to a function (materializeForSet) which escapes the closure in a way not
 expressed by the convert's users. The mandatory pass must ensure the lifetime
 in a conservative way.
 
-thin_function_to_pointer
-````````````````````````
-
-TODO
-
-pointer_to_thin_function
-````````````````````````
-
-TODO
-
 classify_bridge_object
 ``````````````````````
 ::

include/swift/SIL/SILBuilder.h

@@ -1060,18 +1060,6 @@ class SILBuilder {
         lifetimeGuaranteed));
   }
 
-  ThinFunctionToPointerInst *
-  createThinFunctionToPointer(SILLocation Loc, SILValue Op, SILType Ty) {
-    return insert(new (getModule()) ThinFunctionToPointerInst(
-        getSILDebugLocation(Loc), Op, Ty));
-  }
-
-  PointerToThinFunctionInst *
-  createPointerToThinFunction(SILLocation Loc, SILValue Op, SILType Ty) {
-    return insert(PointerToThinFunctionInst::create(
-        getSILDebugLocation(Loc), Op, Ty, getFunction()));
-  }
-
   UpcastInst *createUpcast(SILLocation Loc, SILValue Op, SILType Ty) {
     return createUpcast(Loc, Op, Ty, Op.getOwnershipKind());
   }

include/swift/SIL/SILCloner.h

@@ -1434,26 +1434,6 @@ void SILCloner<ImplClass>::visitConvertEscapeToNoEscapeInst(
                 getOpType(Inst->getType()), Inst->isLifetimeGuaranteed()));
 }
 
-template<typename ImplClass>
-void SILCloner<ImplClass>::visitThinFunctionToPointerInst(
-                                           ThinFunctionToPointerInst *Inst) {
-  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-  recordClonedInstruction(Inst, getBuilder().createThinFunctionToPointer(
-                                    getOpLocation(Inst->getLoc()),
-                                    getOpValue(Inst->getOperand()),
-                                    getOpType(Inst->getType())));
-}
-
-template<typename ImplClass>
-void SILCloner<ImplClass>::visitPointerToThinFunctionInst(
-                                           PointerToThinFunctionInst *Inst) {
-  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
-  recordClonedInstruction(Inst, getBuilder().createPointerToThinFunction(
-                                    getOpLocation(Inst->getLoc()),
-                                    getOpValue(Inst->getOperand()),
-                                    getOpType(Inst->getType())));
-}
-
 template<typename ImplClass>
 void
 SILCloner<ImplClass>::visitUpcastInst(UpcastInst *Inst) {

include/swift/SIL/SILInstruction.h

@@ -5241,39 +5241,6 @@ class ConvertEscapeToNoEscapeInst final
   void setLifetimeGuaranteed() { lifetimeGuaranteed = true; }
 };
 
-/// ThinFunctionToPointerInst - Convert a thin function pointer to a
-/// Builtin.RawPointer.
-class ThinFunctionToPointerInst
-  : public UnaryInstructionBase<SILInstructionKind::ThinFunctionToPointerInst,
-                                ConversionInst>
-{
-  friend SILBuilder;
-
-  ThinFunctionToPointerInst(SILDebugLocation DebugLoc, SILValue operand,
-                            SILType ty)
-      : UnaryInstructionBase(DebugLoc, operand, ty) {}
-};
-
-/// PointerToThinFunctionInst - Convert a Builtin.RawPointer to a thin
-/// function pointer.
-class PointerToThinFunctionInst final
-    : public UnaryInstructionWithTypeDependentOperandsBase<
-          SILInstructionKind::PointerToThinFunctionInst,
-          PointerToThinFunctionInst,
-          ConversionInst> {
-  friend SILBuilder;
-
-  PointerToThinFunctionInst(SILDebugLocation DebugLoc, SILValue operand,
-                            ArrayRef<SILValue> TypeDependentOperands,
-                            SILType ty)
-      : UnaryInstructionWithTypeDependentOperandsBase(
-            DebugLoc, operand, TypeDependentOperands, ty) {}
-
-  static PointerToThinFunctionInst *
-  create(SILDebugLocation DebugLoc, SILValue Operand, SILType Ty,
-         SILFunction &F);
-};
-
 /// UpcastInst - Perform a conversion of a class instance to a supertype.
 class UpcastInst final : public UnaryInstructionWithTypeDependentOperandsBase<
                              SILInstructionKind::UpcastInst, UpcastInst,

include/swift/SIL/SILNode.h

@@ -367,7 +367,6 @@ class alignas(8) SILNode :
 
   UIWTDOB_BITFIELD(ConvertFunctionInst, ConversionInst, 1,
                    WithoutActuallyEscaping : 1);
-  UIWTDOB_BITFIELD_EMPTY(PointerToThinFunctionInst, ConversionInst);
   UIWTDOB_BITFIELD_EMPTY(UnconditionalCheckedCastInst, ConversionInst);
   UIWTDOB_BITFIELD_EMPTY(UpcastInst, ConversionInst);
   UIWTDOB_BITFIELD_EMPTY(UncheckedRefCastInst, ConversionInst);

include/swift/SIL/SILNodes.def

@@ -405,10 +405,6 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
                       ConversionInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(ConvertEscapeToNoEscapeInst, convert_escape_to_noescape,
                       ConversionInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST(ThinFunctionToPointerInst, thin_function_to_pointer,
-                      ConversionInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST(PointerToThinFunctionInst, pointer_to_thin_function,
-                      ConversionInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(RefToBridgeObjectInst, ref_to_bridge_object,
                       ConversionInst, None, DoesNotRelease)
     BRIDGED_SINGLE_VALUE_INST(BridgeObjectToRefInst, bridge_object_to_ref,

include/swift/SIL/SILNodes.def.rej

@@ -0,0 +1,19 @@
+***************
+*** 405,414 ****
+                        ConversionInst, None, DoesNotRelease)
+      SINGLE_VALUE_INST(ConvertEscapeToNoEscapeInst, convert_escape_to_noescape,
+                        ConversionInst, None, DoesNotRelease)
+-     SINGLE_VALUE_INST(ThinFunctionToPointerInst, thin_function_to_pointer,
+-                       ConversionInst, None, DoesNotRelease)
+-     SINGLE_VALUE_INST(PointerToThinFunctionInst, pointer_to_thin_function,
+-                       ConversionInst, None, DoesNotRelease)
+      BRIDGED_SINGLE_VALUE_INST(RefToBridgeObjectInst, ref_to_bridge_object,
+                        ConversionInst, None, DoesNotRelease)
+      BRIDGED_SINGLE_VALUE_INST(BridgeObjectToRefInst, bridge_object_to_ref,
+--- 405,410 ----
+                        ConversionInst, None, DoesNotRelease)
+      SINGLE_VALUE_INST(ConvertEscapeToNoEscapeInst, convert_escape_to_noescape,
+                        ConversionInst, None, DoesNotRelease)
+      BRIDGED_SINGLE_VALUE_INST(RefToBridgeObjectInst, ref_to_bridge_object,
+                        ConversionInst, None, DoesNotRelease)
+      BRIDGED_SINGLE_VALUE_INST(BridgeObjectToRefInst, bridge_object_to_ref,

lib/IRGen/IRGenSIL.cpp

@@ -1311,8 +1311,6 @@ class IRGenSILFunction :
 
   void visitConvertFunctionInst(ConvertFunctionInst *i);
   void visitConvertEscapeToNoEscapeInst(ConvertEscapeToNoEscapeInst *i);
-  void visitThinFunctionToPointerInst(ThinFunctionToPointerInst *i);
-  void visitPointerToThinFunctionInst(PointerToThinFunctionInst *i);
   void visitUpcastInst(UpcastInst *i);
   void visitAddressToPointerInst(AddressToPointerInst *i);
   void visitPointerToAddressInst(PointerToAddressInst *i);
@@ -5856,26 +5854,6 @@ void IRGenSILFunction::visitConvertEscapeToNoEscapeInst(
   setLoweredExplosion(i, out);
 }
 
-void IRGenSILFunction::visitThinFunctionToPointerInst(
-                                          swift::ThinFunctionToPointerInst *i) {
-  Explosion in = getLoweredExplosion(i->getOperand());
-  llvm::Value *fn = in.claimNext();
-  fn = Builder.CreateBitCast(fn, IGM.Int8PtrTy);
-  Explosion out;
-  out.add(fn);
-  setLoweredExplosion(i, out);
-}
-
-void IRGenSILFunction::visitPointerToThinFunctionInst(
-                                          swift::PointerToThinFunctionInst *i) {
-  Explosion in = getLoweredExplosion(i->getOperand());
-  llvm::Value *fn = in.claimNext();
-  fn = Builder.CreateBitCast(fn, IGM.FunctionPtrTy);
-  Explosion out;
-  out.add(fn);
-  setLoweredExplosion(i, out);
-}
-
 void IRGenSILFunction::visitAddressToPointerInst(swift::AddressToPointerInst *i)
 {
   Explosion to;

lib/IRGen/LoadableByAddress.cpp

@@ -2782,9 +2782,6 @@ bool LoadableByAddress::recreateConvInstr(SILInstruction &I,
   IRGenModule *currIRMod =
       getIRGenModule()->IRGen.getGenModule(convInstr->getFunction());
   SILType currSILType = convInstr->getType();
-  if (auto *thinToPointer = dyn_cast<ThinFunctionToPointerInst>(convInstr)) {
-    currSILType = thinToPointer->getOperand()->getType();
-  }
   auto currSILFunctionType = currSILType.castTo<SILFunctionType>();
   GenericEnvironment *genEnv =
     getSubstGenericEnvironment(convInstr->getFunction());
@@ -2813,14 +2810,6 @@ bool LoadableByAddress::recreateConvInstr(SILInstruction &I,
         instr->getLoc(), instr->getOperand(), newType);
     break;
   }
-  case SILInstructionKind::ThinFunctionToPointerInst: {
-    auto instr = cast<ThinFunctionToPointerInst>(convInstr);
-    newType =
-        MapperCache.getNewSILType(genEnv, instr->getType(), *getIRGenModule());
-    newInstr = convBuilder.createThinFunctionToPointer(
-        instr->getLoc(), instr->getOperand(), newType);
-    break;
-  }
   case SILInstructionKind::ConvertFunctionInst: {
     auto instr = cast<ConvertFunctionInst>(convInstr);
     newInstr = convBuilder.createConvertFunction(
@@ -2956,7 +2945,6 @@ void LoadableByAddress::run() {
               case SILInstructionKind::ConvertFunctionInst:
               case SILInstructionKind::ConvertEscapeToNoEscapeInst:
               case SILInstructionKind::MarkDependenceInst:
-              case SILInstructionKind::ThinFunctionToPointerInst:
               case SILInstructionKind::ThinToThickFunctionInst:
               case SILInstructionKind::DifferentiableFunctionInst:
               case SILInstructionKind::LinearFunctionInst:

lib/SIL/IR/OperandOwnership.cpp

@@ -171,7 +171,6 @@ OPERAND_OWNERSHIP(TrivialUse, ObjCToThickMetatype)
 OPERAND_OWNERSHIP(TrivialUse, OpenExistentialAddr)
 OPERAND_OWNERSHIP(TrivialUse, OpenExistentialMetatype)
 OPERAND_OWNERSHIP(TrivialUse, PointerToAddress)
-OPERAND_OWNERSHIP(TrivialUse, PointerToThinFunction)
 OPERAND_OWNERSHIP(TrivialUse, ProjectBlockStorage)
 OPERAND_OWNERSHIP(TrivialUse, RawPointerToRef)
 OPERAND_OWNERSHIP(TrivialUse, SelectEnumAddr)
@@ -180,7 +179,6 @@ OPERAND_OWNERSHIP(TrivialUse, SwitchEnumAddr)
 OPERAND_OWNERSHIP(TrivialUse, SwitchValue)
 OPERAND_OWNERSHIP(TrivialUse, TailAddr)
 OPERAND_OWNERSHIP(TrivialUse, ThickToObjCMetatype)
-OPERAND_OWNERSHIP(TrivialUse, ThinFunctionToPointer)
 OPERAND_OWNERSHIP(TrivialUse, ThinToThickFunction)
 OPERAND_OWNERSHIP(TrivialUse, TupleElementAddr)
 OPERAND_OWNERSHIP(TrivialUse, UncheckedAddrCast)