8 Commits

Author	SHA1	Message	Date
Anton Korobeynikov	5b0746f967	Fix two Wasm test harness issues and re-enable more autodiff tests (#86931) ... - Correctly construct cmake cmdline for wasmstdlib including cmake common host options. This is required in order to include e.g. `CMAKE_OSX_SYSROOT` on macOS, etc. - Ensure we're passing path to newly-built SDK to sil-opt This makes almost every AutoDiff tests passing for Wasm target (the only exception is `AutoDiff/validation-test/always_emit_into_client/multi_module_struct_no_jvp.swift` as `expectCrash()` is not working properly on Wasm.	2026-02-09 19:15:52 -08:00
Erik Eckstein	18063707b5	Optimizer: enable complete OSSA lifetimes throughout the pass pipeline ... This new OSSA invariant simplifies many optimizations because they don't have to take care of the corner case of incomplete lifetimes in dead-end blocks. The implementation basically consists of these changes: * add the lifetime completion utility * add a flag in SILFunction which tells optimization that they need to run the lifetime completion utility * let all optimizations complete lifetimes if necessary * enable the ownership verifier to check complete lifetimes	2026-01-22 17:41:48 +01:00
Max Desiatov	a0741478d3	AutoDiff: add UNSUPPORTED: OS=wasip1 where needed	2026-01-21 13:09:15 +00:00
Daniil Kovalev	1f77138afe	[AutoDiff] Closure specialization: specialize branch tracing enums (#85757) ... This patch contains part of the changes intended to resolve #68944. 1. Closure info gathering logic. 2. Branch tracing enum specialization logic. 3. Specialization of branch tracing enum basic block arguments in VJP. 4. Specialization of branch tracing enum payload basic block arguments in pullback. Note that mangling-related logic is implemented in C++ since at this moment we have no Swift bridged for that. Here is a simplified example of how branch tracing enum (BTE) specialization looks like. Before specialization: ``` enum $_AD__xxx { case bb0(((Float) -> Float)) } func vjp(...) { // ... %foo = function_ref $foo : (Float, Float) -> Float %pa1 = partial_apply %foo(%arg1) : (Float) -> Float %payload1 = tuple (%pa1) : ((Float) -> Float) %bte = enum $_AD__xxx.bb0!enumelt, %payload1 // ... } func pullback(%bte, ...) { // ... %payload2 = unchecked_enum_data %bte, $_AD__xxx.bb0!enumelt : ((Float) -> Float) %pa2 = tuple_extract %payload2, 0 : (Float) -> Float %res = apply %pa2(%arg2) : Float // ... } ``` After specialization: ``` enum $_AD__xxx_spec_bb0_0 { case bb0(((Float))) } func vjp(...) { // ... %captured1 = tuple (%arg1) : (Float) %payload1 = tuple (%captured1) : ((Float)) %bte_spec = enum $_AD__xxx_spec_bb0_0.bb0!enumelt, %payload1 // ... } func pullback_spec(%bte_spec, ...) { // ... %payload2 = unchecked_enum_data %bte, $_AD__xxx_spec_bb0_0.bb0!enumelt : ((Float)) %captured2 = tuple_extract %payload2, 0 : (Float) %arg1 = tuple_extract %captured2, 0 : Float %foo = function_ref $foo : (Float, Float) -> Float %res = apply %foo(%arg2, %arg1) : Float // ... } ```	2025-12-21 00:33:50 +00:00
Erik Eckstein	df20d36255	ClosureSpecialization: support for OSSA and a big overhaul ... Beside supporting OSSA, this change significantly simplifies the pass. The main change is that instead of starting at a closure (e.g. `partial_apply`) and finding all call sites, we now start at a call site and look for closures for all arguments. This makes a lot of things much simpler, e.g. not so many intermediate data structures are required to track all the states. I needed to remove the 3 unit tests because the things those tests were testing are not there anymore. However, the pass is tested with a lot of sil tests (and I added quite a few), which should give good test coverage. The old ClosureSpecializer pass is still kept in place, because at that point in the pipeline we don't have OSSA, yet. Once we have that, we can replace the old pass withe the new one. However, the autodiff closure specializer already runs in the OSSA pipeline and there the new changes take effect.	2025-10-06 12:02:48 +02:00
Arnold Schwaighofer	25a071efc8	Add experimental feature @inline(always) ... The intent for `@inline(always)` is to act as an optimization control. The user can rely on inlining to happen or the compiler will emit an error message. Because function values can be dynamic (closures, protocol/class lookup) this guarantee can only be upheld for direct function references. In cases where the optimizer can resolve dynamic function values the attribute shall be respected. rdar://148608854	2025-09-30 08:36:26 -07:00
Meghana Gupta	ce6ac88813	Enable test for 64bit platforms only	2025-07-08 06:43:32 -07:00
Daniil Kovalev	5528cf1cc4	[AutoDiff] Run AutoDiff closure spec pass for all VJPs (#81548) ... Previously, AutoDiff closure specialization pass was triggered only on VJPs containing single basic block. However, the pass logic allows running on arbitrary VJPs. This PR enables the pass for all VJPs unconditionally. So, if the pullback corresponding to multiple-BB VJP accepts some closures directly as arguments, these closures might become specialized by the pass. Closures passed via payload of branch tracing enum are not specialized - this is subject for future changes. The PR contains several commits. 1. The thing named "call site" in the code is partial_apply of pullback corresponding to the VJP. This might appear only once, so we drop support for multiple "call sites". 2. Enhance existing SILOptimizer tests for the pass. 3. Add validation-tests for single basic block case. 4. The change itself - delete check against single basic block. 5. Add validation-tests for multiple basic block case. 6. Add SILOptimizer tests for multiple basic block case.	2025-07-07 13:00:14 +00:00