Swift SIL: some new APIs and some refactoring

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -168,8 +168,7 @@ struct FunctionPassContext : MutatingContext {
   var notifyInstructionChanged: (Instruction) -> () { return { inst in } }
 
   func continueWithNextSubpassRun(for inst: Instruction? = nil) -> Bool {
-    let bridgedInst = OptionalBridgedInstruction(inst?.bridged.obj)
-    return _bridged.continueWithNextSubpassRun(bridgedInst)
+    return _bridged.continueWithNextSubpassRun(inst.bridged)
   }
 
   func createSimplifyContext(preserveDebugInfo: Bool, notifyInstructionChanged: @escaping (Instruction) -> ()) -> SimplifyContext {

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -113,7 +113,7 @@ public struct Builder {
     return notifyNew(cast.getAs(UpcastInst.self))
   }
 
-  public func createLoad(fromAddress: Value, ownership: LoadInst.LoadOwnership) -> LoadInst {
+  public func createLoad(fromAddress: Value, ownership: LoadInst.Ownership) -> LoadInst {
     let load = bridged.createLoad(fromAddress.bridged, ownership.rawValue)
     return notifyNew(load.getAs(LoadInst.self))
   }
@@ -184,6 +184,12 @@ public struct Builder {
     let ued = bridged.createUncheckedEnumData(enumVal.bridged, caseIndex, resultType.bridged)
     return notifyNew(ued.getAs(UncheckedEnumDataInst.self))
   }
+
+  public func createEnum(caseIndex: Int, payload: Value?, enumType: Type) -> EnumInst {
+    let enumInst = bridged.createEnum(caseIndex, payload.bridged, enumType.bridged)
+    return notifyNew(enumInst.getAs(EnumInst.self))
+  }
+
   @discardableResult
   public func createSwitchEnum(enum enumVal: Value,
                                cases: [(Int, BasicBlock)],
@@ -225,20 +231,23 @@ public struct Builder {
     return notifyNew(bridged.createGlobalValue(global.bridged).getAs(GlobalValueInst.self))
   }
 
-  @discardableResult
   public func createStruct(type: Type, elements: [Value]) -> StructInst {
     let structInst = elements.withBridgedValues { valuesRef in
       return bridged.createStruct(type.bridged, valuesRef)
     }
     return notifyNew(structInst.getAs(StructInst.self))
   }
 
-  @discardableResult
   public func createTuple(type: Type, elements: [Value]) -> TupleInst {
     let tuple = elements.withBridgedValues { valuesRef in
       return bridged.createTuple(type.bridged, valuesRef)
     }
     return notifyNew(tuple.getAs(TupleInst.self))
   }
 
+  @discardableResult
+  public func createStore(source: Value, destination: Value, ownership: StoreInst.Ownership) -> StoreInst {
+    let store = bridged.createStore(source.bridged, destination.bridged, ownership.rawValue)
+    return notifyNew(store.getAs(StoreInst.self))
+  }
 }

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -148,6 +148,12 @@ extension OptionalBridgedInstruction {
   }
 }
 
+extension Optional where Wrapped == Instruction {
+  public var bridged: OptionalBridgedInstruction {
+    OptionalBridgedInstruction(self?.bridged.obj)
+  }
+}
+
 public class SingleValueInstruction : Instruction, Value {
   final public var definingInstruction: Instruction? { self }
 
@@ -222,11 +228,23 @@ extension StoringInstruction {
 
 final public class StoreInst : Instruction, StoringInstruction {
   // must match with enum class StoreOwnershipQualifier
-  public enum StoreOwnership: Int {
+  public enum Ownership: Int {
     case unqualified = 0, initialize = 1, assign = 2, trivial = 3
+
+    public init(for type: Type, in function: Function, initialize: Bool) {
+      if function.hasOwnership {
+        if type.isTrivial(in: function) {
+          self = .trivial
+        } else {
+          self = initialize ? .initialize : .assign
+        }
+      } else {
+        self = .unqualified
+      }
+    }
   }
-  public var destinationOwnership: StoreOwnership {
-    StoreOwnership(rawValue: bridged.StoreInst_getStoreOwnership())!
+  public var destinationOwnership: Ownership {
+    Ownership(rawValue: bridged.StoreInst_getStoreOwnership())!
   }
 }
 
@@ -307,6 +325,7 @@ final public class DestroyAddrInst : Instruction, UnaryInstruction {
 }
 
 final public class InjectEnumAddrInst : Instruction, UnaryInstruction, EnumInstruction {
+  public var `enum`: Value { operand.value }
   public var caseIndex: Int { bridged.InjectEnumAddrInst_caseIndex() }
 }
 
@@ -351,11 +370,11 @@ final public class LoadInst : SingleValueInstruction, UnaryInstruction {
   public var address: Value { operand.value }
 
   // must match with enum class LoadOwnershipQualifier
-  public enum LoadOwnership: Int {
+  public enum Ownership: Int {
     case unqualified = 0, take = 1, copy = 2, trivial = 3
   }
-  public var ownership: LoadOwnership {
-    LoadOwnership(rawValue: bridged.LoadInst_getLoadOwnership())!
+  public var ownership: Ownership {
+    Ownership(rawValue: bridged.LoadInst_getLoadOwnership())!
   }
 }
 

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -31,6 +31,10 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
     return !bridged.isNonTrivialOrContainsRawPointer(function.bridged.getFunction())
   }
 
+  public func isLoadable(in function: Function) -> Bool {
+    return bridged.isLoadable(function.bridged.getFunction())
+  }
+
   public func isReferenceCounted(in function: Function) -> Bool {
     return bridged.isReferenceCounted(function.bridged.getFunction())
   }

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -204,3 +204,9 @@ final class PlaceholderValue : Value {
 extension OptionalBridgedValue {
   public var value: Value? { obj.getAs(AnyObject.self) as? Value }
 }
+
+extension Optional where Wrapped == Value {
+  public var bridged: OptionalBridgedValue {
+    OptionalBridgedValue(obj: self?.bridged.obj)
+  }
+}

include/swift/SIL/SILBridging.h

@@ -88,6 +88,12 @@ struct BridgedValue {
 
 struct OptionalBridgedValue {
   OptionalSwiftObject obj;
+
+  swift::SILValue getSILValue() const {
+    if (obj)
+      return static_cast<swift::ValueBase *>(obj);
+    return swift::SILValue();
+  }
 };
 
 inline swift::ValueOwnershipKind castToOwnership(BridgedValue::Ownership ownership) {
@@ -1173,6 +1179,14 @@ struct BridgedBuilder{
                                               en->getType().getEnumElement(caseIdx), resultType)};
   }
 
+  SWIFT_IMPORT_UNSAFE
+  BridgedInstruction createEnum(SwiftInt caseIdx, OptionalBridgedValue payload,
+                                swift::SILType resultType) const {
+    swift::EnumElementDecl *caseDecl = resultType.getEnumElement(caseIdx);
+    swift::SILValue pl = payload.getSILValue();
+    return {builder().createEnum(regularLoc(), pl, caseDecl, resultType)};
+  }
+
   SWIFT_IMPORT_UNSAFE
   BridgedInstruction createBranch(BridgedBasicBlock destBlock, BridgedValueArray arguments) const {
     llvm::SmallVector<swift::SILValue, 16> argValues;
@@ -1212,6 +1226,13 @@ struct BridgedBuilder{
     llvm::SmallVector<swift::SILValue, 16> elementValues;
     return {builder().createTuple(regularLoc(), type, elements.getValues(elementValues))};
   }
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedInstruction createStore(BridgedValue src, BridgedValue dst,
+                                 SwiftInt ownership) const {
+    return {builder().createStore(regularLoc(), src.getSILValue(), dst.getSILValue(),
+                                  (swift::StoreOwnershipQualifier)ownership)};
+  }
 };
 
 // AST bridging

include/swift/SIL/SILType.h

@@ -346,6 +346,8 @@ class SILType {
     return !isAddressOnly(F);
   }
 
+  bool isLoadable(const SILFunction *f) const { return isLoadable(*f); }
+
   /// True if either:
   /// 1) The type, or the referenced type of an address type, is loadable.
   /// 2) The SIL Module conventions uses lowered addresses