mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
3fa07a0e7a
`swift_willThrow` is called with an error right before it is thrown. This existing entrypoint requires an already-boxed error existential; with typed errors, we don't have the error existential on hand, so we would need to allocate the box to throw a typed error. That's not okay. Introduce a new `swift_willThrowTypedImpl` entry point into the runtime that will first check for the presence of an error handler and, if one is present, box the error to provide to the error handler. This maintains the no-allocations path for typed errors while still allowing existing error handlers to work. This new entrypoint isn't available on older Swift runtimes, so create a back-deployable shim called by the compiler. On new-enough platforms, this will call through to `swift_willThrowTypedImpl`. On older platforms, we drop the error and don't call the registered will-throw handler at all. This is a compromise that avoids boxing when throwing typed errors, at the cost of a slightly different experience for this new feature on older runtimes. Fixes rdar://119828459.
69 lines
2.7 KiB
C++
69 lines
2.7 KiB
C++
//===--- ErrorObjectCommon.cpp - Recoverable error object -----------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2019 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This implements the parts of the standard Error protocol type which are
|
|
// shared between the ObjC-interoperable implementation and the native
|
|
// implementation. The parts specific to each implementation can be found in
|
|
// ErrorObject.mm (for the ObjC-interoperable parts) and ErrorObjectNative.cpp.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "swift/Runtime/Concurrent.h"
|
|
#include "swift/Runtime/Config.h"
|
|
#include "ErrorObject.h"
|
|
#include "ErrorObjectTestSupport.h"
|
|
|
|
using namespace swift;
|
|
|
|
std::atomic<void (*)(SwiftError *error)> swift::_swift_willThrow;
|
|
|
|
void swift::_swift_setWillThrowHandler(void (* handler)(SwiftError *error)) {
|
|
_swift_willThrow.store(handler, std::memory_order_release);
|
|
}
|
|
|
|
/// Breakpoint hook for debuggers that is called for untyped throws, and
|
|
/// calls _swift_willThrow if set.
|
|
SWIFT_CC(swift) void
|
|
swift::swift_willThrow(SWIFT_CONTEXT void *unused,
|
|
SWIFT_ERROR_RESULT SwiftError **error) {
|
|
// Cheap check to bail out early, since we expect there to be no callbacks
|
|
// the vast majority of the time.
|
|
auto handler = _swift_willThrow.load(std::memory_order_acquire);
|
|
if (SWIFT_UNLIKELY(handler)) {
|
|
(* handler)(*error);
|
|
}
|
|
}
|
|
|
|
/// Breakpoint hook for debuggers that is called for typed throws, and calls
|
|
/// _swift_willThrow if set. This implicitly boxes the typed error in an
|
|
/// any Error for the call.
|
|
SWIFT_CC(swift) void
|
|
swift::swift_willThrowTypedImpl(OpaqueValue *value,
|
|
const Metadata *type,
|
|
const WitnessTable *errorConformance) {
|
|
// Cheap check to bail out early, since we expect there to be no callbacks
|
|
// the vast majority of the time.
|
|
auto handler = _swift_willThrow.load(std::memory_order_acquire);
|
|
if (SWIFT_UNLIKELY(handler)) {
|
|
// Form an error box containing the error.
|
|
BoxPair boxedError = swift_allocError(
|
|
type, errorConformance, value, /*isTake=*/false);
|
|
|
|
// Hand the boxed error off to the handler.
|
|
auto errorBox = reinterpret_cast<SwiftError *>(boxedError.object);
|
|
(* handler)(errorBox);
|
|
|
|
// Release the error box.
|
|
swift_errorRelease(errorBox);
|
|
}
|
|
}
|