mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
0664c3f333
Add a distinct hook for `swift_willThrowTypedImpl()`. This PR adds a hook for `swift_willThrowTypedImpl()` that is distinct from `swift_willThrow()`. The current implementation of `swift_willThrowTypedImpl()` creates a temporary existential box for the thrown error and calls the `_swift_willThrow` hook that is set by XCTest and swift-testing. Unfortunately, this temporary existential box isn't very useful because its address is not expected to be stable. Instead, expose a separate hook, `_swift_willThrowTypedImpl`, whose signature matches that of the new ABI function. This hook can then be used by XCTest and swift-testing to distinguish between typed throws and untyped throws and avoids creating a temporary existential box when it won't be useful. As implemented, if `_swift_willThrowTypedImpl` is not set but `_swift_willThrow` is, the `swift_willThrowTypedImpl()` will fall back to calling `_swift_willThrow` with a temporary existential box. We might decide this is unnecessary, but I figured it would allow us more time to stage adoption of the new hook in the testing libraries. Resolves rdar://122824443.
80 lines
3.1 KiB
C++
80 lines
3.1 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);
|
|
}
|
|
}
|
|
|
|
std::atomic<void (*)(
|
|
OpaqueValue *value,
|
|
const Metadata *type,
|
|
const WitnessTable *errorConformance
|
|
)> swift::_swift_willThrowTypedImpl;
|
|
|
|
/// Breakpoint hook for debuggers that is called for typed throws, and calls
|
|
/// _swift_willThrowTypedImpl if set. If not set and _swift_willThrow is set, this calls
|
|
/// that hook instead and implicitly boxes the typed error in an any Error for that 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_willThrowTypedImpl.load(std::memory_order_acquire);
|
|
if (SWIFT_UNLIKELY(handler)) {
|
|
(* handler)(value, type, errorConformance);
|
|
} else {
|
|
auto fallbackHandler = _swift_willThrow.load(std::memory_order_acquire);
|
|
if (SWIFT_UNLIKELY(fallbackHandler)) {
|
|
// 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);
|
|
(* fallbackHandler)(errorBox);
|
|
|
|
// Release the error box.
|
|
swift_errorRelease(errorBox);
|
|
}
|
|
}
|
|
}
|