Merge pull request #5292 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeEscapeEffects.swift

@@ -158,9 +158,9 @@ func addArgEffects(_ arg: FunctionArgument, argPath ap: SmallProjectionPath,
     effect = EscapeEffects.ArgumentEffect(.escapingToReturn(toPath, exclusive),
                                           argumentIndex: arg.index, pathPattern: argPath)
   case .toArgument(let toArgIdx, let toPath):
-    let exclusive = isExclusiveEscapeToArgument(fromArgument: arg, fromPath: argPath,
-                                                toArgumentIndex: toArgIdx, toPath: toPath, context)
-    effect = EscapeEffects.ArgumentEffect(.escapingToArgument(toArgIdx, toPath, exclusive),
+    // Exclusive argument -> argument effects cannot appear because such an effect would
+    // involve a store which is not permitted for exclusive escapes.
+    effect = EscapeEffects.ArgumentEffect(.escapingToArgument(toArgIdx, toPath, /*exclusive*/ false),
                                           argumentIndex: arg.index, pathPattern: argPath)
   }
   newEffects.append(effect)
@@ -197,25 +197,39 @@ private func isOperandOfRecursiveCall(_ op: Operand) -> Bool {
   return false
 }
 
-/// Returns true if when walking from the `toSelection` to the `fromArgument`,
-/// there are no other arguments or escape points than `fromArgument`. Also, the
-/// path at the `fromArgument` must match with `fromPath`.
+/// Returns true if when walking up from the `returnInst`, the `fromArgument` is the one
+/// and only argument which is reached - with a matching `fromPath`.
 private
 func isExclusiveEscapeToReturn(fromArgument: Argument, fromPath: SmallProjectionPath,
                                toPath: SmallProjectionPath,
                                returnInst: ReturnInst, _ context: FunctionPassContext) -> Bool {
-  struct IsExclusiveReturnEscapeVisitor : EscapeVisitor {
+  struct IsExclusiveReturnEscapeVisitor : EscapeVisitorWithResult {
     let fromArgument: Argument
     let fromPath: SmallProjectionPath
     let toPath: SmallProjectionPath
+    var result = false
 
     mutating func visitUse(operand: Operand, path: EscapePath) -> UseResult {
-      if operand.instruction is ReturnInst {
+      switch operand.instruction {
+      case is ReturnInst:
         if path.followStores { return .abort }
         if path.projectionPath.matches(pattern: toPath) {
           return .ignore
         }
         return .abort
+      case let si as StoringInstruction:
+        // Don't allow store instructions because this allows the EscapeUtils to walk up
+        // an apply result with `followStores`.
+        if operand == si.destinationOperand {
+          return .abort
+        }
+      case let ca as CopyAddrInst:
+        // `copy_addr` is like a store.
+        if operand == ca.destinationOperand {
+          return .abort
+        }
+      default:
+        break
       }
       return .continueWalk
     }
@@ -226,37 +240,12 @@ func isExclusiveEscapeToReturn(fromArgument: Argument, fromPath: SmallProjection
       }
       if path.followStores { return .abort }
       if arg == fromArgument && path.projectionPath.matches(pattern: fromPath) {
+        result = true
         return .walkDown
       }
       return .abort
     }
   }
   let visitor = IsExclusiveReturnEscapeVisitor(fromArgument: fromArgument, fromPath: fromPath, toPath: toPath)
-  return !returnInst.operand.at(toPath).isEscaping(using: visitor, context)
+  return returnInst.operand.at(toPath).visit(using: visitor, context) ?? false
 }
-
-private
-func isExclusiveEscapeToArgument(fromArgument: Argument, fromPath: SmallProjectionPath,
-                                 toArgumentIndex: Int, toPath: SmallProjectionPath, _ context: FunctionPassContext) -> Bool {
-  struct IsExclusiveArgumentEscapeVisitor : EscapeVisitor {
-    let fromArgument: Argument
-    let fromPath: SmallProjectionPath
-    let toArgumentIndex: Int
-    let toPath: SmallProjectionPath
-    
-    mutating func visitDef(def: Value, path: EscapePath) -> DefResult {
-      guard let arg = def as? FunctionArgument else {
-        return .continueWalkUp
-      }
-      if path.followStores { return .abort }
-      if arg == fromArgument && path.projectionPath.matches(pattern: fromPath) { return .walkDown }
-      if arg.index == toArgumentIndex && path.projectionPath.matches(pattern: toPath) { return .walkDown }
-      return .abort
-    }
-  }
-  let visitor = IsExclusiveArgumentEscapeVisitor(fromArgument: fromArgument, fromPath: fromPath,
-                                                 toArgumentIndex: toArgumentIndex, toPath: toPath)
-  let toArg = fromArgument.parentFunction.arguments[toArgumentIndex]
-  return !toArg.at(toPath).isEscapingWhenWalkingDown(using: visitor, context)
-}
-

SwiftCompilerSources/Sources/Optimizer/Utilities/EscapeUtils.swift

@@ -547,7 +547,9 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
     }
 
     // Indirect arguments cannot escape the function, but loaded values from such can.
-    if !followLoads(at: path.projectionPath) {
+    if !followLoads(at: path.projectionPath) &&
+       // Except for begin_apply: it can yield an address value.
+       !apply.isBeginApplyWithIndirectResults {
       return .continueWalk
     }
 
@@ -592,7 +594,8 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
     var matched = false
     for effect in effects.escapeEffects.arguments {
       switch effect.kind {
-      case .escapingToArgument(let toArgIdx, let toPath, let exclusive):
+      case .escapingToArgument(let toArgIdx, let toPath, _):
+        // Note: exclusive argument -> argument effects cannot appear, so we don't need to handle them here.
         if effect.matches(calleeArgIdx, argPath.projectionPath) {
           guard let callerToIdx = apply.callerArgIndex(calleeArgIndex: toArgIdx) else {
             return isEscaping
@@ -602,20 +605,6 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
           let arg = apply.arguments[callerToIdx]
 
           let p = Path(projectionPath: toPath, followStores: false, knownType: nil)
-          if walkUp(addressOrValue: arg, path: p) == .abortWalk {
-            return .abortWalk
-          }
-          matched = true
-        } else if toArgIdx == calleeArgIdx && argPath.projectionPath.matches(pattern: toPath) {
-          // Handle the reverse direction of an arg-to-arg escape.
-          guard let callerArgIdx = apply.callerArgIndex(calleeArgIndex: effect.argumentIndex) else {
-            return isEscaping
-          }
-          if !exclusive { return isEscaping }
-
-          let arg = apply.arguments[callerArgIdx]
-          let p = Path(projectionPath: effect.pathPattern, followStores: false, knownType: nil)
-
           if walkUp(addressOrValue: arg, path: p) == .abortWalk {
             return .abortWalk
           }
@@ -690,6 +679,14 @@ fileprivate struct EscapeWalker<V: EscapeVisitor> : ValueDefUseWalker,
     case let ap as ApplyInst:
       return walkUpApplyResult(apply: ap, path: path.with(knownType: nil))
     case is LoadInst, is LoadWeakInst, is LoadUnownedInst:
+      if !followLoads(at: path.projectionPath) {
+        // When walking up we shouldn't end up at a load where followLoads is false,
+        // because going from a (non-followLoads) address to a load always involves a class indirection.
+        // There is one exception: loading a raw pointer, e.g.
+        //   %l = load %a : $Builtin.RawPointer
+        //   %a = pointer_to_address %l           // the up-walk starts at %a
+        return isEscaping
+      }
       return walkUp(address: (def as! UnaryInstruction).operand,
                     path: path.with(followStores: true).with(knownType: nil))
     case let atp as AddressToPointerInst:
@@ -837,3 +834,13 @@ private extension SmallProjectionPath {
     EscapeUtilityTypes.EscapePath(projectionPath: self, followStores: false, knownType: nil)
   }
 }
+
+private extension ApplySite {
+  var isBeginApplyWithIndirectResults: Bool {
+    guard let ba = self as? BeginApplyInst else {
+      return false
+    }
+    // Note that the token result is always a non-address type.
+    return ba.results.contains { $0.type.isAddress }
+  }
+}

include/swift/AST/DiagnosticsParse.def

@@ -889,7 +889,7 @@ ERROR(expected_rangle_protocol,PointsToFirstBadToken,
       "expected '>' to complete protocol-constrained type", ())
 
 ERROR(deprecated_protocol_composition,none,
-      "'protocol<...>' composition syntax has been removed; join the protocols using '&'", ())
+      "'protocol<...>' composition syntax has been removed; join the type constraints using '&'", ())
 ERROR(deprecated_protocol_composition_single,none,
       "'protocol<...>' composition syntax has been removed and is not needed here", ())
 ERROR(deprecated_any_composition,none,

include/swift/AST/DiagnosticsSIL.def

@@ -748,6 +748,25 @@ ERROR(sil_moveonlychecker_exclusivity_violation, none,
 ERROR(sil_moveonlychecker_moveonly_field_consumed, none,
       "'%0' has a move only field that was consumed before later uses", (StringRef))
 
+ERROR(sil_moveonlychecker_notconsumable_but_assignable_was_consumed_classfield_let, none,
+      "'%0' was consumed but it is illegal to consume a noncopyable class let field. One can only read from it",
+      (StringRef))
+ERROR(sil_moveonlychecker_notconsumable_but_assignable_was_consumed_classfield_var, none,
+      "'%0' was consumed but it is illegal to consume a noncopyable class var field. One can only read from it or assign to it",
+      (StringRef))
+ERROR(sil_moveonlychecker_notconsumable_but_assignable_was_consumed_global_var, none,
+      "'%0' was consumed but it is illegal to consume a noncopyable global var. One can only read from it or assign to it",
+      (StringRef))
+ERROR(sil_moveonlychecker_notconsumable_but_assignable_was_consumed_global_let, none,
+      "'%0' was consumed but it is illegal to consume a noncopyable global let. One can only read from it",
+      (StringRef))
+ERROR(sil_moveonlychecker_notconsumable_but_assignable_was_consumed_escaping_let, none,
+      "'%0' was consumed but it is illegal to consume a noncopyable escaping immutable capture. One can only read from it",
+      (StringRef))
+ERROR(sil_moveonlychecker_notconsumable_but_assignable_was_consumed_escaping_var, none,
+      "'%0' was consumed but it is illegal to consume a noncopyable escaping mutable capture. One can only read from it or assign over it",
+      (StringRef))
+
 NOTE(sil_moveonlychecker_moveonly_field_consumed_here, none,
      "move only field consumed here", ())
 NOTE(sil_moveonlychecker_boundary_use, none,

include/swift/AST/DiagnosticsSema.def

@@ -3918,7 +3918,7 @@ ERROR(unresolved_member_no_inference,none,
 ERROR(cannot_infer_base_of_unresolved_member,none,
       "cannot infer contextual base in reference to member %0", (DeclNameRef))
 ERROR(cannot_infer_underlying_for_opaque_result,none,
-      "cannot infer underlying type for opaque result %0 from return expression",
+      "underlying type for opaque result type %0 could not be inferred from return expression",
       (Type))
 ERROR(unresolved_nil_literal,none,
       "'nil' requires a contextual type", ())

include/swift/IRGen/IRABIDetailsProvider.h

@@ -255,6 +255,9 @@ class IRABIDetailsProvider {
       Direct,
       /// An indirect call that can be made via a static offset in a vtable.
       IndirectVTableStaticOffset,
+      /// An indirect call that should be made via an offset relative to
+      /// external base value in a vtable.
+      IndirectVTableRelativeOffset,
       /// The call should be made via the provided thunk function.
       Thunk
     };
@@ -268,44 +271,73 @@ class IRABIDetailsProvider {
     }
 
     static MethodDispatchInfo indirectVTableStaticOffset(
-        size_t bitOffset, Optional<PointerAuthDiscriminator> discriminator) {
-      return MethodDispatchInfo(Kind::IndirectVTableStaticOffset, bitOffset, "",
+        size_t offset, Optional<PointerAuthDiscriminator> discriminator) {
+      return MethodDispatchInfo(Kind::IndirectVTableStaticOffset, offset, "",
                                 discriminator);
     }
 
+    static MethodDispatchInfo indirectVTableRelativeOffset(
+        size_t offset, std::string symbolName,
+        Optional<PointerAuthDiscriminator> discriminator) {
+      return MethodDispatchInfo(Kind::IndirectVTableRelativeOffset, offset,
+                                symbolName, discriminator);
+    }
+
     static MethodDispatchInfo thunk(std::string thunkName) {
       return MethodDispatchInfo(Kind::Thunk, 0, thunkName);
     }
 
     Kind getKind() const { return kind; }
-    size_t getStaticBitOffset() const {
+
+    /// Return the byte offset into the vtable from which the method pointer
+    /// should be loaded.
+    size_t getStaticOffset() const {
       assert(kind == Kind::IndirectVTableStaticOffset);
-      return bitOffset;
+      return offset;
     }
     Optional<PointerAuthDiscriminator> getPointerAuthDiscriminator() const {
-      assert(kind == Kind::IndirectVTableStaticOffset);
+      assert(kind == Kind::IndirectVTableStaticOffset ||
+             kind == Kind::IndirectVTableRelativeOffset);
       return discriminator;
     }
     StringRef getThunkSymbolName() const {
       assert(kind == Kind::Thunk);
-      return thunkName;
+      return symbolName;
+    }
+
+    /// Return the byte offset relative to base offset value into the vtable
+    /// from which the method pointer should be loaded.
+    size_t getRelativeOffset() const {
+      assert(kind == Kind::IndirectVTableRelativeOffset);
+      return offset;
+    }
+
+    /// Return the external symbol from which the relative base offset should be
+    /// loaded.
+    StringRef getBaseOffsetSymbolName() const {
+      assert(kind == Kind::IndirectVTableRelativeOffset);
+      return symbolName;
     }
 
   private:
-    MethodDispatchInfo(Kind kind, size_t bitOffset, std::string thunkName = "",
+    MethodDispatchInfo(Kind kind, size_t offset, std::string symbolName = "",
                        Optional<PointerAuthDiscriminator> discriminator = None)
-        : kind(kind), bitOffset(bitOffset), thunkName(thunkName),
+        : kind(kind), offset(offset), symbolName(symbolName),
           discriminator(discriminator) {}
 
     Kind kind;
-    size_t bitOffset;
-    std::string thunkName;
+    size_t offset;
+    std::string symbolName;
     Optional<PointerAuthDiscriminator> discriminator;
   };
 
   Optional<MethodDispatchInfo>
   getMethodDispatchInfo(const AbstractFunctionDecl *funcDecl);
 
+  /// Returns the type of the base offset value located at the specific class
+  /// base offset symbol.
+  Type getClassBaseOffsetSymbolType() const;
+
 private:
   std::unique_ptr<IRABIDetailsProviderImpl> impl;
 };

lib/AST/ASTMangler.cpp

@@ -3764,6 +3764,7 @@ void ASTMangler::appendMacroExpansionContext(
     outerExpansionDC = expansion->getDeclContext();
     discriminator = expansion->getDiscriminator();
     role = MacroRole::Declaration;
+    baseName = expansion->getMacroName().getBaseName();
     break;
   }
 
@@ -3799,6 +3800,17 @@ void ASTMangler::appendMacroExpansionContext(
     outerExpansionLoc = decl->getLoc();
     outerExpansionDC = decl->getDeclContext();
     discriminator = decl->getAttachedMacroDiscriminator(role, attr);
+
+    auto *macroDecl = evaluateOrDefault(
+        ctx.evaluator,
+        ResolveMacroRequest{const_cast<CustomAttr *>(attr),
+                            getAttachedMacroRoles(), outerExpansionDC},
+        nullptr);
+    if (macroDecl)
+      baseName = macroDecl->getBaseName();
+    else
+      baseName = ctx.getIdentifier("__unknown_macro__");
+
     break;
   }
 

lib/AST/ASTVerifier.cpp

@@ -26,6 +26,7 @@
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/Initializer.h"
+#include "swift/AST/MacroDiscriminatorContext.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Pattern.h"
@@ -233,7 +234,8 @@ class Verifier : public ASTWalker {
       ClosureDiscriminators;
   DeclContext *CanonicalTopLevelSubcontext = nullptr;
 
-  typedef std::pair<DeclContext *, Identifier> MacroExpansionDiscriminatorKey;
+  typedef std::pair</*MacroDiscriminatorContext*/const void *, Identifier>
+      MacroExpansionDiscriminatorKey;
   llvm::DenseMap<MacroExpansionDiscriminatorKey, SmallBitVector>
       MacroExpansionDiscriminators;
 
@@ -2410,9 +2412,8 @@ class Verifier : public ASTWalker {
     }
 
     void verifyChecked(MacroExpansionExpr *expansion) {
-      auto dc = getCanonicalDeclContext(expansion->getDeclContext());
       MacroExpansionDiscriminatorKey key{
-        dc,
+        MacroDiscriminatorContext::getParentOf(expansion).getOpaqueValue(),
         expansion->getMacroName().getBaseName().getIdentifier()
       };
       auto &discriminatorSet = MacroExpansionDiscriminators[key];
@@ -2433,9 +2434,8 @@ class Verifier : public ASTWalker {
     }
 
     void verifyChecked(MacroExpansionDecl *expansion) {
-      auto dc = getCanonicalDeclContext(expansion->getDeclContext());
       MacroExpansionDiscriminatorKey key{
-        dc,
+        MacroDiscriminatorContext::getParentOf(expansion).getOpaqueValue(),
         expansion->getMacroName().getBaseName().getIdentifier()
       };
       auto &discriminatorSet = MacroExpansionDiscriminators[key];

lib/AST/Decl.cpp

@@ -422,7 +422,15 @@ unsigned Decl::getAttachedMacroDiscriminator(
         foundDiscriminator = discriminator;
     });
 
-  return *foundDiscriminator;
+  if (foundDiscriminator)
+    return *foundDiscriminator;
+
+  // If that failed, conjure up a discriminator.
+  ASTContext &ctx = getASTContext();
+  assert(ctx.Diags.hadAnyError());
+  return ctx.getNextMacroDiscriminator(
+      MacroDiscriminatorContext::getParentOf(getLoc(), getDeclContext()),
+      DeclBaseName());
 }
 
 const Decl *Decl::getInnermostDeclWithAvailability() const {