Swift SIL: add a few utilities and instructions

eeckstein · eeckstein · commit 24b62d4d7c42 · 2022-01-12T15:47:15.000+01:00
* instructions: function_ref, mark_dependence
* add `BuiltinInst.id`
* add isObjC and canAllocOnStack for alloc_ref and alloc_ref_dynamic
* add `ApplySite::referencedFunction`
* add `Builder.createDeallocStackRef`
* add == and != operators for `Function`
* add `List.first` and `ReverseList.first`
diff --git a/SwiftCompilerSources/Sources/SIL/ApplySite.swift b/SwiftCompilerSources/Sources/SIL/ApplySite.swift
@@ -36,6 +36,12 @@ extension ApplySite {
     return nil
   }
 
+  public var referencedFunction: Function? {
+    if let fri = callee as? FunctionRefInst {
+      return fri.referencedFunction
+    }
+    return nil
+  }
 }
 
 public protocol FullApplySite : ApplySite {
diff --git a/SwiftCompilerSources/Sources/SIL/Builder.swift b/SwiftCompilerSources/Sources/SIL/Builder.swift
@@ -67,4 +67,10 @@ public struct Builder {
       bridgedInsPoint, location.bridgedLocation, type.bridged, value)
     return literal.getAs(IntegerLiteralInst.self)
   }
+  
+  public func createDeallocStackRef(_ operand: Value) -> DeallocStackRefInst {
+    notifyInstructionsChanged()
+    let dr = SILBuilder_createDeallocStackRef(bridgedInsPoint, location.bridgedLocation, operand.bridged)
+    return dr.getAs(DeallocStackRefInst.self)
+  }
 }
diff --git a/SwiftCompilerSources/Sources/SIL/Function.swift b/SwiftCompilerSources/Sources/SIL/Function.swift
@@ -54,6 +54,9 @@ final public class Function : CustomStringConvertible {
   public var bridged: BridgedFunction { BridgedFunction(obj: SwiftObject(self)) }
 }
 
+public func == (lhs: Function, rhs: Function) -> Bool { lhs === rhs }
+public func != (lhs: Function, rhs: Function) -> Bool { lhs !== rhs }
+
 // Bridging utilities
 
 extension BridgedFunction {
diff --git a/SwiftCompilerSources/Sources/SIL/Instruction.swift b/SwiftCompilerSources/Sources/SIL/Instruction.swift
@@ -29,6 +29,8 @@ public class Instruction : ListNode, CustomStringConvertible, Hashable {
     SILInstruction_getParent(bridged).block
   }
 
+  final public var function: Function { block.function }
+
   final public var description: String {
     SILNode_debugDescription(bridgedNode).takeString()
   }
@@ -263,7 +265,19 @@ final public class LoadInst : SingleValueInstruction, UnaryInstruction {}
 
 final public class LoadBorrowInst : SingleValueInstruction, UnaryInstruction {}
 
-final public class BuiltinInst : SingleValueInstruction {}
+final public class BuiltinInst : SingleValueInstruction {
+  // TODO: find a way to directly reuse the BuiltinValueKind enum
+  public enum ID  {
+    case None
+    case DestroyArray
+  }
+  public var id: ID? {
+    switch BuiltinInst_getID(bridged) {
+      case DestroyArrayBuiltin: return .DestroyArray
+      default: return .None
+    }
+  }
+}
 
 final public class UpcastInst : SingleValueInstruction, UnaryInstruction {}
 
@@ -324,6 +338,12 @@ public class GlobalAccessInst : SingleValueInstruction {
   }
 }
 
+final public class FunctionRefInst : GlobalAccessInst {
+  public var referencedFunction: Function {
+    FunctionRefInst_getReferencedFunction(bridged).function
+  }
+}
+
 final public class GlobalAddrInst : GlobalAccessInst {}
 
 final public class GlobalValueInst : GlobalAccessInst {}
@@ -398,6 +418,12 @@ class ObjCMetatypeToObjectInst : SingleValueInstruction, UnaryInstruction {}
 final public
 class ValueToBridgeObjectInst : SingleValueInstruction, UnaryInstruction {}
 
+final public
+class MarkDependenceInst : SingleValueInstruction {
+  public var value: Value { return operands[0].value }
+  public var base: Value { return operands[1].value }
+}
+
 final public class BridgeObjectToRefInst : SingleValueInstruction,
                                            UnaryInstruction {}
 
@@ -442,10 +468,18 @@ public protocol Allocation : AnyObject { }
 final public class AllocStackInst : SingleValueInstruction, Allocation {
 }
 
