Merge pull request #4696 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift

@@ -16,26 +16,17 @@ import Basic
 
 public typealias DiagID = BridgedDiagID
 
-extension BridgedDiagnosticArgument {
-  init(stringRef val: BridgedStringRef) {
-    self.init(kind: .stringRef, value: .init(stringRefValue: val))
-  }
-  init(int val: Int) {
-    self.init(kind: .int, value: .init(intValue: val))
-  }
-}
-
 public protocol DiagnosticArgument {
-  func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void)
+  func _withBridgedDiagnosticArgument(_ fn: (swift.DiagnosticArgument) -> Void)
 }
 extension String: DiagnosticArgument {
-  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
-    withBridgedStringRef { fn(BridgedDiagnosticArgument(stringRef: $0)) }
+  public func _withBridgedDiagnosticArgument(_ fn: (swift.DiagnosticArgument) -> Void) {
+    withBridgedStringRef { fn(swift.DiagnosticArgument(llvm.StringRef($0))) }
   }
 }
 extension Int: DiagnosticArgument {
-  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
-    fn(BridgedDiagnosticArgument(int: self))
+  public func _withBridgedDiagnosticArgument(_ fn: (swift.DiagnosticArgument) -> Void) {
+    fn(swift.DiagnosticArgument(Int32(self)))
   }
 }
 
