mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
f009cf3de8
This is the first in a series of patches that reworks EscapeAnalysis. For this patch, I extracted every change that does not introduce new features, rewrite logic, or appear to change functionality. These cleanups were done in preparation for: - adding a graph representation for reference counted objects - rewriting parts to the query logic - ...which then allows the analysis to safely assume that all exclusive arguments are unique - ...which then allows more aggressive optimization of local variables that don't escape There are two possible functional changes: 1. getUnderlyingAddressRoot in InstructionUtils now sees through OSSA instructions: begin_borrow and copy_value 2. The getPointerBase helper in EscapeAnalysis now sees through all of these reference and pointer casts: + case ValueKind::UncheckedRefCastInst: + case ValueKind::ConvertFunctionInst: + case ValueKind::UpcastInst: + case ValueKind::InitExistentialRefInst: + case ValueKind::OpenExistentialRefInst: + case ValueKind::RawPointerToRefInst: + case ValueKind::RefToRawPointerInst: + case ValueKind::RefToBridgeObjectInst: + case ValueKind::BridgeObjectToRefInst: + case ValueKind::UncheckedAddrCastInst: + case ValueKind::UnconditionalCheckedCastInst: + case ValueKind::RefTo##Name##Inst: + case ValueKind::Name##ToRefInst: This coalesces a whole bunch of nodes together that were just there because of casts. The existing code was already doing this for one level of casts, but there was a bug that prevented it from happening transitively. So, in theory, anything that breaks with this fix could also break without this fix, but may not have been exposed. The fact that this analysis coalesces address-to-reference casts at all is what caused me to spent vast amounts of time debugging any time I tried to force some structure on the graph via assertions. If it is done at all, it should be done everywhere consistently to expose issues as early as possible. Here is a description of the changes in diff order. If something in the diff is not listed here, then the code probably just moved around in the file: Rename isNotAliasedIndirectParameter to isExclusiveIndirectParameter. The argument may be aliased in the caller's scope and it's contents may have already escaped. Add comments to SILType APIs (isTrivial, isReferenceCounted) that give answers about the AST type which don't really make sense for address SILTypes. Add comments about CGNode's 'Value' field. I spent lots of time attempting to tighten this down with asserts, but it's only possible for non-content nodes. For content nodes, the node's value is highly unpredictable and basically nonsense but needed for debugging. Add comments about not assuming that the content nodes pointsTo edge represents physical indirection. This matters when reasoning about aliasing and it's a tempting assumption to make. Add a CGNode::mergeProperties placeholder for adding node properties. Factor out a CGNode::canAddDeferred helper for use later. Rename `setPointsTo` to `setPointsToEdge` because it actually creates an edge rather than just setting `pointsTo`. Add CGNode::getValue() and related helpers to help maintain invariants. Factor out a `markEscaping` helper. Clean up the `escapesInsideFunction` helper. Add node visitor helpers: visitSuccessors, visitDefers. This made is much easier to prototype utilities. Add comments to clarify the `pointsTo` invariant. In particular, an entire defer web may have a null pointsTo for a while. Add an `activeWorklist` to avoid nasty bugs when composing multiple helpers that each use the worklist. Remove the `EA` argument from `getNode`. I ended up needing access to the `EA` context from the ConnectionGraph many times during prototyping and passing `this` was all the `getNode` calls was very silly. Add graph visitor helpers: backwardTraverse, forwardTraverseDefer, forwardTraversePointsToEdges, and mayReach for ease in developing new logic and utilities. Add isExclusiveArgument helper and distinguish exclusive arguments from local objects. Confusing these properties could lead to scary bugs. For example, unlike a local object, an exclusive argument's contents may still escape even when the content's connection graph node is non-escaping! Add isUniquelyIdentified helper when we want to treat exclusive arguments and local objects uniformly. getUnderlyingAddressRoot now looks through OSSA instructions. Rename `getAccessedMemory` to `getDirectlyAccessedMemory` with comments. This is another dangerous API because it assumes the memory access to a given address won't touch memory represented by different graph nodes, but graph edges don't necessarily represent physical indirection. Further clarify this issue in comments in AliasAnalysis.cpp. Factor out a 'findRecursiveRefType' helper from the old 'mayContainReference' for checking whether types may or must contain references. Support both kinds of queries so the analysis can be certain when a pointer's content is a physical heap object. Factor out 'getPointerBase' and 'getPointerRoot' helpers that follow address projections within what EscapeAnalysis will consider a single node. Create a CGNodeWorklist abstraction to safely formalize the worklist mechanism that's used all over the place. In one place, there were even two separate independent lists used independently (nodes added to one list could appear to be in the other list). The CGNodeMap abstraction did not significantly change, it was just moved. Added 'dumpCG' for dumping .dot files making it possible to remote debug. Added '-escapes-enable-graphwriter' option to dump .dot files, since they are so much more useful than the textual dump of the connection graph, which lacks node identity!
156 lines
5.3 KiB
C++
156 lines
5.3 KiB
C++
//===--- SILArgumentConvention.h --------------------------------*- C++ -*-===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef SWIFT_SIL_SILARGUMENTCONVENTION_H
|
|
#define SWIFT_SIL_SILARGUMENTCONVENTION_H
|
|
|
|
#include "swift/AST/Types.h"
|
|
|
|
namespace swift {
|
|
|
|
/// Conventions for apply operands and function-entry arguments in SIL.
|
|
///
|
|
/// This is simply a union of ParameterConvention and ResultConvention
|
|
/// (ParameterConvention + Indirect_Out) for convenience when visiting all
|
|
/// arguments.
|
|
struct SILArgumentConvention {
|
|
enum ConventionType : uint8_t {
|
|
Indirect_In,
|
|
Indirect_In_Constant,
|
|
Indirect_In_Guaranteed,
|
|
Indirect_Inout,
|
|
Indirect_InoutAliasable,
|
|
Indirect_Out,
|
|
Direct_Owned,
|
|
Direct_Unowned,
|
|
Direct_Deallocating,
|
|
Direct_Guaranteed,
|
|
} Value;
|
|
|
|
SILArgumentConvention(decltype(Value) NewValue) : Value(NewValue) {}
|
|
|
|
/// Turn a ParameterConvention into a SILArgumentConvention.
|
|
explicit SILArgumentConvention(ParameterConvention Conv) : Value() {
|
|
switch (Conv) {
|
|
case ParameterConvention::Indirect_In:
|
|
Value = SILArgumentConvention::Indirect_In;
|
|
return;
|
|
case ParameterConvention::Indirect_In_Constant:
|
|
Value = SILArgumentConvention::Indirect_In_Constant;
|
|
return;
|
|
case ParameterConvention::Indirect_Inout:
|
|
Value = SILArgumentConvention::Indirect_Inout;
|
|
return;
|
|
case ParameterConvention::Indirect_InoutAliasable:
|
|
Value = SILArgumentConvention::Indirect_InoutAliasable;
|
|
return;
|
|
case ParameterConvention::Indirect_In_Guaranteed:
|
|
Value = SILArgumentConvention::Indirect_In_Guaranteed;
|
|
return;
|
|
case ParameterConvention::Direct_Unowned:
|
|
Value = SILArgumentConvention::Direct_Unowned;
|
|
return;
|
|
case ParameterConvention::Direct_Guaranteed:
|
|
Value = SILArgumentConvention::Direct_Guaranteed;
|
|
return;
|
|
case ParameterConvention::Direct_Owned:
|
|
Value = SILArgumentConvention::Direct_Owned;
|
|
return;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?!");
|
|
}
|
|
|
|
operator ConventionType() const { return Value; }
|
|
|
|
bool isIndirectConvention() const {
|
|
return Value <= SILArgumentConvention::Indirect_Out;
|
|
}
|
|
|
|
bool isInoutConvention() const {
|
|
switch (Value) {
|
|
case SILArgumentConvention::Indirect_Inout:
|
|
case SILArgumentConvention::Indirect_InoutAliasable:
|
|
return true;
|
|
case SILArgumentConvention::Indirect_In_Guaranteed:
|
|
case SILArgumentConvention::Indirect_In:
|
|
case SILArgumentConvention::Indirect_In_Constant:
|
|
case SILArgumentConvention::Indirect_Out:
|
|
case SILArgumentConvention::Direct_Unowned:
|
|
case SILArgumentConvention::Direct_Owned:
|
|
case SILArgumentConvention::Direct_Deallocating:
|
|
case SILArgumentConvention::Direct_Guaranteed:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?!");
|
|
}
|
|
|
|
bool isOwnedConvention() const {
|
|
switch (Value) {
|
|
case SILArgumentConvention::Indirect_In:
|
|
case SILArgumentConvention::Direct_Owned:
|
|
return true;
|
|
case SILArgumentConvention::Indirect_In_Guaranteed:
|
|
case SILArgumentConvention::Direct_Guaranteed:
|
|
case SILArgumentConvention::Indirect_Inout:
|
|
case SILArgumentConvention::Indirect_In_Constant:
|
|
case SILArgumentConvention::Indirect_Out:
|
|
case SILArgumentConvention::Indirect_InoutAliasable:
|
|
case SILArgumentConvention::Direct_Unowned:
|
|
case SILArgumentConvention::Direct_Deallocating:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?!");
|
|
}
|
|
|
|
bool isGuaranteedConvention() const {
|
|
switch (Value) {
|
|
case SILArgumentConvention::Indirect_In_Guaranteed:
|
|
case SILArgumentConvention::Direct_Guaranteed:
|
|
return true;
|
|
case SILArgumentConvention::Indirect_Inout:
|
|
case SILArgumentConvention::Indirect_In:
|
|
case SILArgumentConvention::Indirect_In_Constant:
|
|
case SILArgumentConvention::Indirect_Out:
|
|
case SILArgumentConvention::Indirect_InoutAliasable:
|
|
case SILArgumentConvention::Direct_Unowned:
|
|
case SILArgumentConvention::Direct_Owned:
|
|
case SILArgumentConvention::Direct_Deallocating:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?!");
|
|
}
|
|
|
|
/// Returns true if \p Value is a non-aliasing indirect parameter.
|
|
bool isExclusiveIndirectParameter() {
|
|
switch (Value) {
|
|
case SILArgumentConvention::Indirect_In:
|
|
case SILArgumentConvention::Indirect_In_Constant:
|
|
case SILArgumentConvention::Indirect_Out:
|
|
case SILArgumentConvention::Indirect_In_Guaranteed:
|
|
case SILArgumentConvention::Indirect_Inout:
|
|
return true;
|
|
|
|
case SILArgumentConvention::Indirect_InoutAliasable:
|
|
case SILArgumentConvention::Direct_Unowned:
|
|
case SILArgumentConvention::Direct_Guaranteed:
|
|
case SILArgumentConvention::Direct_Owned:
|
|
case SILArgumentConvention::Direct_Deallocating:
|
|
return false;
|
|
}
|
|
llvm_unreachable("covered switch isn't covered?!");
|
|
}
|
|
};
|
|
|
|
} // namespace swift
|
|
|
|
#endif
|