[embedded] Convert thick->thin metatypes on array builtins (copy, take, assign) in mandatory optimizations

Author: kubamracek

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyBuiltin.swift

@@ -32,6 +32,15 @@ extension BuiltinInst : OnoneSimplifyable {
            .Strideof,
            .Alignof:
         optimizeTargetTypeConst(context)
+      case .CopyArray,
+           .TakeArrayNoAlias,
+           .TakeArrayFrontToBack,
+           .TakeArrayBackToFront,
+           .AssignCopyArrayNoAlias,
+           .AssignCopyArrayFrontToBack,
+           .AssignCopyArrayBackToFront,
+           .AssignTakeArray:
+        optimizeArrayBuiltin(context)
       default:
         if let literal = constantFold(context) {
           uses.replaceAll(with: literal, context)
@@ -162,6 +171,23 @@ private extension BuiltinInst {
     uses.replaceAll(with: literal, context)
     context.erase(instruction: self)
   }
+  
+  func optimizeArrayBuiltin(_ context: SimplifyContext) {
+    guard let metatypeInst = operands[0].value as? MetatypeInst,
+          metatypeInst.type.representationOfMetatype(in: parentFunction) == .Thick else {
+      return
+    }
+    
+    // Must be single use so that we can use replaceAll
+    guard metatypeInst.uses.isSingleUse else {
+      return
+    }
+    
+    let instanceType = metatypeInst.type.instanceTypeOfMetatype(in: parentFunction)
+    let builder = Builder(before: self, context)
+    let metatype = builder.createMetatype(of: instanceType, representation: .Thin)
+    metatypeInst.uses.replaceAll(with: metatype, context)
+  }
 }
 
 private func hasSideEffectForBuiltinOnce(_ instruction: Instruction) -> Bool {

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -309,4 +309,9 @@ public struct Builder {
                                                            useConformancesOf.bridged)
     return notifyNew(initExistential.getAs(InitExistentialRefInst.self))
   }
+  
+  public func createMetatype(of type: Type, representation: swift.MetatypeRepresentation) -> MetatypeInst {
+    let metatype = bridged.createMetatype(type.bridged, representation)
+    return notifyNew(metatype.getAs(MetatypeInst.self))
+  }
 }

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -90,6 +90,10 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
     bridged.getInstanceTypeOfMetatype(function.bridged.getFunction()).type
   }
 
+  public func representationOfMetatype(in function: Function) -> swift.MetatypeRepresentation {
+    bridged.getRepresentationOfMetatype(function.bridged.getFunction())
+  }
+
   public var isCalleeConsumedFunction: Bool { bridged.isCalleeConsumedFunction() }
 
   public var isMarkedAsImmortal: Bool { bridged.isMarkedAsImmortal() }

include/swift/SIL/SILBridging.h

@@ -1357,6 +1357,13 @@ struct BridgedBuilder{
                                                instance.getSILValue(),
                                                src->getConformances())};
   }
+
+  SWIFT_IMPORT_UNSAFE
+  BridgedInstruction createMetatype(swift::SILType type, swift::MetatypeRepresentation representation) const {
+    swift::MetatypeType *mt = swift::MetatypeType::get(type.getASTType(), representation);
+    swift::SILType t = swift::SILType::getPrimitiveObjectType(swift::CanType(mt));
+    return {builder().createMetatype(regularLoc(), t)};
+  }
 };
 
 // AST bridging

include/swift/SIL/SILType.h

@@ -864,6 +864,8 @@ class SILType {
 
   SILType getInstanceTypeOfMetatype(SILFunction *function) const;
 
+  MetatypeRepresentation getRepresentationOfMetatype(SILFunction *function) const;
+
   bool isOrContainsObjectiveCClass() const;
 
   bool isCalleeConsumedFunction() const {

lib/SIL/IR/SILType.cpp

@@ -1076,6 +1076,11 @@ SILType SILType::getInstanceTypeOfMetatype(SILFunction *function) const {
   return tl.getLoweredType();
 }
 
+MetatypeRepresentation SILType::getRepresentationOfMetatype(SILFunction *function) const {
+  auto metaType = castTo<MetatypeType>();
+  return metaType->getRepresentation();
+}
+
 bool SILType::isOrContainsObjectiveCClass() const {
   return getASTType().findIf([](Type ty) {
     if (ClassDecl *cd = ty->getClassOrBoundGenericClass()) {

test/embedded/array-builtins2-no-stdlib.swift

@@ -0,0 +1,33 @@
+// RUN: %target-swift-emit-ir %s -parse-stdlib -module-name Swift -enable-experimental-feature Embedded -target arm64e-apple-none | %FileCheck %s
+
+class MyClass {}
+
+struct MyStruct {
+  var c: MyClass
+}
+
+public func foo(x: Builtin.RawPointer, y: Builtin.RawPointer, count: Builtin.Word) {
+  var s = MyGenericStruct<MyStruct>()
+  s.foo(x: x, y: y, count: count)
+}
+
+public struct MyGenericStruct<T> {
+  public func foo(x: Builtin.RawPointer, y: Builtin.RawPointer, count: Builtin.Word) {
+    Builtin.copyArray(T.self, x, y, count)
+    Builtin.copyArray(T.self, x, y, count)
+    Builtin.takeArrayNoAlias(T.self, x, y, count)
+    Builtin.takeArrayFrontToBack(T.self, x, y, count)
+    Builtin.takeArrayBackToFront(T.self, x, y, count)
+    Builtin.assignCopyArrayNoAlias(T.self, x, y, count)
+    Builtin.assignCopyArrayFrontToBack(T.self, x, y, count)
+    Builtin.assignCopyArrayBackToFront(T.self, x, y, count)
+    Builtin.assignTakeArray(T.self, x, y, count)
+  }
+}
+
+// No runtime calls should be present.
+// CHECK-NOT: @swift_arrayInitWithCopy
+// CHECK-NOT: @swift_arrayAssignWithCopyNoAlias
+// CHECK-NOT: @swift_arrayAssignWithCopyFrontToBack
+// CHECK-NOT: @swift_arrayAssignWithCopyBackToFront
+// CHECK-NOT: @swift_arrayAssignWithTake