[embedded] Perform VTable specialization iteratively as part of MandatoryPerformanceOptimizations

kubamracek · kubamracek · commit 03f927eca1c1 · 2023-09-20T09:41:09.000-07:00
diff --git a/SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift b/SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift
@@ -49,7 +49,17 @@ private func optimizeFunctionsTopDown(using worklist: inout FunctionWorklist,
       if !context.loadFunction(function: f, loadCalleesRecursively: true) {
         return
       }
+
+      let vTablesFunctionsBefore = Set(moduleContext.vTables.flatMap { $0.entries.map { $0.function } })
+
       optimize(function: f, context)
+
+      let vTablesFunctionsAfter = Set(moduleContext.vTables.flatMap { $0.entries.map { $0.function } })
+      // Optimizing can trigger vtable specialization, add new vtable entries to the worklist
+      for f in vTablesFunctionsAfter.subtracting(vTablesFunctionsBefore) {
+        worklist.pushIfNotVisited(f)
+      }
+
       worklist.add(calleesOf: f)
     }
   }
@@ -82,6 +92,8 @@ private func optimize(function: Function, _ context: FunctionPassContext) {
 
     _ = context.specializeApplies(in: function, isMandatory: true)
 
+    changed = context.specializeVTables(in: function) || changed
+
     removeUnusedMetatypeInstructions(in: function, context)
 
     // If this is a just specialized function, try to optimize copy_addr, etc.
diff --git a/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift b/SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift
@@ -267,6 +267,14 @@ struct FunctionPassContext : MutatingContext {
     return false
   }
 
+  func specializeVTables(in function: Function) -> Bool {
+    if _bridged.specializeVTables(function.bridged) {
+      notifyInstructionsChanged()
+      return true
+    }
+    return false
+  }
+
   func specializeApplies(in function: Function, isMandatory: Bool) -> Bool {
     if _bridged.specializeAppliesInFunction(function.bridged, isMandatory) {
       notifyInstructionsChanged()
diff --git a/include/swift/SILOptimizer/OptimizerBridging.h b/include/swift/SILOptimizer/OptimizerBridging.h
@@ -254,6 +254,8 @@ struct BridgedPassContext {
   SWIFT_IMPORT_UNSAFE
   OptionalBridgedValue constantFoldBuiltin(BridgedInstruction builtin) const;
 
+  bool specializeVTables(BridgedFunction function) const;
+
   bool specializeAppliesInFunction(BridgedFunction function, bool isMandatory) const;
 
   std::string mangleOutlinedVariable(BridgedFunction function) const;
diff --git a/include/swift/SILOptimizer/Utils/InstOptUtils.h b/include/swift/SILOptimizer/Utils/InstOptUtils.h
@@ -597,6 +597,8 @@ bool optimizeMemoryAccesses(SILFunction *fn);
 /// See the PredictableDeadAllocationElimination pass.
 bool eliminateDeadAllocations(SILFunction *fn);
 
+bool specializeVTables(SILFunction *fn, SILTransform *transform);
+
 bool specializeAppliesInFunction(SILFunction &F,
                                  SILTransform *transform,
                                  bool isMandatory);
diff --git a/lib/SILOptimizer/PassManager/PassManager.cpp b/lib/SILOptimizer/PassManager/PassManager.cpp
@@ -1545,6 +1545,10 @@ SwiftInt BridgedPassContext::getStaticStride(swift::SILType type) const {
   return integerValueFromConstant(c);
 }
 
+bool BridgedPassContext::specializeVTables(BridgedFunction function) const {
+  return ::specializeVTables(function.getFunction(), invocation->getTransform());
+}
+
 bool BridgedPassContext::specializeAppliesInFunction(BridgedFunction function, bool isMandatory) const {
   return ::specializeAppliesInFunction(*function.getFunction(), invocation->getTransform(), isMandatory);
 }
diff --git a/lib/SILOptimizer/Transforms/VTableSpecializer.cpp b/lib/SILOptimizer/Transforms/VTableSpecializer.cpp
@@ -38,10 +38,6 @@ namespace {
 
 class VTableSpecializer : public SILModuleTransform {
   bool specializeVTables(SILModule &module);
-  bool specializeVTableFor(SILType classTy, SILModule &module);
-  SILFunction *specializeVTableMethod(SILFunction *origMethod,
-                                      SubstitutionMap subs, SILModule &module);
-  bool specializeClassMethodInst(ClassMethodInst *cm);
 
   /// The entry point to the transformation.
   void run() override {
@@ -57,25 +53,41 @@ class VTableSpecializer : public SILModuleTransform {
 
 }  // end anonymous namespace
 
-bool VTableSpecializer::specializeVTables(SILModule &module) {
+static bool specializeVTableFor(SILType classTy, SILModule &module,
+                                SILTransform *transform);
+static SILFunction *specializeVTableMethod(SILFunction *origMethod,
+                                           SubstitutionMap subs,
+                                           SILModule &module,
+                                           SILTransform *transform);
+static bool specializeClassMethodInst(ClassMethodInst *cm);
+
+static bool specializeVTablesInFunction(SILFunction &func, SILModule &module,
+                                        SILTransform *transform) {
   bool changed = false;
-  for (SILFunction &func : module) {
-    if (func.getLoweredFunctionType()->isPolymorphic()) continue;
-
-    for (SILBasicBlock &block : func) {
-      for (SILInstruction &inst : block) {
-        if (auto *allocRef = dyn_cast<AllocRefInst>(&inst)) {
-          changed |= specializeVTableFor(allocRef->getType(), module);
-        } else if (auto *metatype = dyn_cast<MetatypeInst>(&inst)) {
-          changed |= specializeVTableFor(
-              metatype->getType().getInstanceTypeOfMetatype(&func), module);
-        } else if (auto *cm = dyn_cast<ClassMethodInst>(&inst)) {
-          changed |= specializeClassMethodInst(cm);
-        }
+  if (func.getLoweredFunctionType()->isPolymorphic()) return changed;
+
+  for (SILBasicBlock &block : func) {
+    for (SILInstruction &inst : block) {
+      if (auto *allocRef = dyn_cast<AllocRefInst>(&inst)) {
+        changed |= specializeVTableFor(allocRef->getType(), module, transform);
+      } else if (auto *metatype = dyn_cast<MetatypeInst>(&inst)) {
+        changed |= specializeVTableFor(
+            metatype->getType().getInstanceTypeOfMetatype(&func), module, transform);
+      } else if (auto *cm = dyn_cast<ClassMethodInst>(&inst)) {
+        changed |= specializeClassMethodInst(cm);
       }
     }
   }
 
+  return changed;
+}
+
+bool VTableSpecializer::specializeVTables(SILModule &module) {
+  bool changed = false;
+  for (SILFunction &func : module) {
+    specializeVTablesInFunction(func, module, this);
+  }
+
   for (SILVTable *vtable : module.getVTables()) {
     if (vtable->getClass()->isGenericContext()) continue;
 
@@ -92,8 +104,8 @@ bool VTableSpecializer::specializeVTables(SILModule &module) {
   return changed;
 }
 
-bool VTableSpecializer::specializeVTableFor(SILType classTy,
-                                            SILModule &module) {
+static bool specializeVTableFor(SILType classTy, SILModule &module,
+                                SILTransform *transform) {
   CanType astType = classTy.getASTType();
   BoundGenericClassType *genClassTy = dyn_cast<BoundGenericClassType>(astType);
   if (!genClassTy) return false;
@@ -120,7 +132,7 @@ bool VTableSpecializer::specializeVTableFor(SILType classTy,
   for (const SILVTableEntry &entry : origVtable->getEntries()) {
     SILFunction *origMethod = entry.getImplementation();
     SILFunction *specializedMethod =
-        specializeVTableMethod(origMethod, subs, module);
+        specializeVTableMethod(origMethod, subs, module, transform);
     newEntries.push_back(SILVTableEntry(entry.getMethod(), specializedMethod,
                                         entry.getKind(),
                                         entry.isNonOverridden()));
@@ -130,9 +142,10 @@ bool VTableSpecializer::specializeVTableFor(SILType classTy,
   return true;
 }
 
-SILFunction *VTableSpecializer::specializeVTableMethod(SILFunction *origMethod,
-                                                       SubstitutionMap subs,
-                                                       SILModule &module) {
+static SILFunction *specializeVTableMethod(SILFunction *origMethod,
+                                           SubstitutionMap subs,
+                                           SILModule &module,
+                                           SILTransform *transform) {
   LLVM_DEBUG(llvm::errs() << "specializeVTableMethod " << origMethod->getName()
                           << '\n');
 
@@ -149,7 +162,7 @@ SILFunction *VTableSpecializer::specializeVTableMethod(SILFunction *origMethod,
     llvm::report_fatal_error("cannot specialize vtable method");
   }
 
-  SILOptFunctionBuilder FunctionBuilder(*this);
+  SILOptFunctionBuilder FunctionBuilder(*transform);
 
   GenericFuncSpecializer FuncSpecializer(FunctionBuilder, origMethod, subs,
                                          ReInfo, /*isMandatory=*/true);
@@ -172,7 +185,7 @@ SILFunction *VTableSpecializer::specializeVTableMethod(SILFunction *origMethod,
   return SpecializedF;
 }
 
-bool VTableSpecializer::specializeClassMethodInst(ClassMethodInst *cm) {
+static bool specializeClassMethodInst(ClassMethodInst *cm) {
   SILValue instance = cm->getOperand();
   SILType classTy = instance->getType();
   CanType astType = classTy.getASTType();
@@ -217,6 +230,12 @@ bool VTableSpecializer::specializeClassMethodInst(ClassMethodInst *cm) {
   return true;
 }
 
+bool swift::specializeVTables(SILFunction *fn, SILTransform *transform) {
+  if (!fn->getModule.getASTContext().LangOpts.hasFeature(Feature::Embedded))
+    return false;
+  return specializeVTablesInFunction(*fn, fn->getModule(), transform);
+}
+
 SILTransform *swift::createVTableSpecializer() {
   return new VTableSpecializer();
 }
diff --git a/test/embedded/arrays.swift b/test/embedded/arrays.swift
@@ -0,0 +1,82 @@
+// RUN: %empty-directory(%t)
+// RUN: %{python} %utils/split_file.py -o %t %s
+
+// RUN: %target-swift-frontend %t/main.swift -enable-experimental-feature Embedded -c -o %t/main.o
+// RUN: %target-clang -g -x c %t/runtime.c -c -o %t/runtime.o
+// RUN: %target-clang %t/main.o %t/runtime.o -o %t/a.out -dead_strip
+// RUN: %target-run %t/a.out | %FileCheck %s
+
+// REQUIRES: executable_test
+
+// BEGIN main.swift
+
+@_silgen_name("putchar")
+func putchar(_: UInt8)
+
+public func print(_ s: StaticString, terminator: StaticString = "\n") {
+  var p = s.utf8Start
+  while p.pointee != 0 {
+    putchar(p.pointee)
+    p += 1
+  }
+  p = terminator.utf8Start
+  while p.pointee != 0 {
+    putchar(p.pointee)
+    p += 1
+  }
+}
+
+@_silgen_name("vprintf")
+func vprintf(_: UnsafePointer<UInt8>, _: UnsafeRawPointer)
+
+var global: Int = 0
+public func print(_ n: Int) {
+    let f: StaticString = "%d"
+    global = n
+    vprintf(f.utf8Start, &global)
+}
+
+public func print(_ array: [Int]) {
+  print("[", terminator: "")
+  for e in array {
+    print(e)
+    print(", ", terminator: "")
+  }
+  print("]")
+}
+
+func test() {
+  var a = [1, 2, 3]
+  a.append(8)
+  a.append(contentsOf: [5, 4])
+  let b = a.sorted()
+  var c = b
+  c = c.reversed()
+  print(c) // CHECK: [8, 5, 4, 3, 2, 1, ]
+}
+
+test()
+
+// BEGIN runtime.c
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <stdbool.h>
+
+size_t _swiftEmptyArrayStorage[] = { /*isa*/0, /*refcount*/0, /*count*/0, /*flags*/1 };
+
+void *swift_allocObject(void *metadata, size_t requiredSize, size_t requiredAlignmentMask) {
+  void *r = NULL;
+  posix_memalign(&r, requiredAlignmentMask + 1, requiredSize);
+  return r;
+}
+
+void swift_deallocClassInstance() { }
+void swift_initStackObject() { }
+bool swift_isUniquelyReferenced_nonNull_native(void *) { return true; }
+void swift_release() { }
+void swift_retain() { }
+void swift_setDeallocating() { }
+
+void swift_beginAccess() { }
+void swift_endAccess() { }

Original file line number	Diff line number	Diff line change
`@@ -1545,6 +1545,10 @@ SwiftInt BridgedPassContext::getStaticStride(swift::SILType type) const {`
`1545`	`1545`	`return integerValueFromConstant(c);`
`1546`	`1546`	`}`
`1547`	`1547`
	`1548`	`+bool BridgedPassContext::specializeVTables(BridgedFunction function) const {`
	`1549`	`+ return ::specializeVTables(function.getFunction(), invocation->getTransform());`
	`1550`	`+}`
	`1551`	`+`
`1548`	`1552`	`bool BridgedPassContext::specializeAppliesInFunction(BridgedFunction function, bool isMandatory) const {`
`1549`	`1553`	`return ::specializeAppliesInFunction(*function.getFunction(), invocation->getTransform(), isMandatory);`
`1550`	`1554`	`}`