swift SIL: add some Instruction, Value and Type APIs

* instructions `RefToBridgeObjectInst`, `BridgeObjectToWordInst`, `StringLiteralInst`, `ProjectBoxInst`, `InitEnumDataAddrInst`, `UncheckedTakeEnumDataAddrInst`, `InjectEnumAddrInst`
* protocols `StoringInstruction` and `EnumInstruction`
* load/store-weak/unowned instructions
* `CopyAddrInst.isTakeOfSrc/isInitializationOfDest`
* `ApplySite.calleeArgIndex/callerArgIndex`
* `SILValue.definingInstruction/definingBlock/function`
*  `Type.isReferenceCounted`
* `FunctionArgument.isExclusiveIndirectParameter`
* support `CondBranchInst` in `incomingPhiValues`

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/SILPrinter.swift

@@ -29,6 +29,11 @@ func runSILPrinter(function: Function, context: PassContext) {
       for use in arg.uses {
         print("      user: \(use.instruction)")
       }
+      if let blockArg = arg as? BlockArgument, blockArg.isPhiArgument {
+        for incoming in blockArg.incomingPhiValues {
+          print("      incoming: \(incoming)")
+        }
+      }
     }
 
     print("  instructions:")

SwiftCompilerSources/Sources/SIL/ApplySite.swift

