[pull] swiftwasm from main

SwiftCompilerSources/CMakeLists.txt

@@ -227,7 +227,7 @@ else()
   add_subdirectory(Sources)
 
   # TODO: generate this dynamically through the modulemap; this cannot use `sed`
-  # as that is not available on all paltforms (e.g. Windows).
+  # as that is not available on all platforms (e.g. Windows).
   #
   # step 1: generate a dummy source file, which just includes all headers
   # defined in include/swift/module.modulemap

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/InitializeStaticGlobals.swift

@@ -63,6 +63,7 @@ let initializeStaticGlobalsPass = FunctionPass(name: "initialize-static-globals"
 
   context.erase(instruction: allocInst)
   context.erase(instruction: storeToGlobal)
+  context.removeTriviallyDeadInstructionsIgnoringDebugUses(in: function)
 }
 
 /// Analyses the global initializer function and returns the `alloc_global` and `store`

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/CMakeLists.txt

@@ -16,9 +16,11 @@ swift_compiler_sources(Optimizer
   SimplifyDebugStep.swift
   SimplifyDestructure.swift
   SimplifyGlobalValue.swift
+  SimplifyInitEnumDataAddr.swift
   SimplifyLoad.swift
   SimplifyPartialApply.swift
   SimplifyStrongRetainRelease.swift
   SimplifyStructExtract.swift
   SimplifyTupleExtract.swift
-  SimplifyUncheckedEnumData.swift)
+  SimplifyUncheckedEnumData.swift
+  SimplifyValueToBridgeObject.swift)

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyInitEnumDataAddr.swift

