1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
//===--- ARCMatchingSet.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_SILOPTIMIZER_PASSMANAGER_GLOBALARCPAIRINGANALYSIS_H
#define SWIFT_SILOPTIMIZER_PASSMANAGER_GLOBALARCPAIRINGANALYSIS_H
#include "GlobalARCSequenceDataflow.h"
#include "GlobalLoopARCSequenceDataflow.h"
#include "swift/SIL/SILValue.h"
#include "swift/SILOptimizer/Utils/LoopUtils.h"
#include "swift/SILOptimizer/Analysis/RCIdentityAnalysis.h"
#include "llvm/ADT/SetVector.h"
namespace swift {
class SILInstruction;
class SILFunction;
class AliasAnalysis;
class PostOrderAnalysis;
class LoopRegionFunctionInfo;
class SILLoopInfo;
class RCIdentityFunctionInfo;
/// A set of matching reference count increments, decrements, increment
/// insertion pts, and decrement insertion pts.
struct ARCMatchingSet {
/// The pointer that this ARCMatchingSet is providing matching increment and
/// decrement sets for.
///
/// TODO: This should really be called RCIdentity.
SILValue Ptr;
/// The set of reference count increments that were paired.
llvm::SetVector<SILInstruction *> Increments;
/// The set of reference count decrements that were paired.
llvm::SetVector<SILInstruction *> Decrements;
// This is a data structure that cannot be moved or copied.
ARCMatchingSet() = default;
ARCMatchingSet(const ARCMatchingSet &) = delete;
ARCMatchingSet(ARCMatchingSet &&) = delete;
ARCMatchingSet &operator=(const ARCMatchingSet &) = delete;
ARCMatchingSet &operator=(ARCMatchingSet &&) = delete;
void clear() {
Ptr = SILValue();
Increments.clear();
Decrements.clear();
}
};
struct MatchingSetFlags {
bool KnownSafe;
bool CodeMotionSafe;
};
static_assert(std::is_pod<MatchingSetFlags>::value,
"MatchingSetFlags should be a pod.");
struct ARCMatchingSetBuilder {
using TDMapTy = BlotMapVector<SILInstruction *, TopDownRefCountState>;
using BUMapTy = BlotMapVector<SILInstruction *, BottomUpRefCountState>;
TDMapTy &TDMap;
BUMapTy &BUMap;
llvm::SmallVector<SILInstruction *, 8> NewIncrements;
llvm::SmallVector<SILInstruction *, 8> NewDecrements;
bool MatchedPair;
ARCMatchingSet MatchSet;
bool PtrIsGuaranteedArg;
RCIdentityFunctionInfo *RCIA;
public:
ARCMatchingSetBuilder(TDMapTy &TDMap, BUMapTy &BUMap,
RCIdentityFunctionInfo *RCIA)
: TDMap(TDMap), BUMap(BUMap), MatchedPair(false),
PtrIsGuaranteedArg(false), RCIA(RCIA) {}
void init(SILInstruction *Inst) {
clear();
MatchSet.Ptr = RCIA->getRCIdentityRoot(Inst->getOperand(0));
// If we have a function argument that is guaranteed, set the guaranteed
// flag so we know that it is always known safe.
if (auto *A = dyn_cast<SILFunctionArgument>(MatchSet.Ptr)) {
auto C = A->getArgumentConvention();
PtrIsGuaranteedArg = C == SILArgumentConvention::Direct_Guaranteed;
}
NewIncrements.push_back(Inst);
}
void clear() {
MatchSet.clear();
MatchedPair = false;
NewIncrements.clear();
NewDecrements.clear();
}
bool matchUpIncDecSetsForPtr();
// We only allow for get result when this object is invalidated via a move.
ARCMatchingSet &getResult() { return MatchSet; }
bool matchedPair() const { return MatchedPair; }
private:
/// Returns .Some(MatchingSetFlags) on success and .None on failure.
std::optional<MatchingSetFlags> matchIncrementsToDecrements();
std::optional<MatchingSetFlags> matchDecrementsToIncrements();
};
} // end swift namespace
#endif
|