-final public class AllocRefInst : SingleValueInstruction, Allocation {
+public class AllocRefInstBase : SingleValueInstruction, Allocation {
+  final public var isObjC: Bool { AllocRefInstBase_isObjc(bridged) != 0 }
+
+  final public var canAllocOnStack: Bool {
+    AllocRefInstBase_canAllocOnStack(bridged) != 0
+  }
+}
+
+final public class AllocRefInst : AllocRefInstBase {
 }
 
-final public class AllocRefDynamicInst : SingleValueInstruction, Allocation {
+final public class AllocRefDynamicInst : AllocRefInstBase {
 }
 
 final public class AllocBoxInst : SingleValueInstruction, Allocation {
diff --git a/SwiftCompilerSources/Sources/SIL/Registration.swift b/SwiftCompilerSources/Sources/SIL/Registration.swift
@@ -76,6 +76,7 @@ public func registerSILClasses() {
   register(OpenExistentialMetatypeInst.self)
   register(ValueMetatypeInst.self)
   register(ExistentialMetatypeInst.self)
+  register(FunctionRefInst.self)
   register(GlobalAddrInst.self)
   register(GlobalValueInst.self)
   register(IntegerLiteralInst.self)
@@ -96,6 +97,7 @@ public func registerSILClasses() {
   register(ObjCExistentialMetatypeToObjectInst.self)
   register(ObjCMetatypeToObjectInst.self)
   register(ValueToBridgeObjectInst.self)
+  register(MarkDependenceInst.self)
   register(BridgeObjectToRefInst.self)
   register(BeginAccessInst.self)
   register(BeginBorrowInst.self)
diff --git a/SwiftCompilerSources/Sources/SIL/Utils.swift b/SwiftCompilerSources/Sources/SIL/Utils.swift
@@ -37,6 +37,8 @@ public struct List<NodeType: ListNode> :
     return nil
   }
 
+  public var first: NodeType? { currentNode }
+
   public var customMirror: Mirror {
     let c: [Mirror.Child] = map { (label: nil, value: $0) }
     return Mirror(self, children: c)
@@ -58,6 +60,8 @@ public struct ReverseList<NodeType: ListNode> :
     return nil
   }
 
+  public var first: NodeType? { currentNode }
+
   public var customMirror: Mirror {
     let c: [Mirror.Child] = map { (label: nil, value: $0) }
     return Mirror(self, children: c)
diff --git a/include/swift/SIL/SILBridging.h b/include/swift/SIL/SILBridging.h
@@ -144,6 +144,11 @@ typedef enum {
   MayHaveSideEffectsBehavior
 } BridgedMemoryBehavior;
 
+typedef enum {
+  UnknownBuiltin = 0,
+#define BUILTIN(Id, Name, Attrs) Id##Builtin,
+#include "swift/AST/Builtins.def"
+} BridgedBuiltinID;
 
 typedef intptr_t SwiftInt;
 
@@ -217,7 +222,9 @@ BridgedMultiValueResult
 BridgedArrayRef TermInst_getSuccessors(BridgedInstruction term);
 
 BridgedStringRef CondFailInst_getMessage(BridgedInstruction cfi);
+BridgedBuiltinID BuiltinInst_getID(BridgedInstruction bi);
 BridgedGlobalVar GlobalAccessInst_getGlobal(BridgedInstruction globalInst);
+BridgedFunction FunctionRefInst_getReferencedFunction(BridgedInstruction fri);
 SwiftInt TupleExtractInst_fieldIndex(BridgedInstruction tei);
 SwiftInt TupleElementAddrInst_fieldIndex(BridgedInstruction teai);
 SwiftInt StructExtractInst_fieldIndex(BridgedInstruction sei);
@@ -227,6 +234,8 @@ SwiftInt UncheckedEnumDataInst_caseIndex(BridgedInstruction uedi);
 SwiftInt RefElementAddrInst_fieldIndex(BridgedInstruction reai);
 SwiftInt PartialApplyInst_numArguments(BridgedInstruction ai);
 SwiftInt ApplyInst_numArguments(BridgedInstruction ai);
+SwiftInt AllocRefInstBase_isObjc(BridgedInstruction arb);
+SwiftInt AllocRefInstBase_canAllocOnStack(BridgedInstruction arb);
 SwiftInt BeginApplyInst_numArguments(BridgedInstruction ai);
 SwiftInt TryApplyInst_numArguments(BridgedInstruction ai);
 BridgedBasicBlock BranchInst_getTargetBlock(BridgedInstruction bi);
@@ -243,6 +252,8 @@ BridgedInstruction SILBuilder_createCondFail(BridgedInstruction insertionPoint,
           BridgedLocation loc, BridgedValue condition, BridgedStringRef messge);
 BridgedInstruction SILBuilder_createIntegerLiteral(BridgedInstruction insertionPoint,
           BridgedLocation loc, BridgedType type, SwiftInt value);
+BridgedInstruction SILBuilder_createDeallocStackRef(BridgedInstruction insertionPoint,
+          BridgedLocation loc, BridgedValue operand);
 
 SWIFT_END_NULLABILITY_ANNOTATIONS
 
diff --git a/include/swift/SIL/SILNodes.def b/include/swift/SIL/SILNodes.def
@@ -457,7 +457,7 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
 
   // Literals
   ABSTRACT_SINGLE_VALUE_INST(LiteralInst, SingleValueInstruction)
-    SINGLE_VALUE_INST(FunctionRefInst, function_ref,
+    BRIDGED_SINGLE_VALUE_INST(FunctionRefInst, function_ref,
                       LiteralInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(DynamicFunctionRefInst, dynamic_function_ref,
                       LiteralInst, None, DoesNotRelease)
@@ -566,7 +566,7 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
                     SingleValueInstruction, None, DoesNotRelease)
   BRIDGED_SINGLE_VALUE_INST(ValueToBridgeObjectInst, value_to_bridge_object,
                     SingleValueInstruction, None, DoesNotRelease)
-  SINGLE_VALUE_INST(MarkDependenceInst, mark_dependence,
+  BRIDGED_SINGLE_VALUE_INST(MarkDependenceInst, mark_dependence,
                     SingleValueInstruction, None, DoesNotRelease)
   SINGLE_VALUE_INST(CopyBlockInst, copy_block,
                     SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
diff --git a/lib/SIL/Utils/SILBridging.cpp b/lib/SIL/Utils/SILBridging.cpp
@@ -419,10 +419,18 @@ BridgedStringRef CondFailInst_getMessage(BridgedInstruction cfi) {
   return getBridgedStringRef(castToInst<CondFailInst>(cfi)->getMessage());
 }
 
+BridgedBuiltinID BuiltinInst_getID(BridgedInstruction bi) {
+  return (BridgedBuiltinID)castToInst<BuiltinInst>(bi)->getBuiltinInfo().ID;
+}
+
 BridgedGlobalVar GlobalAccessInst_getGlobal(BridgedInstruction globalInst) {
   return {castToInst<GlobalAccessInst>(globalInst)->getReferencedGlobal()};
 }
 
+BridgedFunction FunctionRefInst_getReferencedFunction(BridgedInstruction fri) {
+  return {castToInst<FunctionRefInst>(fri)->getReferencedFunction()};
+}
+
 SwiftInt TupleExtractInst_fieldIndex(BridgedInstruction tei) {
   return castToInst<TupleExtractInst>(tei)->getFieldIndex();
 }
@@ -459,6 +467,14 @@ SwiftInt ApplyInst_numArguments(BridgedInstruction ai) {
   return castToInst<ApplyInst>(ai)->getNumArguments();
 }
 
+SwiftInt AllocRefInstBase_isObjc(BridgedInstruction arb) {
+  return castToInst<AllocRefInstBase>(arb)->isObjC();
+}
+
+SwiftInt AllocRefInstBase_canAllocOnStack(BridgedInstruction arb) {
+  return castToInst<AllocRefInstBase>(arb)->canAllocOnStack();
+}
+
 SwiftInt BeginApplyInst_numArguments(BridgedInstruction tai) {
   return castToInst<BeginApplyInst>(tai)->getNumArguments();
 }
@@ -519,3 +535,9 @@ BridgedInstruction SILBuilder_createIntegerLiteral(BridgedInstruction insertionP
                                        getSILType(type), value)};
 }
 
+BridgedInstruction SILBuilder_createDeallocStackRef(BridgedInstruction insertionPoint,
+          BridgedLocation loc, BridgedValue operand) {
+  SILBuilder builder(castToInst(insertionPoint), getSILDebugScope(loc));
+  return {builder.createDeallocStackRef(getRegularLocation(loc),
+                                        castToSILValue(operand))};
+}

Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,12 @@ extension ApplySite {`
`36`	`36`	`return nil`
`37`	`37`	`}`
`38`	`38`
	`39`	`+ public var referencedFunction: Function? {`
	`40`	`+ if let fri = callee as? FunctionRefInst {`
	`41`	`+ return fri.referencedFunction`
	`42`	`+ }`
	`43`	`+ return nil`
	`44`	`+ }`
`39`	`45`	`}`
`40`	`46`
`41`	`47`	`public protocol FullApplySite : ApplySite {`
Original file line number	Diff line number	Diff line change
`@@ -67,4 +67,10 @@ public struct Builder {`
`67`	`67`	`bridgedInsPoint, location.bridgedLocation, type.bridged, value)`
`68`	`68`	`return literal.getAs(IntegerLiteralInst.self)`
`69`	`69`	`}`
	`70`	`+`
	`71`	`+ public func createDeallocStackRef(_ operand: Value) -> DeallocStackRefInst {`
	`72`	`+ notifyInstructionsChanged()`
	`73`	`+ let dr = SILBuilder_createDeallocStackRef(bridgedInsPoint, location.bridgedLocation, operand.bridged)`
	`74`	`+ return dr.getAs(DeallocStackRefInst.self)`
	`75`	`+ }`
`70`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,6 +54,9 @@ final public class Function : CustomStringConvertible {`
`54`	`54`	`public var bridged: BridgedFunction { BridgedFunction(obj: SwiftObject(self)) }`
`55`	`55`	`}`
`56`	`56`
	`57`	`+public func == (lhs: Function, rhs: Function) -> Bool { lhs === rhs }`
	`58`	`+public func != (lhs: Function, rhs: Function) -> Bool { lhs !== rhs }`
	`59`	`+`
`57`	`60`	`// Bridging utilities`
`58`	`61`
`59`	`62`	`extension BridgedFunction {`