[embedded] 🚀 add Embedded expiremental feature.

Optimize all functions in embedded mode. Diagnose any uses of existentials or witness tables.

Author: zoecarver

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -300,6 +300,15 @@ fileprivate struct FunctionWorklist {
   }
 
   mutating func addAllPerformanceAnnotatedFunctions(of moduleContext: ModulePassContext) {
+    // For embedded Swift, optimize all the functions (there cannot be any
+    // generics, type metadata, etc.)
+    if moduleContext.options.enableEmbeddedSwift {
+      for f in moduleContext.functions {
+        pushIfNotVisited(f)
+      }
+      return
+    }
+
     for f in moduleContext.functions where f.performanceConstraints != .none {
       pushIfNotVisited(f)
     }

SwiftCompilerSources/Sources/Optimizer/PassManager/Options.swift

@@ -28,6 +28,10 @@ struct Options {
     _bridged.enableSimplificationFor(inst.bridged)
   }
 
+  var enableEmbeddedSwift: Bool {
+    _bridged.enableEmbeddedSwift()
+  }
+
   enum AssertConfiguration {
     case enabled
     case disabled

include/swift/Basic/Features.def

@@ -232,6 +232,9 @@ EXPERIMENTAL_FEATURE(ThenStatements, false)
 /// Enable the `@_rawLayout` attribute.
 EXPERIMENTAL_FEATURE(RawLayout, true)
 
+/// Enables the "embedded" swift mode (no runtime).
+EXPERIMENTAL_FEATURE(Embedded, true)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

include/swift/SILOptimizer/OptimizerBridging.h

@@ -494,6 +494,11 @@ struct BridgedPassContext {
     return mod->getOptions().EnableStackProtection;
   }
 
+  bool enableEmbeddedSwift() const {
+    swift::SILModule *mod = invocation->getPassManager()->getModule();
+    return mod->getASTContext().LangOpts.hasFeature(swift::Feature::Embedded);
+  }
+
   bool enableMoveInoutStackProtection() const {
     swift::SILModule *mod = invocation->getPassManager()->getModule();
     return mod->getOptions().EnableMoveInoutStackProtection;

lib/AST/ASTPrinter.cpp

@@ -3148,6 +3148,10 @@ static bool usesFeatureBuiltinStackAlloc(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureEmbedded(Decl *decl) {
+  return false;
+}
+
 static bool usesFeatureBuiltinUnprotectedStackAlloc(Decl *decl) {
   return false;
 }

lib/SILOptimizer/Mandatory/PerformanceDiagnostics.cpp

@@ -353,7 +353,26 @@ bool PerformanceDiagnostics::visitInst(SILInstruction *inst,
   SILType impactType;
   RuntimeEffect impact = getRuntimeEffect(inst, impactType);
   LocWithParent loc(inst->getLoc().getSourceLoc(), parentLoc);
-  
+
+  if (isa<WitnessMethodInst>(inst) ||
+      isa<InitExistentialAddrInst>(inst) ||
+      isa<InitExistentialValueInst>(inst) ||
+      isa<InitExistentialRefInst>(inst) ||
+      isa<OpenExistentialValueInst>(inst) ||
+      isa<OpenExistentialRefInst>(inst) ||
+      isa<OpenExistentialAddrInst>(inst) ||
+      isa<OpenExistentialBoxInst>(inst) ||
+      isa<OpenExistentialBoxValueInst>(inst) ||
+      isa<InitExistentialMetatypeInst>(inst) ||
+      isa<OpenExistentialMetatypeInst>(inst)) {
+    PrettyStackTracePerformanceDiagnostics stackTrace("existential", inst);
+    diagnose(loc, diag::performance_metadata, "existential");
+    return true;
+  }
+
+  if (perfConstr == PerformanceConstraints::None)
+    return false;
+
   if (impact & RuntimeEffect::Casting) {
     // TODO: be more specific on casting.
     // E.g. distinguish locking and allocating dynamic casts, etc.
@@ -497,6 +516,11 @@ bool PerformanceDiagnostics::visitInst(SILInstruction *inst,
 void PerformanceDiagnostics::checkNonAnnotatedFunction(SILFunction *function) {
   for (SILBasicBlock &block : *function) {
     for (SILInstruction &inst : block) {
+      if (function->getASTContext().LangOpts.hasFeature(Feature::Embedded)) {
+        auto loc = LocWithParent(inst.getLoc().getSourceLoc(), nullptr);
+        visitInst(&inst, PerformanceConstraints::None, &loc);
+      }
+
       auto as = FullApplySite::isa(&inst);
       if (!as)
         continue;
@@ -592,14 +616,20 @@ class PerformanceDiagnosticsPass : public SILModuleTransform {
       }
     }
 
-    if (!annotatedFunctionsFound)
+    if (!annotatedFunctionsFound &&
+        !getModule()->getASTContext().LangOpts.hasFeature(Feature::Embedded))
       return;
 
     for (SILFunction &function : *module) {
       // Don't rerun diagnostics on deserialized functions.
       if (function.wasDeserializedCanonical())
         continue;
 
+      // Don't check generic functions, they're about to be removed anyway.
+      if (getModule()->getASTContext().LangOpts.hasFeature(Feature::Embedded) &&
+          function.getLoweredFunctionType()->getSubstGenericSignature())
+        continue;
+
       if (function.getPerfConstraints() == PerformanceConstraints::None) {
         diagnoser.checkNonAnnotatedFunction(&function);
       }