@@ -82,7 +73,7 @@ public struct DiagnosticEngine {
 
     let bridgedSourceLoc: swift.SourceLoc = position.bridged
     let bridgedHighlightRange: swift.CharSourceRange = highlight.bridged
-    var bridgedArgs: [BridgedDiagnosticArgument] = []
+    var bridgedArgs: [swift.DiagnosticArgument] = []
     var bridgedFixIts: [swift.DiagnosticInfo.FixIt] = []
 
     // Build a higher-order function to wrap every 'withBridgedXXX { ... }'

SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockSet.swift

@@ -8,7 +8,7 @@
 
 swift_compiler_sources(Optimizer
   BasicBlockRange.swift
-  BasicBlockSet.swift
   BasicBlockWorklist.swift
   InstructionRange.swift
+  Set.swift
   Stack.swift)

SwiftCompilerSources/Sources/Optimizer/DataStructures/CMakeLists.txt

@@ -46,12 +46,12 @@ struct InstructionRange : CustomStringConvertible, CustomReflectable {
   /// The underlying block range.
   private(set) var blockRange: BasicBlockRange
 
-  private var insertedInsts: Set<Instruction>
+  private var insertedInsts: InstructionSet
 
   init(begin beginInst: Instruction, _ context: PassContext) {
     self.begin = beginInst
-    self.insertedInsts = Set<Instruction>()
     self.blockRange = BasicBlockRange(begin: beginInst.block, context)
+    self.insertedInsts = InstructionSet(context)
   }
 
   /// Insert a potential end instruction.
@@ -143,6 +143,7 @@ struct InstructionRange : CustomStringConvertible, CustomReflectable {
 
   /// TODO: once we have move-only types, make this a real deinit.
   mutating func deinitialize() {
+    insertedInsts.deinitialize()
     blockRange.deinitialize()
   }
 }

SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift

@@ -0,0 +1,170 @@
+//===--- Set.swift - sets for basic blocks, values and instructions -------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2022 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SIL
+import OptimizerBridging
+
+/// A set of basic blocks.
+///
+/// This is an extremely efficient implementation which does not need memory
+/// allocations or hash lookups.
+///
+/// This type should be a move-only type, but unfortunately we don't have move-only
+/// types yet. Therefore it's needed to call `deinitialize()` explicitly to
+/// destruct this data structure, e.g. in a `defer {}` block.
+struct BasicBlockSet : CustomStringConvertible, CustomReflectable {
+
+  private let context: PassContext
+  private let bridged: BridgedBasicBlockSet
+    
+  init(_ context: PassContext) {
+    self.context = context
+    self.bridged = PassContext_allocBasicBlockSet(context._bridged)
+  }
+
+  func contains(_ block: BasicBlock) -> Bool {
+    BasicBlockSet_contains(bridged, block.bridged) != 0
+  }
+
+  mutating func insert(_ block: BasicBlock) {
+    BasicBlockSet_insert(bridged, block.bridged)
+  }
+
+  mutating func erase(_ block: BasicBlock) {
+    BasicBlockSet_erase(bridged, block.bridged)
+  }
+
+  var description: String {
+    let function = BasicBlockSet_getFunction(bridged).function
+    let blockNames = function.blocks.enumerated().filter { contains($0.1) }
+                                                 .map { "bb\($0.0)"}
+    return "{" + blockNames.joined(separator: ", ") + "}"
+  }
+
+  var customMirror: Mirror { Mirror(self, children: []) }
+
+  /// TODO: once we have move-only types, make this a real deinit.
+  mutating func deinitialize() {
+    PassContext_freeBasicBlockSet(context._bridged, bridged)
+  }
+}
+
+/// A set of values.
+///
+/// This is an extremely efficient implementation which does not need memory
+/// allocations or hash lookups.
+///
+/// This type should be a move-only type, but unfortunately we don't have move-only
+/// types yet. Therefore it's needed to call `deinitialize()` explicitly to
+/// destruct this data structure, e.g. in a `defer {}` block.
+struct ValueSet : CustomStringConvertible, CustomReflectable {
+
+  private let context: PassContext
+  private let bridged: BridgedNodeSet
+    
+  init(_ context: PassContext) {
+    self.context = context
+    self.bridged = PassContext_allocNodeSet(context._bridged)
+  }
+
+  func contains(_ value: Value) -> Bool {
+    NodeSet_containsValue(bridged, value.bridged) != 0
+  }
+
+  mutating func insert(_ value: Value) {
+    NodeSet_insertValue(bridged, value.bridged)
+  }
+
+  mutating func erase(_ value: Value) {
+    NodeSet_eraseValue(bridged, value.bridged)
+  }
+
+  var description: String {
+    let function = NodeSet_getFunction(bridged).function
+    var d = "{\n"
+    for block in function.blocks {
+      for arg in block.arguments {
+        if contains(arg) {
+          d += arg.description
+        }
+      }
+      for inst in block.instructions {
+        for result in inst.results {
+          if contains(result) {
+            d += result.description
+          }
+        }
+      }
+    }
+    d += "}\n"
+    return d
+  }
+
+  var customMirror: Mirror { Mirror(self, children: []) }
+
+  /// TODO: once we have move-only types, make this a real deinit.
+  mutating func deinitialize() {
+    PassContext_freeNodeSet(context._bridged, bridged)
+  }
+}
+
+/// A set of instructions.
+///
+/// This is an extremely efficient implementation which does not need memory
+/// allocations or hash lookups.
+///
+/// This type should be a move-only type, but unfortunately we don't have move-only
+/// types yet. Therefore it's needed to call `deinitialize()` explicitly to
+/// destruct this data structure, e.g. in a `defer {}` block.
+struct InstructionSet : CustomStringConvertible, CustomReflectable {
+
+  private let context: PassContext
+  private let bridged: BridgedNodeSet
+    
+  init(_ context: PassContext) {
+    self.context = context
+    self.bridged = PassContext_allocNodeSet(context._bridged)
+  }
+
+  func contains(_ inst: Instruction) -> Bool {
+    NodeSet_containsInstruction(bridged, inst.bridged) != 0
+  }
+
+  mutating func insert(_ inst: Instruction) {
+    NodeSet_insertInstruction(bridged, inst.bridged)
+  }
+
+  mutating func erase(_ inst: Instruction) {
+    NodeSet_eraseInstruction(bridged, inst.bridged)
+  }
+
+  var description: String {
+    let function = NodeSet_getFunction(bridged).function
+    var d = "{\n"
+    for block in function.blocks {
+      for inst in block.instructions {
+        if contains(inst) {
+          d += inst.description
+        }
+      }
+    }
+    d += "}\n"
+    return d
+  }
+
+  var customMirror: Mirror { Mirror(self, children: []) }
+
+  /// TODO: once we have move-only types, make this a real deinit.
+  mutating func deinitialize() {
+    PassContext_freeNodeSet(context._bridged, bridged)
+  }
+}

SwiftCompilerSources/Sources/Optimizer/DataStructures/Set.swift

@@ -15,6 +15,7 @@
 
 #include "swift/Basic/BasicBridging.h"
 #include "swift/Basic/Compiler.h"
+#include "swift/AST/DiagnosticEngine.h"
 #include <stdbool.h>
 #include <stddef.h>
 
@@ -38,19 +39,6 @@ typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedDiagID : uint32_t {
 #include "swift/AST/DiagnosticsAll.def"
 } BridgedDiagID;
 
-typedef enum ENUM_EXTENSIBILITY_ATTR(open) BridgedDiagnosticArgumentKind {
-  BridgedDiagnosticArgumentKind_StringRef,
-  BridgedDiagnosticArgumentKind_Int,
-} BridgedDiagnosticArgumentKind;
-
-typedef struct {
-  BridgedDiagnosticArgumentKind kind;
-  union {
-    BridgedStringRef stringRefValue;
-    SwiftInt intValue;
-  } value;
-} BridgedDiagnosticArgument;
-
 typedef struct {
   void * _Nonnull object;
 } BridgedDiagnosticEngine;

include/swift/AST/ASTBridging.h

@@ -377,11 +377,6 @@ WARNING(warning_module_shadowing_may_break_module_interface,none,
         /*shadowedModule=*/ModuleDecl *, /*interfaceModule*/ModuleDecl *))
 REMARK(rebuilding_module_from_interface,none,
        "rebuilding module '%0' from interface '%1'", (StringRef, StringRef))
-REMARK(rebuilding_stdlib_from_interface,none,
-       "did not find a prebuilt standard library for target '%0' compatible "
-       "with this Swift compiler; building it may take a few minutes, but it "
-       "should only happen once for this combination of compiler and target",
-       (StringRef))
 NOTE(sdk_version_pbm_version,none,
      "SDK build version is '%0'; prebuilt modules were "
      "built using SDK build version: '%1'", (StringRef, StringRef))

include/swift/AST/DiagnosticsFrontend.def

@@ -1690,7 +1690,7 @@ class TypeRefBuilder {
     // is an offset to a TypeRef string, read it.
     auto readRequirementTypeRefAddress =
         [&](uintptr_t offsetFromOpaqueDescBase,
-            uintptr_t requirementAddress) -> uint32_t {
+            uintptr_t requirementAddress) -> uintptr_t {
       std::string typeRefString = "";
       auto fieldOffsetOffset = requirementAddress + offsetFromOpaqueDescBase -
                                (uintptr_t)opaqueTypeDescriptor;