libswift: bridge more functions from SILBuilder

MaxDesiatov · MaxDesiatov · commit 7d961001d318 · 2022-01-19T18:51:18.000Z
diff --git a/SwiftCompilerSources/Sources/AST/SubstitutionMap.swift b/SwiftCompilerSources/Sources/AST/SubstitutionMap.swift
@@ -13,7 +13,7 @@
 import SILBridging
 
 public struct SubstitutionMap {
-  let bridged: BridgedSubstitutionMap
+  public let bridged: BridgedSubstitutionMap
 
   public init(_ bridged: BridgedSubstitutionMap) {
     self.bridged = bridged
diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/PassUtils.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/PassUtils.swift
@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import AST
 import SIL
 import OptimizerBridging
 
@@ -115,6 +116,14 @@ struct PassContext {
   func fixStackNesting(function: Function) {
     PassContext_fixStackNesting(_bridged, function.bridged)
   }
+
+  func getDeallocRef(for type: Type) -> Function? {
+    PassContext_getDeallocRef(_bridged, type.bridged).function
+  }
+
+  func getContextSubstitutionMap(for type: Type) -> SubstitutionMap {
+    SubstitutionMap(PassContext_getContextSubstitutionMap(_bridged, type.bridged))
+  }
 }
 
 struct FunctionPass {
diff --git a/SwiftCompilerSources/Sources/SIL/Builder.swift b/SwiftCompilerSources/Sources/SIL/Builder.swift
@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import AST
 import SILBridging
 
 /// A utility to create new instructions at a given insertion point.
@@ -73,4 +74,42 @@ public struct Builder {
     let dr = SILBuilder_createDeallocStackRef(bridgedInsPoint, location.bridgedLocation, operand.bridged)
     return dr.getAs(DeallocStackRefInst.self)
   }
+
+  public func createUncheckedRefCast(object: Value, type: Type) -> UncheckedRefCastInst {
+    notifyInstructionsChanged()
+    let object = SILBuilder_createUncheckedRefCast(
+      bridgedInsPoint, location.bridgedLocation, object.bridged, type.bridged)
+    return object.getAs(UncheckedRefCastInst.self)
+  }
+
+  @discardableResult
+  public func createSetDeallocating(operand: Value, isAtomic: Bool) -> SetDeallocatingInst {
+    notifyInstructionsChanged()
+    let setDeallocating = SILBuilder_createSetDeallocating(
+      bridgedInsPoint, location.bridgedLocation, operand.bridged, isAtomic)
+    return setDeallocating.getAs(SetDeallocatingInst.self)
+  }
+
+  public func createFunctionRef(_ function: Function) -> FunctionRefInst {
+    notifyInstructionsChanged()
+    let functionRef = SILBuilder_createFunctionRef(
+      bridgedInsPoint, location.bridgedLocation, function.bridged)
+    return functionRef.getAs(FunctionRefInst.self)
+  }
+
+  @discardableResult
+  public func createApply(
+    function: Value,
+    _ substitutionMap: SubstitutionMap,
+    arguments: [Value]
+  ) -> FunctionRefInst {
+    notifyInstructionsChanged()
+    let functionRef = arguments.withBridgedValues { valuesRef in
+      SILBuilder_createApply(
+        bridgedInsPoint, location.bridgedLocation, function.bridged,
+        substitutionMap.bridged, valuesRef
+      )
+    }
+    return functionRef.getAs(FunctionRefInst.self)
+  }
 }
diff --git a/SwiftCompilerSources/Sources/SIL/Function.swift b/SwiftCompilerSources/Sources/SIL/Function.swift
@@ -59,3 +59,7 @@ public func != (lhs: Function, rhs: Function) -> Bool { lhs !== rhs }
 extension BridgedFunction {
   public var function: Function { obj.getAs(Function.self) }
 }
+
+extension OptionalBridgedFunction {
+  public var function: Function? { obj.getAs(Function.self) }
+}
diff --git a/SwiftCompilerSources/Sources/SIL/Type.swift b/SwiftCompilerSources/Sources/SIL/Type.swift
@@ -13,7 +13,7 @@
 import SILBridging
 
 public struct Type {
-  var bridged: BridgedType
+  public let bridged: BridgedType
 
   public var isAddress: Bool { SILType_isAddress(bridged) != 0 }
   public var isObject: Bool { !isAddress }
diff --git a/SwiftCompilerSources/Sources/SIL/Utils.swift b/SwiftCompilerSources/Sources/SIL/Utils.swift
@@ -219,4 +219,3 @@ extension Optional where Wrapped == UnsafeMutablePointer<BridgedSwiftObject> {
     return nil
   }
 }
-
diff --git a/SwiftCompilerSources/Sources/SIL/Value.swift b/SwiftCompilerSources/Sources/SIL/Value.swift
@@ -24,11 +24,11 @@ extension Value {
   }
 
   public var uses: UseList {
-    return UseList(SILValue_firstUse(bridged))
+    UseList(SILValue_firstUse(bridged))
   }
 
   public var type: Type {
-    return Type(bridged: SILValue_getType(bridged))
+    Type(bridged: SILValue_getType(bridged))
   }
 
   public var hashable: HashableValue { ObjectIdentifier(self) }
@@ -48,7 +48,7 @@ public func ==(_ lhs: Value, _ rhs: Value) -> Bool {
 }
 
 extension BridgedValue {
-  func getAs<T: AnyObject>(_ valueType: T.Type) -> T { obj.getAs(T.self) }
+  public func getAs<T: AnyObject>(_ valueType: T.Type) -> T { obj.getAs(T.self) }
 }
 
 final class Undef : Value {
diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h
@@ -252,6 +252,22 @@ BridgedInstruction SILBuilder_createIntegerLiteral(BridgedInstruction insertionP
           BridgedLocation loc, BridgedType type, SwiftInt value);
 BridgedInstruction SILBuilder_createDeallocStackRef(BridgedInstruction insertionPoint,
           BridgedLocation loc, BridgedValue operand);
+BridgedInstruction SILBuilder_createUncheckedRefCast(BridgedInstruction insertionPoint,
+                                                     BridgedLocation loc,
+                                                     BridgedValue op,
+                                                     BridgedType type);
+BridgedInstruction
+SILBuilder_createSetDeallocating(BridgedInstruction insertionPoint,
+                                 BridgedLocation loc, BridgedValue op,
+                                 bool isAtomic);
+BridgedInstruction
+SILBuilder_createFunctionRef(BridgedInstruction insertionPoint,
+                             BridgedLocation loc, BridgedFunction function);
+BridgedInstruction SILBuilder_createApply(BridgedInstruction insertionPoint,
+                                          BridgedLocation loc,
+                                          BridgedValue function,
+                                          BridgedSubstitutionMap subMap,
+                                          BridgedValueArray arguments);
 
 SWIFT_END_NULLABILITY_ANNOTATIONS
 
diff --git a/include/swift/SIL/SILBridgingUtils.h b/include/swift/SIL/SILBridgingUtils.h
@@ -74,6 +74,10 @@ inline SILType castToSILType(BridgedType type) {
   return SILType::getFromOpaqueValue(type.typePtr);
 }
 
+inline SubstitutionMap castToSubstitutionMap(BridgedSubstitutionMap subMap) {
+  return SubstitutionMap::getFromOpaqueValue(subMap.op);
+}
+
 template <class I = SILInstruction> I *castToInst(BridgedInstruction inst) {
   return cast<I>(static_cast<SILNode *>(inst.obj)->castToInstruction());
 }
diff --git a/include/swift/SILOptimizer/OptimizerBridging.h b/include/swift/SILOptimizer/OptimizerBridging.h
@@ -151,9 +151,13 @@ RCIdentityAnalysis_getFunctionInfo(BridgedRCIdentityAnalysis bridgedAnalysis,
 BridgedValue RCIdentityFunctionInfo_getRCIdentityRoot(
     BridgedRCIdentityFunctionInfo bridgedInfo, BridgedValue value);
 
-OptionalBridgedFunction PassContext_getDestructor(BridgedPassContext context,
+OptionalBridgedFunction PassContext_getDeallocRef(BridgedPassContext context,
                                                   BridgedType type);
 
+BridgedSubstitutionMap
+PassContext_getContextSubstitutionMap(BridgedPassContext context,
+                                      BridgedType bridgedType);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/lib/SIL/Utils/SILBridging.cpp b/lib/SIL/Utils/SILBridging.cpp
@@ -93,7 +93,7 @@ void registerBridgedClass(BridgedStringRef className, SwiftMetatype metatype) {
   }
 
   // Pre-populate the "unimplemented" ranges of metatypes.
-  // If a specifc class is not implemented in Swift yet, it bridges to an
+  // If a specific class is not implemented in Swift yet, it bridges to an
   // "unimplemented" class. This ensures that optimizations handle _all_ kind of
   // instructions gracefully, without the need to define the not-yet-used
   // classes in Swift.
@@ -541,3 +541,45 @@ BridgedInstruction SILBuilder_createDeallocStackRef(BridgedInstruction insertion
   return {builder.createDeallocStackRef(getRegularLocation(loc),
                                         castToSILValue(operand))};
 }
+
+BridgedInstruction
+SILBuilder_createUncheckedRefCast(BridgedInstruction insertionPoint,
+                                  BridgedLocation loc, BridgedValue op,
+                                  BridgedType type) {
+  SILBuilder builder(castToInst(insertionPoint), getSILDebugScope(loc));
+  return {builder.createUncheckedRefCast(getRegularLocation(loc),
+                                         castToSILValue(op), getSILType(type))};
+}
+
+BridgedInstruction
+SILBuilder_createSetDeallocating(BridgedInstruction insertionPoint,
+                                 BridgedLocation loc, BridgedValue op,
+                                 bool isAtomic) {
+  SILBuilder builder(castToInst(insertionPoint), getSILDebugScope(loc));
+  return {builder.createSetDeallocating(
+      getRegularLocation(loc), castToSILValue(op),
+      isAtomic ? RefCountingInst::Atomicity::Atomic
+               : RefCountingInst::Atomicity::NonAtomic)};
+}
+
+BridgedInstruction
+SILBuilder_createFunctionRef(BridgedInstruction insertionPoint,
+                             BridgedLocation loc,
+                             BridgedFunction function) {
+  SILBuilder builder(castToInst(insertionPoint), getSILDebugScope(loc));
+  return {builder.createFunctionRef(getRegularLocation(loc),
+                                    castToFunction(function))};
+}
+
+BridgedInstruction SILBuilder_createApply(BridgedInstruction insertionPoint,
+                                          BridgedLocation loc,
+                                          BridgedValue function,
+                                          BridgedSubstitutionMap subMap,
+                                          BridgedValueArray arguments) {
+  SILBuilder builder(castToInst(insertionPoint), getSILDebugScope(loc));
+  SmallVector<SILValue, 16> argValues;
+  return {builder.createApply(getRegularLocation(loc), castToSILValue(function),
+                              castToSubstitutionMap(subMap),
+                              getSILValues(arguments, argValues))};
+}
+
diff --git a/lib/SILOptimizer/PassManager/PassManager.cpp b/lib/SILOptimizer/PassManager/PassManager.cpp
@@ -1320,13 +1320,15 @@ BridgedFunction BasicBlockSet_getFunction(BridgedBasicBlockSet set) {
 
 void AllocRefInstBase_setIsStackAllocatable(BridgedInstruction arb) {
   castToInst<AllocRefInstBase>(arb)->setStackAllocatable();
+}
+
 BridgedRCIdentityAnalysis
 PassContext_getRCIdentityAnalysis(BridgedPassContext context) {
   SILPassManager *pm = castToPassInvocation(context)->getPassManager();
   return {pm->getAnalysis<RCIdentityAnalysis>()};
 }
 
-OptionalBridgedFunction PassContext_getDestructor(BridgedPassContext context,
+OptionalBridgedFunction PassContext_getDeallocRef(BridgedPassContext context,
                                                   BridgedType type) {
   auto *cd = castToSILType(type).getClassOrBoundGenericClass();
   assert(cd && "no class type allocated with alloc_ref");

Original file line number	Diff line number	Diff line change
`@@ -59,3 +59,7 @@ public func != (lhs: Function, rhs: Function) -> Bool { lhs !== rhs }`
`59`	`59`	`extension BridgedFunction {`
`60`	`60`	`public var function: Function { obj.getAs(Function.self) }`
`61`	`61`	`}`
	`62`	`+`
	`63`	`+extension OptionalBridgedFunction {`
	`64`	`+ public var function: Function? { obj.getAs(Function.self) }`
	`65`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -219,4 +219,3 @@ extension Optional where Wrapped == UnsafeMutablePointer<BridgedSwiftObject> {`
`219`	`219`	`return nil`
`220`	`220`	`}`
`221`	`221`	`}`
`222`		`-`
Original file line number	Diff line number	Diff line change
`@@ -24,11 +24,11 @@ extension Value {`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`public var uses: UseList {`
`27`		`- return UseList(SILValue_firstUse(bridged))`
	`27`	`+ UseList(SILValue_firstUse(bridged))`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`public var type: Type {`
`31`		`- return Type(bridged: SILValue_getType(bridged))`
	`31`	`+ Type(bridged: SILValue_getType(bridged))`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`public var hashable: HashableValue { ObjectIdentifier(self) }`
`@@ -48,7 +48,7 @@ public func ==(_ lhs: Value, _ rhs: Value) -> Bool {`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`extension BridgedValue {`
`51`		`- func getAs<T: AnyObject>(_ valueType: T.Type) -> T { obj.getAs(T.self) }`
	`51`	`+ public func getAs<T: AnyObject>(_ valueType: T.Type) -> T { obj.getAs(T.self) }`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`final class Undef : Value {`
Original file line number	Diff line number	Diff line change
`@@ -74,6 +74,10 @@ inline SILType castToSILType(BridgedType type) {`
`74`	`74`	`return SILType::getFromOpaqueValue(type.typePtr);`
`75`	`75`	`}`
`76`	`76`
	`77`	`+inline SubstitutionMap castToSubstitutionMap(BridgedSubstitutionMap subMap) {`
	`78`	`+ return SubstitutionMap::getFromOpaqueValue(subMap.op);`
	`79`	`+}`
	`80`	`+`
`77`	`81`	`template <class I = SILInstruction> I *castToInst(BridgedInstruction inst) {`
`78`	`82`	`return cast<I>(static_cast<SILNode *>(inst.obj)->castToInstruction());`
`79`	`83`	`}`