SIL: add some Builder-create functions

Author: eeckstein

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -79,6 +79,17 @@ public struct Builder {
     self.notificationHandler = notificationHandler
   }
 
+  public func createBuiltin(name: StringRef,
+                            type: Type,
+                            substitutions: SubstitutionMap = SubstitutionMap(),
+                            arguments: [Value]) -> BuiltinInst {
+    return arguments.withBridgedValues { valuesRef in
+      let bi = bridged.createBuiltin(
+        name._bridged, type.bridged, substitutions.bridged, valuesRef)
+      return notifyNew(bi.getAs(BuiltinInst.self))
+    }
+  }
+
   public func createBuiltinBinaryFunction(name: String,
       operandType: Type, resultType: Type, arguments: [Value]) -> BuiltinInst {
     return arguments.withBridgedValues { valuesRef in
@@ -142,11 +153,29 @@ public struct Builder {
     return notifyNew(dr.getAs(AddressToPointerInst.self))
   }
 
+  public func createPointerToAddress(pointer: Value, addressType: Type,
+                                     isStrict: Bool, isInvariant: Bool,
+                                     alignment: Int? = nil) -> PointerToAddressInst {
+    let dr = bridged.createPointerToAddress(pointer.bridged, addressType.bridged, isStrict, isInvariant,
+                                            UInt64(alignment ?? 0))
+    return notifyNew(dr.getAs(PointerToAddressInst.self))
+  }
+
+  public func createIndexAddr(base: Value, index: Value, needStackProtection: Bool) -> IndexAddrInst {
+    let dr = bridged.createIndexAddr(base.bridged, index.bridged, needStackProtection)
+    return notifyNew(dr.getAs(IndexAddrInst.self))
+  }
+
   public func createUncheckedRefCast(from value: Value, to type: Type) -> UncheckedRefCastInst {
     let cast = bridged.createUncheckedRefCast(value.bridged, type.bridged)
     return notifyNew(cast.getAs(UncheckedRefCastInst.self))
   }
 
+  public func createUncheckedAddrCast(from value: Value, to type: Type) -> UncheckedAddrCastInst {
+    let cast = bridged.createUncheckedAddrCast(value.bridged, type.bridged)
+    return notifyNew(cast.getAs(UncheckedAddrCastInst.self))
+  }
+
   public func createUpcast(from value: Value, to type: Type) -> UpcastInst {
     let cast = bridged.createUpcast(value.bridged, type.bridged)
     return notifyNew(cast.getAs(UpcastInst.self))

include/swift/SIL/SILBridging.h

@@ -1063,6 +1063,10 @@ struct BridgedBuilder{
   BRIDGED_INLINE swift::SILBuilder unbridged() const;
   BRIDGED_INLINE swift::SILLocation regularLoc() const;
 
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createBuiltin(BridgedStringRef name,
+                                                                      BridgedType type,
+                                                                      BridgedSubstitutionMap subs,
+                                                                      BridgedValueArray arguments) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createBuiltinBinaryFunction(BridgedStringRef name,
                                           BridgedType operandType, BridgedType resultType,
                                           BridgedValueArray arguments) const;
@@ -1084,8 +1088,18 @@ struct BridgedBuilder{
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createAddressToPointer(BridgedValue address,
                                                                                BridgedType pointerTy,
                                                                                bool needsStackProtection) const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createPointerToAddress(BridgedValue pointer,
+                                                                               BridgedType addressTy,
+                                                                               bool isStrict,
+                                                                               bool isInvariant,
+                                                                               uint64_t alignment) const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createIndexAddr(BridgedValue base,
+                                                                        BridgedValue index,
+                                                                        bool needsStackProtection) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createUncheckedRefCast(BridgedValue op,
                                                                                BridgedType type) const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createUncheckedAddrCast(BridgedValue op,
+                                                                                BridgedType type) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createUpcast(BridgedValue op, BridgedType type) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createLoad(BridgedValue op, SwiftInt ownership) const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedInstruction createLoadBorrow(BridgedValue op) const;

include/swift/SIL/SILBridgingImpl.h

@@ -1919,6 +1919,17 @@ swift::SILLocation BridgedBuilder::regularLoc() const {
   return swift::RegularLocation(loc.getLoc().getLocation());
 }
 
+BridgedInstruction BridgedBuilder::createBuiltin(BridgedStringRef name, BridgedType type,
+                                                 BridgedSubstitutionMap subs,
+                                                 BridgedValueArray arguments) const {
+  llvm::SmallVector<swift::SILValue, 16> argValues;
+  auto builder = unbridged();
+  auto ident = builder.getASTContext().getIdentifier(name.unbridged());
+  return {builder.createBuiltin(
+      regularLoc(), ident, type.unbridged(),
+      subs.unbridged(), arguments.getValues(argValues))};
+}
+
 BridgedInstruction BridgedBuilder::createBuiltinBinaryFunction(BridgedStringRef name,
                                                BridgedType operandType, BridgedType resultType,
                                                BridgedValueArray arguments) const {
@@ -1980,11 +1991,30 @@ BridgedInstruction BridgedBuilder::createAddressToPointer(BridgedValue address,
                                              needsStackProtection)};
 }
 
+BridgedInstruction BridgedBuilder::createPointerToAddress(BridgedValue pointer, BridgedType addressTy,
+                                                          bool isStrict, bool isInvariant,
+                                                          uint64_t alignment) const {
+  return {unbridged().createPointerToAddress(regularLoc(), pointer.getSILValue(), addressTy.unbridged(),
+                                             isStrict, isInvariant,
+                                             alignment == 0 ? llvm::MaybeAlign() : llvm::Align(alignment))};
+}
+
+BridgedInstruction BridgedBuilder::createIndexAddr(BridgedValue base, BridgedValue index,
+                                                   bool needsStackProtection) const {
+  return {unbridged().createIndexAddr(regularLoc(), base.getSILValue(), index.getSILValue(),
+                                      needsStackProtection)};
+}
+
 BridgedInstruction BridgedBuilder::createUncheckedRefCast(BridgedValue op, BridgedType type) const {
   return {unbridged().createUncheckedRefCast(regularLoc(), op.getSILValue(),
                                              type.unbridged())};
 }
 
+BridgedInstruction BridgedBuilder::createUncheckedAddrCast(BridgedValue op, BridgedType type) const {
+  return {unbridged().createUncheckedAddrCast(regularLoc(), op.getSILValue(),
+                                              type.unbridged())};
+}
+
 BridgedInstruction BridgedBuilder::createUpcast(BridgedValue op, BridgedType type) const {
   return {unbridged().createUpcast(regularLoc(), op.getSILValue(),
                                    type.unbridged())};