@@ -18,6 +18,8 @@ public struct ApplyOperands {
 public protocol ApplySite : AnyObject {
   var operands: OperandArray { get }
   var numArguments: Int { get }
+  func calleeArgIndex(callerArgIndex: Int) -> Int
+  func callerArgIndex(calleeArgIndex: Int) -> Int?
 }
 
 extension ApplySite {
@@ -47,3 +49,8 @@ extension ApplySite {
 public protocol FullApplySite : ApplySite {
   var singleDirectResult: Value? { get }
 }
+
+extension FullApplySite {
+  public func calleeArgIndex(callerArgIndex: Int) -> Int { callerArgIndex }
+  public func callerArgIndex(calleeArgIndex: Int) -> Int? { calleeArgIndex }
+}

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -35,25 +35,42 @@ public class Argument : Value, Equatable {
 }
 
 final public class FunctionArgument : Argument {
+  public var isExclusiveIndirectParameter: Bool {
+    SILArgument_isExclusiveIndirectParameter(bridged) != 0
+  }
 }
 
 final public class BlockArgument : Argument {
-  /// Note: critical edges are not supported, i.e. this is false if there is
-  /// a cond_br in the predecessors.
   public var isPhiArgument: Bool {
-    block.predecessors.allSatisfy { $0.terminator is BranchInst }
+    block.predecessors.allSatisfy {
+      let term = $0.terminator
+      return term is BranchInst || term is CondBranchInst
+    }
   }
 
   public var incomingPhiOperands: LazyMapSequence<PredecessorList, Operand> {
     assert(isPhiArgument)
     let idx = index
-    return block.predecessors.lazy.map { $0.terminator.operands[idx] }
+    return block.predecessors.lazy.map {
+      switch $0.terminator {
+        case let br as BranchInst:
+          return br.operands[idx]
+        case let condBr as CondBranchInst:
+          if condBr.trueBlock == self.block {
+            assert(condBr.falseBlock != self.block)
+            return condBr.trueOperands[idx]
+          } else {
+            assert(condBr.falseBlock == self.block)
+            return condBr.falseOperands[idx]
+          }
+        default:
+          fatalError("wrong terminator for phi-argument")
+      }
+    }
   }
 
-  public var incomingPhiValues: LazyMapSequence<PredecessorList, Value> {
-    assert(isPhiArgument)
-    let idx = index
-    return block.predecessors.lazy.map { $0.terminator.operands[idx].value }
+  public var incomingPhiValues: LazyMapSequence<LazyMapSequence<PredecessorList, Operand>, Value> {
+    incomingPhiOperands.lazy.map { $0.value }
   }
 }
 

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -53,6 +53,13 @@ final public class Function : CustomStringConvertible, HasName {
   public var argumentTypes: ArgumentTypeArray { ArgumentTypeArray(function: self) }
   public var resultType: Type { SILFunction_getSILResultType(bridged).type }
 
+  public var returnInstruction: ReturnInst? {
+    for block in blocks.reversed() {
+      if let retInst = block.terminator as? ReturnInst { return retInst }
+    }
+    return nil
+  }
+
   /// True, if the function runs with a swift 5.1 runtime.
   /// Note that this is function specific, because inlinable functions are de-serialized
   /// in a client module, which might be compiled with a different deployment target.

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -184,12 +184,18 @@ extension UnaryInstruction {
 final public class UnimplementedInstruction : Instruction {
 }
 
-final public class StoreInst : Instruction {
+public protocol StoringInstruction : AnyObject {
+  var operands: OperandArray { get }
+}
+
+extension StoringInstruction {
   public var sourceOperand: Operand { return operands[0] }
   public var destinationOperand: Operand { return operands[1] }
   public var source: Value { return sourceOperand.value }
   public var destination: Value { return destinationOperand.value }
+}
 
+final public class StoreInst : Instruction, StoringInstruction {
   // must match with enum class StoreOwnershipQualifier
   public enum StoreOwnership: Int {
     case unqualified = 0, initialize = 1, assign = 2, trivial = 3
@@ -199,11 +205,21 @@ final public class StoreInst : Instruction {
   }
 }
 
+final public class StoreWeakInst : Instruction, StoringInstruction { }
+final public class StoreUnownedInst : Instruction, StoringInstruction { }
+
 final public class CopyAddrInst : Instruction {
   public var sourceOperand: Operand { return operands[0] }
   public var destinationOperand: Operand { return operands[1] }
   public var source: Value { return sourceOperand.value }
   public var destination: Value { return destinationOperand.value }
+  
+  public var isTakeOfSrc: Bool {
+    CopyAddrInst_isTakeOfSrc(bridged) != 0
+  }
+  public var isInitializationOfDest: Bool {
+    CopyAddrInst_isInitializationOfDest(bridged) != 0
+  }
 }
 
 final public class EndAccessInst : Instruction, UnaryInstruction {
@@ -262,6 +278,10 @@ final public class DestroyValueInst : Instruction, UnaryInstruction {}
 
 final public class DestroyAddrInst : Instruction, UnaryInstruction {}
 
+final public class InjectEnumAddrInst : Instruction, UnaryInstruction, EnumInstruction {
+  public var caseIndex: Int { InjectEnumAddrInst_caseIndex(bridged) }
+}
+
 final public class UnimplementedRefCountingInst : RefCountingInst {}
 
 //===----------------------------------------------------------------------===//
@@ -275,6 +295,8 @@ final public class UnimplementedSingleValueInst : SingleValueInstruction {
 
 final public class LoadInst : SingleValueInstruction, UnaryInstruction {}
 
+final public class LoadWeakInst : SingleValueInstruction, UnaryInstruction {}
+final public class LoadUnownedInst : SingleValueInstruction, UnaryInstruction {}
 final public class LoadBorrowInst : SingleValueInstruction, UnaryInstruction {}
 
 final public class BuiltinInst : SingleValueInstruction {
@@ -362,6 +384,10 @@ final public class GlobalValueInst : GlobalAccessInst {}
 
 final public class IntegerLiteralInst : SingleValueInstruction {}
 
+final public class StringLiteralInst : SingleValueInstruction {
+  public var string: String { StringLiteralInst_getValue(bridged).string }
+}
+
 final public class TupleInst : SingleValueInstruction {
 }
 
@@ -386,17 +412,28 @@ class StructElementAddrInst : SingleValueInstruction, UnaryInstruction {
   public var fieldIndex: Int { StructElementAddrInst_fieldIndex(bridged) }
 }
 
-final public class EnumInst : SingleValueInstruction {
+public protocol EnumInstruction : AnyObject {
+  var caseIndex: Int { get }
+}
+
+final public class EnumInst : SingleValueInstruction, UnaryInstruction, EnumInstruction {
   public var caseIndex: Int { EnumInst_caseIndex(bridged) }
 
   public var operand: Value? { operands.first?.value }
 }
 
-final public
-class UncheckedEnumDataInst : SingleValueInstruction, UnaryInstruction {
+final public class UncheckedEnumDataInst : SingleValueInstruction, UnaryInstruction, EnumInstruction {
   public var caseIndex: Int { UncheckedEnumDataInst_caseIndex(bridged) }
 }
 
+final public class InitEnumDataAddrInst : SingleValueInstruction, UnaryInstruction, EnumInstruction {
+  public var caseIndex: Int { InitEnumDataAddrInst_caseIndex(bridged) }
+}
+
+final public class UncheckedTakeEnumDataAddrInst : SingleValueInstruction, UnaryInstruction, EnumInstruction {
+  public var caseIndex: Int { UncheckedTakeEnumDataAddrInst_caseIndex(bridged) }
+}
+
 final public class RefElementAddrInst : SingleValueInstruction, UnaryInstruction {
   public var fieldIndex: Int { RefElementAddrInst_fieldIndex(bridged) }
 }
@@ -430,13 +467,23 @@ class MarkDependenceInst : SingleValueInstruction {
   public var base: Value { return operands[1].value }
 }
 
+final public class RefToBridgeObjectInst : SingleValueInstruction,
+                                           UnaryInstruction {}
+
 final public class BridgeObjectToRefInst : SingleValueInstruction,
                                            UnaryInstruction {}
 
+final public class BridgeObjectToWordInst : SingleValueInstruction,
+                                           UnaryInstruction {}
+
 final public class BeginAccessInst : SingleValueInstruction, UnaryInstruction {}
 
 final public class BeginBorrowInst : SingleValueInstruction, UnaryInstruction {}
 
+final public class ProjectBoxInst : SingleValueInstruction, UnaryInstruction {
+  public var fieldIndex: Int { ProjectBoxInst_fieldIndex(bridged) }
+}
+
 final public class CopyValueInst : SingleValueInstruction, UnaryInstruction {}
 
 final public class EndCOWMutationInst : SingleValueInstruction, UnaryInstruction {}
@@ -446,6 +493,19 @@ class ClassifyBridgeObjectInst : SingleValueInstruction, UnaryInstruction {}
 
 final public class PartialApplyInst : SingleValueInstruction, ApplySite {
   public var numArguments: Int { PartialApplyInst_numArguments(bridged) }
+  public var isOnStack: Bool { PartialApplyInst_isOnStack(bridged) != 0 }
+
+  public func calleeArgIndex(callerArgIndex: Int) -> Int {
+    PartialApply_getCalleeArgIndexOfFirstAppliedArg(bridged) + callerArgIndex
+  }
+
+  public func callerArgIndex(calleeArgIndex: Int) -> Int? {
+    let firstIdx = PartialApply_getCalleeArgIndexOfFirstAppliedArg(bridged)
+    if calleeArgIndex >= firstIdx {
+      return calleeArgIndex - firstIdx
+    }
+    return nil
+  }
 }
 
 final public class ApplyInst : SingleValueInstruction, FullApplySite {
@@ -520,8 +580,6 @@ final public class BeginApplyInst : MultipleValueInstruction, FullApplySite {
   public var singleDirectResult: Value? { nil }
 }
 
-public final class RefToBridgeObjectInst: MultipleValueInstruction {}
-
 //===----------------------------------------------------------------------===//
 //                            terminator instructions
 //===----------------------------------------------------------------------===//
@@ -565,6 +623,26 @@ final public class BranchInst : TermInst {
 }
 
 final public class CondBranchInst : TermInst {
+  var trueBlock: BasicBlock { successors[0] }
+  var falseBlock: BasicBlock { successors[1] }
+
+  var condition: Value { operands[0].value }
+
+  var trueOperands: OperandArray { operands[1...CondBranchInst_getNumTrueArgs(bridged)] }
+  var falseOperands: OperandArray {
+    let ops = operands
+    return ops[(CondBranchInst_getNumTrueArgs(bridged) &+ 1)..<ops.count]
+  }
+
+  public func getArgument(for operand: Operand) -> Argument {
+    let argIdx = operand.index - 1
+    let numTrueArgs = CondBranchInst_getNumTrueArgs(bridged)
+    if (0..<numTrueArgs).contains(argIdx) {
+      return trueBlock.arguments[argIdx]
+    } else {
+      return falseBlock.arguments[argIdx - numTrueArgs]
+    }
+  }
 }
 
 final public class SwitchValueInst : TermInst {

SwiftCompilerSources/Sources/SIL/Operand.swift

@@ -21,19 +21,7 @@ public struct Operand : CustomStringConvertible, CustomReflectable {
   }
 
   public var value: Value {
-    let v = Operand_getValue(bridged).getAs(AnyObject.self)
-    switch v {
-      case let inst as SingleValueInstruction:
-        return inst
-      case let arg as Argument:
-        return arg
-      case let mvr as MultipleValueInstructionResult:
-        return mvr
-      case let undef as Undef:
-        return undef
-      default:
-        fatalError("unknown Value type")
-    }
+    Operand_getValue(bridged).value
   }
 
   public static func ==(lhs: Operand, rhs: Operand) -> Bool {

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -39,6 +39,8 @@ public func registerSILClasses() {
   register(BlockArgument.self)
 
   register(StoreInst.self)
+  register(StoreWeakInst.self)
+  register(StoreUnownedInst.self)
   register(CopyAddrInst.self)
   register(EndAccessInst.self)
   register(EndBorrowInst.self)
@@ -56,7 +58,10 @@ public func registerSILClasses() {
   register(ReleaseValueInst.self)
   register(DestroyValueInst.self)
   register(DestroyAddrInst.self)
+  register(InjectEnumAddrInst.self)
   register(LoadInst.self)
+  register(LoadWeakInst.self)
+  register(LoadUnownedInst.self)
   register(LoadBorrowInst.self)
   register(BuiltinInst.self)
   register(UpcastInst.self)
@@ -81,6 +86,7 @@ public func registerSILClasses() {
   register(GlobalAddrInst.self)
   register(GlobalValueInst.self)
   register(IntegerLiteralInst.self)
+  register(StringLiteralInst.self)
   register(TupleInst.self)
   register(TupleExtractInst.self)
   register(TupleElementAddrInst.self)
@@ -89,6 +95,8 @@ public func registerSILClasses() {
   register(StructElementAddrInst.self)
   register(EnumInst.self)
   register(UncheckedEnumDataInst.self)
+  register(InitEnumDataAddrInst.self)
+  register(UncheckedTakeEnumDataAddrInst.self)
   register(RefElementAddrInst.self)
   register(RefTailAddrInst.self)
   register(UnconditionalCheckedCastInst.self)
@@ -98,9 +106,12 @@ public func registerSILClasses() {
   register(ObjCMetatypeToObjectInst.self)
   register(ValueToBridgeObjectInst.self)
   register(MarkDependenceInst.self)
+  register(RefToBridgeObjectInst.self)
   register(BridgeObjectToRefInst.self)
+  register(BridgeObjectToWordInst.self)
   register(BeginAccessInst.self)
   register(BeginBorrowInst.self)
+  register(ProjectBoxInst.self)
   register(CopyValueInst.self)
   register(EndCOWMutationInst.self)
   register(ClassifyBridgeObjectInst.self)

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -23,6 +23,10 @@ public struct Type : CustomStringConvertible, CustomReflectable {
     return SILType_isTrivial(bridged, function.bridged) != 0
   }
 
+  public func isReferenceCounted(in function: Function) -> Bool {
+    return SILType_isReferenceCounted(bridged, function.bridged) != 0
+  }
+
   public var isNominal: Bool { SILType_isNominal(bridged) != 0 }
   public var isClass: Bool { SILType_isClass(bridged) != 0 }
   public var isStruct: Bool { SILType_isStruct(bridged) != 0 }