Snapshots are copies of a function at a given point in time.
Currently it's only used for running passes repeatedly for performance profiling.
In future it can be used for caching when doing lazy evaluation in the pipeline.
Andy some time ago already created the new API but didn't go through and update
the old occurences. I did that in this PR and then deprecated the old API. The
tree is clean, so I could just remove it, but I decided to be nicer to
downstream people by deprecating it first.
This is just the very beginning... I still need to implement more parts of
SILGen for this. But all great things start small. I am going to iterate on top
of this and just wanted to get some initial parts of the work in as I go.
I also created a SILType::isMoveOnly() helper that returns true if a type is
a move only wrapped type or a first class move only type. The verifier check
that move only types aren't copied in canonical SIL was rewired to use that as well.
Specifically this means that rather than always being owned, we now have owned
and guaranteed versions of copyable_to_moveonlywrapper. Similar to
moveonlywrapper_to_copyable, one chooses which variant one gets by using
specific SILBuilder APIs:
create{Owned,Guaranteed}CopyableToMoveOnlyWrapperValueInst. It is still
forwarding and the rest of the forwarding APIs work as expected except that the
forwarding ownership is fixed (and an assertion will result if one attempts to
do so).
NOTE: It is assumed that trivial operands are always passed to the owned
variant.
non-throwing functions.
Activating swift-functions-errors tests
Inserting macros and additional parameters in C and C++ functions following the pattern to lowering to LLVM IR.
If such declarations have availability conditions they have to be
kept alive until IRGen to emit opaque type descriptor that is going
be used at runtime to determine the underlying type.
This is important for "optimized" mode only because in non-optimized
mode "shared" symbol survives SILGen.
Previously I thought that we would have @_noImplicitCopy change the
SILFunctionType (but not the AST level type). This caused other problems and was
unnecessary. So I removed all such changes in this commit. Specifically:
1. We no longer thread through no implicit copy in SILFunctionType.cpp.
2. noImplicitCopy no longer by default makes an argument an owned
argument. Instead we use the default convention and handle it appropriately.
It's used to implement `InstructionSet` and `ValueSet`: sets of SILValues and SILInstructions.
Just like `BasicBlockSet` for basic blocks, the set is implemented by setting bits directly in SILNode.
This is super efficient because insertion and deletion to/from the set are basic bit operations.
The cost is an additional word in SILNode. But this is basically negligible: it just adds ~0.7% of memory used for SILInstructions.
In my experiments, I didn't see any relevant changes in memory consumption or compile time.
The use of the SWIFT_INLINE_BITFIELD macros in SILNode were a constant source of confusion and bugs.
With this refactoring I tried to simplify the definition of "shared fields" in SILNode, SILValue and SILInstruction classes:
* Move `kind`, `locationKindAndFlags` and the 32-bit fields out of the 64-bitfield into their own member variables. This avoids _a lot_ of manual bit position computations.
* Now we have two separate "shared fields": an 8-bit field (e.g. for boolean flags) and a 32-bit field (e.g. for indices, which can potentially get large). Both fields can be used independently. Also, they are not "bit fields" per se. Instructions can use the field e.g. as a `bool`, `uint32_t`, or - if multiple flags are to be stored - as a packed bit field.
* With these two separate fields, we don't have the need for defining bitfields both in a base class _and_ in a derived value/instruction class. We can get rid of the complex logic which handles such cases. Just keep a check to catch accidental overlaps of fields in base and derived classes.
* Still use preprocessor macros for the implementation, but much simpler ones than before.
* Add documentation.
The new intrinsic, exposed via static functions on Task<T, Never> and
Task<T, Error> (rethrowing), begins an asynchronous context within a
synchronous caller's context. This is only available for use under the
task-to-thread concurrency model, and even then only under SPI.
[Distributed] generic and inner test; without one edge case
[Distributed] fix distributed_thunk test; unsure about those extra hops, could remove later
[Distributed] Remove type pretending in getSILFunctionType; it is not needed
It seems our constant replacement in the earlier phases is enough, and
we don't need this trick at all.
[Distributed] Use thunk when calling cross-actor on DA protocols
Since I am beginning to prepare for adding real move only types to the language,
I am renaming everything that has to do with copyable types "move only wrapped"
values instead of move only. The hope is this reduces/prevents any confusion in
between the two.
A public designated initializer of a class would have its allocating
entry-point serialized in the module, meaning with `-O` that entry-point
can get inlined into programs linking against that module. Once that
entry-point is inlined, the program will _require_ that it remain non-delegating,
because it will depend on the 2nd entry-point (for actual initializing) to be in the
library.
As a result of this change, public initializers of an actor should be resilient in a
library, whether their underlying implementation is delegating or not.
When developing a module for an OS or SDK, one may use declarations from other modules that were recently introduced in the in-development OS. Those declarations will be annotated as available at the deployment target of the client module and yet the symbols for that declaration are not available in all development builds of that OS. If the module strongly links those symbols, it will crash on older development builds of the OS. The `-enable-experimental-ad-hoc-availability` flag is designed to give developers the option of weakly linking all symbols in other modules that were introduced at the deployment target.
This change introduces the basic change in linking behavior but does not address typechecking. Use of the declarations that are made unavailable in this mode will need to be diagnosed and developers will need a way to detect the unavailability at runtime before use.
Resolves rdar://96011550
The function prologue of async funclets inherits its source location
from the hop_to_executor instruction. This makes it easier to produce
logical backtraces, since the PC in logical frames will always point
to the start if the function.
rdar://89776340
This patch reverts a workaround that was put into pre-1.0 Swift to
avoid linetable entries for autoclosure functions. Nowadays
autoclosures aren't emitted in separate functions, which makes this
obsolete. The workaround also was no longer being tested by the test
suite.
rdar://89776340
Before the introduction of parameterized existential types, there
was no generic structure under these types. Now that there is, we'll
need to recurse into them to pick up any latent generic types
and lower them appropriately.
rdar://94320481
When a distributed-actor-isolated witness is provided for a
non-distributed-actor-isolated requirement, always hop to the
distributed thunk.
While here, mark distributed thunks as being `final`, to ensure that
we always statically call them vs. trying to retrieve them from the
vtable (since they aren't in the vtable).
The main fixes are:
1. MoveOnlyWrapperToCopyableValue needed to be marked as a
FirstArgOwnershipForwardingSingleValueInst instead of just as being an
Ownership mixin. I discovered that in certain cases I was treating it that
way (in the isa check for FirstArgOwnershipForwardingSingleValueInst), but we
were inconsistent. Now we are consistent.
2. MoveOnlyWrapperToCopyableValue is always specified as being initialized as
owned or guaranteed. What is key to understand though is that the
owned/guaranteed property here is more a semantic property around whether the
lifetime of the move only value is ending or if we are allowing it to escape
as an moveonlywrapped unwrapped guaranteed parameter to a function. The main
implication of this is that we can not just use the actual ownership kind to
determine the type of moveonlywrapper_to_copyable we are using. This is b/c
after ownership lowering, the resulting ownership kind will be none, meaning
the instruction will be in an invalid state. Thus the need to represent this
as a separate bit in the instruction. It may make sense to rename the forms
of this instruction to be `[lifetime end]` and `[guaranteed function arg]`
that way it is semantically clear. But I am going to do that change at
another time.
Just forgot to change these when I changed the name of the SILType methods. In
summary:
1. withoutMoveOnly -> removingMoveOnlyWrapper
2. withMoveOnly -> addingMoveOnlyWrapper
