Merge branch 'main' into fix-value-witness-table-type

Author: WANGJIEKE

.dir-locals.el

@@ -11,6 +11,7 @@
           (add-to-list 'load-path
                        (concat this-directory "utils")
                        :append)
+          (defvar swift-project-directory)
           (let ((swift-project-directory this-directory))
             (require 'swift-project-settings)))
         (set (make-local-variable 'swift-project-directory)

SwiftCompilerSources/CMakeLists.txt

@@ -230,18 +230,28 @@ else()
 
   add_subdirectory(Sources)
 
-  # This is a hack to get correct dependencies from imported C++ headers:
-  # step 1: generate a dummy source file, which just includes all headers defined in include/swift/module.modulemap
-  add_custom_command(
-    OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/HeaderDependencies.cpp"
-    COMMAND
-        "sed"
-        -n -e "/header/!d" -e "s/.*header/#include/" -e "w ${CMAKE_CURRENT_BINARY_DIR}/HeaderDependencies.cpp"
-        "${CMAKE_CURRENT_SOURCE_DIR}/../include/swift/module.modulemap"
-    DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/../include/swift/module.modulemap"
-    COMMENT "Generate HeaderDependencies.cpp"
-)
-  
+  # TODO: generate this dynamically through the modulemap; this cannot use `sed`
+  # as that is not available on all paltforms (e.g. Windows).
+  #
+  # step 1: generate a dummy source file, which just includes all headers
+  # defined in include/swift/module.modulemap
+  file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/HeaderDependencies.cpp"
+       "
+#include \"Basic/BridgedSwiftObject.h\"
+#include \"Basic/BasicBridging.h\"
+#include \"Basic/SourceLoc.h\"
+
+#include \"AST/ASTBridging.h\"
+#include \"AST/DiagnosticEngine.h\"
+#include \"AST/DiagnosticConsumer.h\"
+
+#include \"SIL/SILBridging.h\"
+
+#include \"SILOptimizer/OptimizerBridging.h\"
+
+#include \"Parse/RegexParserBridging.h\"
+")
+
   # step 2: build a library containing that source file. This library depends on all the included header files.
   #         The swift modules can now depend on that target.
   #         Note that this library is unused, i.e. not linked to anything.   

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/AccessDumper.swift

@@ -0,0 +1,68 @@
+//===--- AccessDumper.swift - Dump access information  --------------------===//
+//
+// 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
+
+/// Dumps access information for memory accesses (`load` and `store`)
+/// instructions.
+///
+/// This pass is used for testing `AccessUtils`.
+let accessDumper = FunctionPass(name: "dump-access", {
+  (function: Function, context: PassContext) in
+  print("Accesses for \(function.name)")
+
+  var apw = AccessPathWalker()
+  var arw = AccessStoragePathVisitor()
+  for block in function.blocks {
+    for instr in block.instructions {
+      switch instr {
+      case let st as StoreInst:
+        printAccessInfo(st.destinationOperand.value, &apw, &arw, context)
+      case let load as LoadInst:
+        printAccessInfo(load.operand, &apw, &arw, context)
+      default:
+        break
+      }
+    }
+  }
+
+  print("End accesses for \(function.name)")
+})
+
+private struct AccessStoragePathVisitor : AccessStoragePathWalker {
+  var walkUpCache = WalkerCache<Path>()
+  mutating func visit(access: AccessStoragePath) {
+    print("    Storage: \(access.storage)")
+    print("    Path: \"\(access.path)\"")
+  }
+}
+
+private func printAccessInfo(_ value: Value, _ apw: inout AccessPathWalker, _ aspw: inout AccessStoragePathVisitor,
+                             _ ctx: PassContext) {
+  print("Value: \(value)")
+  let (ap, scope) = apw.getAccessPathWithScope(of: value)
+  if let scope = scope {
+    switch scope {
+    case let .scope(ba):
+      print("  Scope: \(ba)")
+    case .base(_):
+      print("  Scope: base")
+    }
+  }
+
+  if let ap = ap {
+    print("  Base: \(ap.base)")
+    print("  Path: \"\(ap.projectionPath)\"")
+
+    aspw.getAccessStorage(for: ap)
+  }
+}

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt

@@ -8,6 +8,7 @@
 
 swift_compiler_sources(Optimizer
   AssumeSingleThreaded.swift
+  AccessDumper.swift
   ComputeEffects.swift
   EscapeInfoDumper.swift
   ObjCBridgingOptimization.swift

SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift

@@ -42,6 +42,7 @@ private func registerSwiftPasses() {
   registerPass(mergeCondFailsPass, { mergeCondFailsPass.run($0) })
   registerPass(escapeInfoDumper, { escapeInfoDumper.run($0) })
   registerPass(addressEscapeInfoDumper, { addressEscapeInfoDumper.run($0) })
+  registerPass(accessDumper, { accessDumper.run($0) })
   registerPass(computeEffects, { computeEffects.run($0) })
   registerPass(objCBridgingOptimization, { objCBridgingOptimization.run($0) })
   registerPass(stackPromotion, { stackPromotion.run($0) })