- **Explanation**: Fix a compiler crash when a module imports `Dispatch`
(without `Foundation`) and holds a `DispatchSourceTimer?`-typed property
under Swift 6 mode. IRGen was dereferencing a null `clang::CanQualType`
when emitting lazy metadata for `NSObjectProtocol.description` /
`.debugDescription`.
- **Scope**: Three local null-guards in `lib/IRGen/GenObjC.cpp`
(`emitObjCGetterDescriptorParts(VarDecl *)`,
`emitObjCSetterDescriptorParts(VarDecl *)`,
`getObjCEncodingForPropertyType`). No change when `getObjCPropertyType`
returns a valid type.
- **Issues**: Reported against Xcode 6.0, 6.1, and 6.2 toolchains on
macOS. Does not reproduce on Linux or with `.swiftLanguageMode(.v5)`.
Minimal repro: `import Dispatch` + `class C { fileprivate var timer:
DispatchSourceTimer? }`.
- **Risk**: Very low. Local null-guards on a known-fragile path. Full
IRGen suite (1031 tests) passes. The placeholder metadata emitted in the
guarded case is never dispatched through at runtime (the real
`NSObjectProtocol` comes from Objective-C).
- **Testing**: New
`test/IRGen/objc_protocol_lazy_definition_null_clang_type.swift`
compiles the reproducer under `-swift-version 6` and checks
`MyClass.timer.getter`'s IR is emitted. Verified the crash reproduces
without the fix and is gone with it.
The root cause sits in SIL type lowering: for
`NSObjectProtocol.description`'s foreign getter,
`TypeConverter::getLoweredCBridgedType` looks up `String:
_ObjectiveCBridgeable` through the user's module, and the conformance
(defined in Foundation) isn't visible when Foundation isn't imported.
The principled fix (widen the bridging-conformance lookup for well-known
bridged Swift types will be a follow-up that doesn't need to go to 6.4.
We already generate forwarding methods that can fix up the base offset
when we call base methods. Unfortunately, these forwarding methods were
not used when we emitted a call to a refcount operation of a foreign
reference type where the annotation is on the type itself but the
operation was inherited from a base.
rdar://173210238
Some foreign reference types such as IUnknown define retain/release operations as methods of the type.
Previously Swift only supported retain/release operations as standalone functions.
The syntax for member functions would be `SWIFT_SHARED_REFERENCE(.doRetain, .doRelease)`.
rdar://160696723
ResultConvention::Guaranteed will be used by borrow accessors when the storage type can be returned by value.
ResultConvention::GuaranteedAddress will be used by mutate accessors and borrow accessors when the storage type
cannot be returned by value.
When it's available, use an open-coded allocator function that returns
an alloca without popping if the allocator is nullptr and otherwise
calls swift_coro_alloc. When it's not available, use the malloc
allocator in the synchronous context.
This corresponds to the parameter-passing convention of the Itanium C++
ABI, in which the argument is passed indirectly and possibly modified,
but not destroyed, by the callee.
@in_cxx is handled the same way as @in in callers and @in_guaranteed in
callees. OwnershipModelEliminator emits the call to destroy_addr that is
needed to destroy the argument in the caller.
rdar://122707697
Although I don't plan to bring over new assertions wholesale
into the current qualification branch, it's entirely possible
that various minor changes in main will use the new assertions;
having this basic support in the release branch will simplify that.
(This is why I'm adding the includes as a separate pass from
rewriting the individual assertions)
This teaches IRGen to only emit a lifetime operation (retain or release) for a C++ foreign reference type if the pointer is not `nullptr`.
Previously the compiler would in some cases emit a release call for `nullptr`, which breaks the assumption that the argument to a custom release function is `_Nonnull`. For instance:
```
var globalOptional: MyRefType? = nil
func foo() { globalOptional = MyRefType.create() }
```
When emitting IR for the assignment operation to `globalOptional`, the compiler would emit code to first retrieve the existing value of `globalOptional` and release it. If the value is `nil`, it does not need to be released.
rdar://97532642
Using symbolic references instead of a text based mangling avoids the
expensive type descriptor scan when objective c protocols are requested.
rdar://111536582
LLVM deprecated, renamed, and removed a bunch of APIs. This patch
contains a lot of the changes needed to deal with that.
The SetVector type changed the template parameters.
APInt updated multiple names, countPopulation became popcount,
getAllOnesValue became getAllOnes, getNullValue became getZero, etc...
Clang type nullability check stopped taking a clang AST context.
The LLVM IRGen Function type stopped exposing basic block list directly,
but gained enough API surface that the translation isn't too bad.
(GenControl.cpp, LLVMMergeFunctions.cpp)
llvm::Optional had a transform function. That was being used in a couple
of places, so I've added a new implementation under STLExtras that
transforms valid optionals, otherwise it returns nullopt.
We have implemented a work-around where we have implemented
objc_retainAutoreleasedReturnValue in a library. When using
clang.arc.attachedcall llvm might optimize the call to objc_retain which
we have not defined a stub for. (Alternatively, we could define
objc_retain in swift-corelibs-libdispatch/src/swift/DispatchStubs.cc)
This is phase-1 of switching from llvm::Optional to std::optional in the
next rebranch. llvm::Optional was removed from upstream LLVM, so we need
to migrate off rather soon. On Darwin, std::optional, and llvm::Optional
have the same layout, so we don't need to be as concerned about ABI
beyond the name mangling. `llvm::Optional` is only returned from one
function in
```
getStandardTypeSubst(StringRef TypeName,
bool allowConcurrencyManglings);
```
It's the return value, so it should not impact the mangling of the
function, and the layout is the same as `std::optional`, so it should be
mostly okay. This function doesn't appear to have users, and the ABI was
already broken 2 years ago for concurrency and no one seemed to notice
so this should be "okay".
I'm doing the migration incrementally so that folks working on main can
cherry-pick back to the release/5.9 branch. Once 5.9 is done and locked
away, then we can go through and finish the replacement. Since `None`
and `Optional` show up in contexts where they are not `llvm::None` and
`llvm::Optional`, I'm preparing the work now by going through and
removing the namespace unwrapping and making the `llvm` namespace
explicit. This should make it fairly mechanical to go through and
replace llvm::Optional with std::optional, and llvm::None with
std::nullopt. It's also a change that can be brought onto the
release/5.9 with minimal impact. This should be an NFC change.
Instead of passing `IRGenFunction`, pass the `IRGenModule` and the `IRBuilder`.
This makes enum creation not dependent on the presence of a function.
NFC, just refactoring.
- SILPackType carries whether the elements are stored directly
in the pack, which we're not currently using in the lowering,
but it's probably something we'll want in the final ABI.
Having this also makes it clear that we're doing the right
thing with substitution and element lowering. I also toyed
with making this a scalar type, which made it necessary in
various places, although eventually I pulled back to the
design where we always use packs as addresses.
- Pack boundaries are a core ABI concept, so the lowering has
to wrap parameter pack expansions up as packs. There are huge
unimplemented holes here where the abstraction pattern will
need to tell us how many elements to gather into the pack,
but a naive approach is good enough to get things off the
ground.
- Pack conventions are related to the existing parameter and
result conventions, but they're different on enough grounds
that they deserve to be separated.
A new `RuntimeAttributeGenerator` is used to reference runtime
attribute generator functions synthesized by SILGen.
`#function` magic literal points to the declaration that declaration
attribute is attached to.
* Introduce TypeLayout Strings
Layout strings encode the structure of a type into a byte string that can be
interpreted by a runtime function to achieve a destroy or copy. Rather than
generating ir for a destroy/assignWithCopy/etc, we instead generate a layout
string which encodes enough information for a called runtime function to
perform the operation for us. Value witness functions tend to be quite large,
so this allows us to replace them with a single call instead. This gives us the
option of making a codesize/runtime cost trade off.
* Added Attribute @_GenerateLayoutBytecode
This marks a type definition that should use generic bytecode based
value witnesses rather than generating the standard suite of
value witness functions. This should reduce the codesize of the binary
for a runtime interpretation of the bytecode cost.
* Statically link in implementation
Summary:
This creates a library to store the runtime functions in to deploy to
runtimes that do not implement bytecode layouts. Right now, that is
everything. Once these are added to the runtime itself, it can be used
to deploy to old runtimes.
* Implement Destroy at Runtime Using LayoutStrings
If GenerateLayoutBytecode is enabled, Create a layout string and use it
to call swift_generic_destroy
* Add Resilient type and Archetype Support for BytecodeLayouts
Add Resilient type and Archetype Support to Bytecode Layouts
* Implement Bytecode assign/init with copy/take
Implements swift_generic_initialize and swift_generic_assign to allow copying
types using bytecode based witnesses.
* Add EnumTag Support
* Add IRGen Bytecode Layouts Test
Added a test to ensure layouts are correct and getting generated
* Implement BytecodeLayouts ObjC retain/release
* Fix for Non static alignments in aligned groups
* Disable MultiEnums
MultiEnums currently have some correctness issues with non fixed multienum
types. Disabling them for now then going to attempt a correct implementation in
a follow up patch
* Fixes after merge
* More fixes
* Possible fix for native unowned
* Use TypeInfoeBasedTypeLayoutEntry for all scalars when ForceStructTypeLayouts is disabled
* Remove @_GenerateBytecodeLayout attribute
* Fix typelayout_based_value_witness.swift
Co-authored-by: Gwen Mittertreiner <gwenm@fb.com>
Co-authored-by: Gwen Mittertreiner <gwen.mittertreiner@gmail.com>
And only replace the variable inside of the clang generated protocol-refs list.
This should make this resilient to mismatches in the protocol list order.
Getting the `protocolRefs` constant must not be hoisted out of the loop because this constant might be deleted by `oldVar->replaceAllUsesWith(newOpd)`.
rdar://102554134
`getValue` -> `value`
`getValueOr` -> `value_or`
`hasValue` -> `has_value`
`map` -> `transform`
The old API will be deprecated in the rebranch.
To avoid merge conflicts, use the new API already in the main branch.
rdar://102362022
Ben Cohen
Gabor Horvath
Slava Pestov
Meghana Gupta
Ellis Hoag
Egor Zhdan
Janat Baig
Anthony Latsis
Nate Chandler
Becca Royal-Gordon
Konrad `ktoso` Malawski
Alex Hoppen
Mykola Pokhylets
Akira Hatanaka
Tim Kientzle
Ben Barham
Arnold Schwaighofer
swift-ci
nate-chandler
Pavel Yaskevich
Evan Wilde
Erik Eckstein
John McCall
Dario Rexin