Merge pull request #69205 from kubamracek/embedded-diagnose-thick-metatypes

[embedded] Start diagnosing metatype/value_metatype instructions in embedded Swift

Author: kubamracek

include/swift/AST/DiagnosticsSIL.def

@@ -356,6 +356,10 @@ ERROR(embedded_swift_existential_type,none,
       "cannot use a value of protocol type %0 in embedded Swift", (Type))
 ERROR(embedded_swift_existential,none,
       "cannot use a value of protocol type in embedded Swift", ())
+ERROR(embedded_swift_metatype_type,none,
+      "cannot use metatype of type %0 in embedded Swift", (Type))
+ERROR(embedded_swift_metatype,none,
+      "cannot use metatype in embedded Swift", ())
 NOTE(performance_called_from,none,
       "called from here", ())
 

lib/SILOptimizer/Mandatory/PerformanceDiagnostics.cpp

@@ -163,8 +163,10 @@ bool PerformanceDiagnostics::visitFunction(SILFunction *function,
       continue;
 
     for (SILInstruction &inst : block) {
-      if (visitInst(&inst, perfConstr, parentLoc))
+      if (visitInst(&inst, perfConstr, parentLoc)) {
+        LLVM_DEBUG(llvm::dbgs() << inst << *inst.getFunction());
         return true;
+      }
 
       if (auto as = FullApplySite::isa(&inst)) {
         if (isEffectFreeArraySemanticCall(&inst))
@@ -346,22 +348,51 @@ static bool metatypeUsesAreNotRelevant(MetatypeInst *mt) {
   return true;
 }
 
+static bool allowedMetadataUseInEmbeddedSwift(SILInstruction *inst) {
+  // Only diagnose metatype and value_metatype instructions, for now.
+  if ((isa<ValueMetatypeInst>(inst) || isa<MetatypeInst>(inst))) {
+    auto metaTy = cast<SingleValueInstruction>(inst)->getType().castTo<MetatypeType>();
+    if (metaTy->getRepresentation() == MetatypeRepresentation::Thick) {
+      Type instTy = metaTy->getInstanceType();
+      if (auto selfType = instTy->getAs<DynamicSelfType>())
+        instTy = selfType->getSelfType();
+      // Class metadata are supported in embedded Swift
+      return instTy->getClassOrBoundGenericClass() ? true : false;
+    }
+  }
+
+  return true;
+}
+
 bool PerformanceDiagnostics::visitInst(SILInstruction *inst,
                                           PerformanceConstraints perfConstr,
                                           LocWithParent *parentLoc) {
   SILType impactType;
   RuntimeEffect impact = getRuntimeEffect(inst, impactType);
   LocWithParent loc(inst->getLoc().getSourceLoc(), parentLoc);
 
-  if (module.getOptions().EmbeddedSwift &&
-      impact & RuntimeEffect::Existential) {
-    PrettyStackTracePerformanceDiagnostics stackTrace("existential", inst);
-    if (impactType) {
-      diagnose(loc, diag::embedded_swift_existential_type, impactType.getASTType());
-    } else {
-      diagnose(loc, diag::embedded_swift_existential);
+  if (module.getOptions().EmbeddedSwift) {
+    if (impact & RuntimeEffect::Existential) {
+      PrettyStackTracePerformanceDiagnostics stackTrace("existential", inst);
+      if (impactType) {
+        diagnose(loc, diag::embedded_swift_existential_type, impactType.getASTType());
+      } else {
+        diagnose(loc, diag::embedded_swift_existential);
+      }
+      return true;
+    }
+
+    if (impact & RuntimeEffect::MetaData) {
+      if (!allowedMetadataUseInEmbeddedSwift(inst)) {
+        PrettyStackTracePerformanceDiagnostics stackTrace("metatype", inst);
+        if (impactType) {
+          diagnose(loc, diag::embedded_swift_metatype_type, impactType.getASTType());
+        } else {
+          diagnose(loc, diag::embedded_swift_metatype);
+        }
+        return true;
+      }
     }
-    return true;
   }
 
   if (perfConstr == PerformanceConstraints::None)
@@ -512,7 +543,9 @@ void PerformanceDiagnostics::checkNonAnnotatedFunction(SILFunction *function) {
     for (SILInstruction &inst : block) {
       if (function->getModule().getOptions().EmbeddedSwift) {
         auto loc = LocWithParent(inst.getLoc().getSourceLoc(), nullptr);
-        visitInst(&inst, PerformanceConstraints::None, &loc);
+        if (visitInst(&inst, PerformanceConstraints::None, &loc)) {
+          LLVM_DEBUG(llvm::dbgs() << inst << *inst.getFunction());
+        }
       }
 
       auto as = FullApplySite::isa(&inst);

stdlib/public/core/ContiguousArrayBuffer.swift

@@ -302,14 +302,13 @@ internal struct _ContiguousArrayBuffer<Element>: _ArrayBufferProtocol {
       self = _ContiguousArrayBuffer<Element>()
     }
     else {
-      let storageType: _ContiguousArrayStorage<Element>.Type
       #if !$Embedded
-      storageType = getContiguousArrayStorageType(for: Element.self)
+      _storage = Builtin.allocWithTailElems_1(
+         getContiguousArrayStorageType(for: Element.self), realMinimumCapacity._builtinWordValue, Element.self)
       #else
-      storageType = _ContiguousArrayStorage<Element>.self
-      #endif
       _storage = Builtin.allocWithTailElems_1(
-         storageType, realMinimumCapacity._builtinWordValue, Element.self)
+         _ContiguousArrayStorage<Element>.self, realMinimumCapacity._builtinWordValue, Element.self)
+      #endif
 
       let storageAddr = UnsafeMutableRawPointer(Builtin.bridgeToRawPointer(_storage))
       let allocSize: Int?

test/embedded/metatypes.swift

@@ -0,0 +1,14 @@
+// RUN: %target-swift-emit-ir -verify %s -enable-experimental-feature Embedded -wmo
+
+// REQUIRES: optimized_stdlib
+// REQUIRES: VENDOR=apple
+// REQUIRES: OS=macosx
+
+public func sink<T>(t: T) {}
+
+public func test() -> Int {
+  let metatype = Int.self
+  sink(t: metatype) // expected-error {{cannot use metatype of type 'Int' in embedded Swift}}
+  // expected-note@-1 {{called from here}}
+  return 42
+}

test/embedded/typeof.swift

@@ -0,0 +1,25 @@
+// RUN: %target-swift-emit-ir -verify %s -enable-experimental-feature Embedded -wmo
+
+// REQUIRES: optimized_stdlib
+// REQUIRES: VENDOR=apple
+// REQUIRES: OS=macosx
+
+public func unsafeWriteArray<T, R>(_ elementType: R.Type, array: inout T, index n: Int, value: R) {
+  precondition(_isPOD(elementType))
+  precondition(_isPOD(type(of: array))) // expected-error {{cannot use metatype of type '(Int, Int, Int, Int)' in embedded Swift}}
+  // expected-note@-1 {{called from here}}
+
+  return withUnsafeMutableBytes(of: &array) { ptr in
+    let buffer = ptr.bindMemory(to: R.self)
+    precondition(n >= 0)
+    precondition(n < buffer.count)
+    buffer[n] = value
+  }
+}
+
+public func test() {
+  var args: (Int, Int, Int, Int) = (0, 0, 0, 0)
+  let n = 2
+  let value = 42
+  unsafeWriteArray(type(of: args.0), array: &args, index: n, value: value)
+}