@@ -0,0 +1,53 @@
+//===--- SimplifyInitEnumDataAddr.swift -----------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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
+
+extension InitEnumDataAddrInst : OnoneSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+
+    // Optimize the sequence
+    // ```
+    //   %1 = init_enum_data_addr %enum_addr, #someCaseWithPayload
+    //   store %payload to %1
+    //   inject_enum_addr %enum_addr, #someCaseWithPayload
+    // ```
+    // to
+    // ```
+    //   %1 = enum  $E, #someCaseWithPayload, %payload
+    //   store %1 to %enum_addr
+    // ```
+    // This sequence of three instructions must appear in consecutive order.
+    // But usually this is the case, because it's generated this way by SILGen.
+    //
+    if let nextInst = self.next,
+       let store = nextInst as? StoreInst,
+       store.destination == self,
+       let singleUse = self.uses.singleUse,
+       singleUse.instruction == store,
+       let nextAfterStore = store.next,
+       let inject = nextAfterStore as? InjectEnumAddrInst,
+       inject.enum == self.enum,
+       inject.enum.type.isLoadable(in: parentFunction) {
+
+      assert(self.caseIndex == inject.caseIndex, "mismatching case indices when creating an enum")
+
+      let builder = Builder(before: store, context)
+      let enumInst = builder.createEnum(caseIndex: self.caseIndex, payload: store.source, enumType: self.enum.type.objectType)
+      let storeOwnership = StoreInst.Ownership(for: self.enum.type, in: parentFunction, initialize: true)
+      builder.createStore(source: enumInst, destination: self.enum, ownership: storeOwnership)
+      context.erase(instruction: store)
+      context.erase(instruction: inject)
+      context.erase(instruction: self)
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/InstructionSimplification/SimplifyValueToBridgeObject.swift

@@ -0,0 +1,38 @@
+//===--- SimplifyValueToBridgeObject.swift --------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2023 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
+
+extension ValueToBridgeObjectInst : OnoneSimplifyable {
+  func simplify(_ context: SimplifyContext) {
+
+    // Optimize the sequence
+    // ```
+    //   %1 = value_to_bridge_object %0
+    //   %2 = struct $SomeInt (%1)
+    //   %3 = unchecked_trivial_bit_cast %2
+    //   %4 = struct_extract %3, #valueFieldInInt
+    //   %5 = value_to_bridge_object %4
+    // ```
+    // to
+    // ```
+    //   %5 = value_to_bridge_object %0
+    // ```
+    // This sequence comes up in the code for constructing an empty string literal.
+    //
+    if let se = self.value as? StructExtractInst,
+       let utbc = se.struct as? UncheckedTrivialBitCastInst,
+       let vtbo = utbc.fromValue as? ValueToBridgeObjectInst {
+      self.operand.set(to: vtbo.value, context)
+    }
+  }
+}

SwiftCompilerSources/Sources/Optimizer/PassManager/Context.swift

@@ -168,8 +168,7 @@ struct FunctionPassContext : MutatingContext {
   var notifyInstructionChanged: (Instruction) -> () { return { inst in } }
 
   func continueWithNextSubpassRun(for inst: Instruction? = nil) -> Bool {
-    let bridgedInst = OptionalBridgedInstruction(inst?.bridged.obj)
-    return _bridged.continueWithNextSubpassRun(bridgedInst)
+    return _bridged.continueWithNextSubpassRun(inst.bridged)
   }
 
   func createSimplifyContext(preserveDebugInfo: Bool, notifyInstructionChanged: @escaping (Instruction) -> ()) -> SimplifyContext {

SwiftCompilerSources/Sources/SIL/Builder.swift

@@ -113,7 +113,7 @@ public struct Builder {
     return notifyNew(cast.getAs(UpcastInst.self))
   }
 
-  public func createLoad(fromAddress: Value, ownership: LoadInst.LoadOwnership) -> LoadInst {
+  public func createLoad(fromAddress: Value, ownership: LoadInst.Ownership) -> LoadInst {
     let load = bridged.createLoad(fromAddress.bridged, ownership.rawValue)
     return notifyNew(load.getAs(LoadInst.self))
   }
@@ -184,6 +184,12 @@ public struct Builder {
     let ued = bridged.createUncheckedEnumData(enumVal.bridged, caseIndex, resultType.bridged)
     return notifyNew(ued.getAs(UncheckedEnumDataInst.self))
   }
+
+  public func createEnum(caseIndex: Int, payload: Value?, enumType: Type) -> EnumInst {
+    let enumInst = bridged.createEnum(caseIndex, payload.bridged, enumType.bridged)
+    return notifyNew(enumInst.getAs(EnumInst.self))
+  }
+
   @discardableResult
   public func createSwitchEnum(enum enumVal: Value,
                                cases: [(Int, BasicBlock)],
@@ -225,20 +231,23 @@ public struct Builder {
     return notifyNew(bridged.createGlobalValue(global.bridged).getAs(GlobalValueInst.self))
   }
 
-  @discardableResult
   public func createStruct(type: Type, elements: [Value]) -> StructInst {
     let structInst = elements.withBridgedValues { valuesRef in
       return bridged.createStruct(type.bridged, valuesRef)
     }
     return notifyNew(structInst.getAs(StructInst.self))
   }
 
-  @discardableResult
   public func createTuple(type: Type, elements: [Value]) -> TupleInst {
     let tuple = elements.withBridgedValues { valuesRef in
       return bridged.createTuple(type.bridged, valuesRef)
     }
     return notifyNew(tuple.getAs(TupleInst.self))
   }
 
+  @discardableResult
+  public func createStore(source: Value, destination: Value, ownership: StoreInst.Ownership) -> StoreInst {
+    let store = bridged.createStore(source.bridged, destination.bridged, ownership.rawValue)
+    return notifyNew(store.getAs(StoreInst.self))
+  }
 }

SwiftCompilerSources/Sources/SIL/GlobalVariable.swift

@@ -123,6 +123,7 @@ extension Instruction {
       return !fri.referencedFunction.isAsync
     case is StructInst,
          is TupleInst,
+         is EnumInst,
          is IntegerLiteralInst,
          is FloatLiteralInst,
          is ObjectInst,

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -148,6 +148,12 @@ extension OptionalBridgedInstruction {
   }
 }
 
+extension Optional where Wrapped == Instruction {
+  public var bridged: OptionalBridgedInstruction {
+    OptionalBridgedInstruction(self?.bridged.obj)
+  }
+}
+
 public class SingleValueInstruction : Instruction, Value {
   final public var definingInstruction: Instruction? { self }
 
@@ -222,11 +228,23 @@ extension StoringInstruction {
 
 final public class StoreInst : Instruction, StoringInstruction {
   // must match with enum class StoreOwnershipQualifier
-  public enum StoreOwnership: Int {
+  public enum Ownership: Int {
     case unqualified = 0, initialize = 1, assign = 2, trivial = 3
+
+    public init(for type: Type, in function: Function, initialize: Bool) {
+      if function.hasOwnership {
+        if type.isTrivial(in: function) {
+          self = .trivial
+        } else {
+          self = initialize ? .initialize : .assign
+        }
+      } else {
+        self = .unqualified
+      }
+    }
   }
-  public var destinationOwnership: StoreOwnership {
-    StoreOwnership(rawValue: bridged.StoreInst_getStoreOwnership())!
+  public var destinationOwnership: Ownership {
+    Ownership(rawValue: bridged.StoreInst_getStoreOwnership())!
   }
 }
 
@@ -307,6 +325,7 @@ final public class DestroyAddrInst : Instruction, UnaryInstruction {
 }
 
 final public class InjectEnumAddrInst : Instruction, UnaryInstruction, EnumInstruction {
+  public var `enum`: Value { operand.value }
   public var caseIndex: Int { bridged.InjectEnumAddrInst_caseIndex() }
 }
 
@@ -351,11 +370,11 @@ final public class LoadInst : SingleValueInstruction, UnaryInstruction {
   public var address: Value { operand.value }
 
   // must match with enum class LoadOwnershipQualifier
-  public enum LoadOwnership: Int {
+  public enum Ownership: Int {
     case unqualified = 0, take = 1, copy = 2, trivial = 3
   }
-  public var ownership: LoadOwnership {
-    LoadOwnership(rawValue: bridged.LoadInst_getLoadOwnership())!
+  public var ownership: Ownership {
+    Ownership(rawValue: bridged.LoadInst_getLoadOwnership())!
   }
 }
 
@@ -388,6 +407,10 @@ final public class UncheckedAddrCastInst : SingleValueInstruction, UnaryInstruct
   public var fromAddress: Value { operand.value }
 }
 
+final public class UncheckedTrivialBitCastInst : SingleValueInstruction, UnaryInstruction {
+  public var fromValue: Value { operand.value }
+}
+
 final public
 class RawPointerToRefInst : SingleValueInstruction, UnaryInstruction {
   public var pointer: Value { operand.value }
@@ -626,7 +649,9 @@ final public
 class ObjCMetatypeToObjectInst : SingleValueInstruction, UnaryInstruction {}
 
 final public
-class ValueToBridgeObjectInst : SingleValueInstruction, UnaryInstruction {}
+class ValueToBridgeObjectInst : SingleValueInstruction, UnaryInstruction {
+  public var value: Value { return operand.value }
+}
 
 final public
 class MarkDependenceInst : SingleValueInstruction {

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -77,6 +77,7 @@ public func registerSILClasses() {
   register(UpcastInst.self)
   register(UncheckedRefCastInst.self)
   register(UncheckedAddrCastInst.self)
+  register(UncheckedTrivialBitCastInst.self)
   register(MarkMustCheckInst.self)
   register(ObjectInst.self)
   register(RawPointerToRefInst.self)

SwiftCompilerSources/Sources/SIL/Type.swift

@@ -31,6 +31,10 @@ public struct Type : CustomStringConvertible, NoReflectionChildren {
     return !bridged.isNonTrivialOrContainsRawPointer(function.bridged.getFunction())
   }
 
+  public func isLoadable(in function: Function) -> Bool {
+    return bridged.isLoadable(function.bridged.getFunction())
+  }
+
   public func isReferenceCounted(in function: Function) -> Bool {
     return bridged.isReferenceCounted(function.bridged.getFunction())
   }

SwiftCompilerSources/Sources/SIL/Value.swift

@@ -204,3 +204,9 @@ final class PlaceholderValue : Value {
 extension OptionalBridgedValue {
   public var value: Value? { obj.getAs(AnyObject.self) as? Value }
 }
+
+extension Optional where Wrapped == Value {
+  public var bridged: OptionalBridgedValue {
+    OptionalBridgedValue(obj: self?.bridged.obj)
+  }
+}

cmake/modules/AddPureSwift.cmake

@@ -261,9 +261,15 @@ function(add_pure_swift_host_tool name)
   add_executable(${name} ${APSHT_SOURCES})
   _add_host_swift_compile_options(${name})
 
-  set_property(TARGET ${name}
-    APPEND PROPERTY INSTALL_RPATH
-      "@executable_path/../lib/swift/host")
+  if(${SWIFT_HOST_VARIANT_SDK} IN_LIST SWIFT_DARWIN_PLATFORMS)
+    set_property(TARGET ${name}
+      APPEND PROPERTY INSTALL_RPATH
+        "@executable_path/../lib/swift/host")
+  else()
+    set_property(TARGET ${name}
+      APPEND PROPERTY INSTALL_RPATH
+        "$ORIGIN/../lib/swift/host")
+  endif()
 
   set_property(TARGET ${name}
     PROPERTY BUILD_WITH_INSTALL_RPATH YES)

cmake/modules/AddSwift.cmake

@@ -576,7 +576,7 @@ function(_add_swift_runtime_link_flags target relpath_to_lib_dir bootstrapping)
     # Make sure we can find the early SwiftSyntax libraries.
     target_link_directories(${target} PRIVATE "${SWIFT_PATH_TO_EARLYSWIFTSYNTAX_BUILD_DIR}/lib/swift/host")
 
-    # For the "end step" of bootstrapping configurations on Darwin, need to be
+    # For the "end step" of bootstrapping configurations, we need to be
     # able to fall back to the SDK directory for libswiftCore et al.
     if (BOOTSTRAPPING_MODE MATCHES "BOOTSTRAPPING.*")
       if (NOT "${bootstrapping}" STREQUAL "1")
@@ -590,6 +590,13 @@ function(_add_swift_runtime_link_flags target relpath_to_lib_dir bootstrapping)
           get_filename_component(TOOLCHAIN_BIN_DIR ${SWIFT_EXEC_FOR_SWIFT_MODULES} DIRECTORY)
           get_filename_component(TOOLCHAIN_LIB_DIR "${TOOLCHAIN_BIN_DIR}/../lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}" ABSOLUTE)
           target_link_directories(${target} PUBLIC ${TOOLCHAIN_LIB_DIR})
+        else()
+          get_filename_component(swift_bin_dir ${SWIFT_EXEC_FOR_SWIFT_MODULES} DIRECTORY)
+          get_filename_component(swift_dir ${swift_bin_dir} DIRECTORY)
+          set(host_lib_dir "${swift_dir}/lib/swift/${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_LIB_SUBDIR}")
+          target_link_directories(${target} PRIVATE ${host_lib_dir})
+
+          set(swift_runtime_rpath "${host_lib_dir}")
         endif()
       endif()
     endif()
@@ -926,10 +933,17 @@ function(add_swift_host_tool executable)
       endif()
     endif()
 
-    set_property(
-      TARGET ${executable}
-      APPEND PROPERTY INSTALL_RPATH
-        "@executable_path/../${extra_relative_rpath}lib/swift/host")
+    if(${SWIFT_HOST_VARIANT_SDK} IN_LIST SWIFT_DARWIN_PLATFORMS)
+      set_property(
+        TARGET ${executable}
+        APPEND PROPERTY INSTALL_RPATH
+          "@executable_path/../${extra_relative_rpath}lib/swift/host")
+    else()
+      set_property(
+        TARGET ${executable}
+        APPEND PROPERTY INSTALL_RPATH
+          "$ORIGIN/../${extra_relative_rpath}lib/swift/host")
+    endif()
   endif()
 
   if(ASHT_THINLTO_LD64_ADD_FLTO_CODEGEN_ONLY)

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -832,6 +832,12 @@ Fully bypasses access control, allowing access to private declarations
 in the imported module. The imported module needs to be compiled with
 `-Xfrontend -enable-private-imports` for this to work.
 
+## `@_section("section_name")`
+
+Places a global variable or a top-level function into a section of the object
+file with the given name. It's the equivalent of clang's
+`__attribute__((section))`.
+
 ## `@_semantics("uniquely.recognized.id")`
 
 Allows the optimizer to make use of some key invariants in performance critical
@@ -994,6 +1000,12 @@ for more details.
 
 This `async` function uses the pre-SE-0338 semantics of unsafely inheriting the caller's executor.  This is an underscored feature because the right way of inheriting an executor is to pass in the required executor and switch to it.  Unfortunately, there are functions in the standard library which need to inherit their caller's executor but cannot change their ABI because they were not defined as `@_alwaysEmitIntoClient` in the initial release.
 
+## `@_used`
+
+Marks a global variable or a top-level function as "used externally" even if it
+does not have visible users in the compilation unit. It's the equivalent of
+clang's `__attribute__((used))`.
+
 ## `@_weakLinked`
 
 Allows a declaration to be weakly-referenced, i.e., any references emitted by