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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//===- StackSafetyAnalysis.h - Stack memory safety analysis -----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Stack Safety Analysis detects allocas and arguments with safe access.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_ANALYSIS_STACKSAFETYANALYSIS_H
#define LLVM_ANALYSIS_STACKSAFETYANALYSIS_H
#include "llvm/IR/ModuleSummaryIndex.h"
#include "llvm/IR/PassManager.h"
#include "llvm/Pass.h"
namespace llvm {
class AllocaInst;
class ScalarEvolution;
/// Interface to access stack safety analysis results for single function.
class StackSafetyInfo {
public:
struct InfoTy;
private:
Function *F = nullptr;
std::function<ScalarEvolution &()> GetSE;
mutable std::unique_ptr<InfoTy> Info;
public:
StackSafetyInfo();
StackSafetyInfo(Function *F, std::function<ScalarEvolution &()> GetSE);
StackSafetyInfo(StackSafetyInfo &&);
StackSafetyInfo &operator=(StackSafetyInfo &&);
~StackSafetyInfo();
const InfoTy &getInfo() const;
// TODO: Add useful for client methods.
void print(raw_ostream &O) const;
/// Parameters use for a FunctionSummary.
/// Function collects access information of all pointer parameters.
/// Information includes a range of direct access of parameters by the
/// functions and all call sites accepting the parameter.
/// StackSafety assumes that missing parameter information means possibility
/// of access to the parameter with any offset, so we can correctly link
/// code without StackSafety information, e.g. non-ThinLTO.
std::vector<FunctionSummary::ParamAccess>
getParamAccesses(ModuleSummaryIndex &Index) const;
};
class StackSafetyGlobalInfo {
public:
struct InfoTy;
private:
Module *M = nullptr;
std::function<const StackSafetyInfo &(Function &F)> GetSSI;
const ModuleSummaryIndex *Index = nullptr;
mutable std::unique_ptr<InfoTy> Info;
const InfoTy &getInfo() const;
public:
StackSafetyGlobalInfo();
StackSafetyGlobalInfo(
Module *M, std::function<const StackSafetyInfo &(Function &F)> GetSSI,
const ModuleSummaryIndex *Index);
StackSafetyGlobalInfo(StackSafetyGlobalInfo &&);
StackSafetyGlobalInfo &operator=(StackSafetyGlobalInfo &&);
~StackSafetyGlobalInfo();
// Whether we can prove that all accesses to this Alloca are in-range and
// during its lifetime.
bool isSafe(const AllocaInst &AI) const;
// Returns true if the instruction can be proven to do only two types of
// memory accesses:
// (1) live stack locations in-bounds or
// (2) non-stack locations.
bool stackAccessIsSafe(const Instruction &I) const;
void print(raw_ostream &O) const;
void dump() const;
};
/// StackSafetyInfo wrapper for the new pass manager.
class StackSafetyAnalysis : public AnalysisInfoMixin<StackSafetyAnalysis> {
friend AnalysisInfoMixin<StackSafetyAnalysis>;
static AnalysisKey Key;
public:
using Result = StackSafetyInfo;
StackSafetyInfo run(Function &F, FunctionAnalysisManager &AM);
};
/// Printer pass for the \c StackSafetyAnalysis results.
class StackSafetyPrinterPass : public PassInfoMixin<StackSafetyPrinterPass> {
raw_ostream &OS;
public:
explicit StackSafetyPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
};
/// StackSafetyInfo wrapper for the legacy pass manager
class StackSafetyInfoWrapperPass : public FunctionPass {
StackSafetyInfo SSI;
public:
static char ID;
StackSafetyInfoWrapperPass();
const StackSafetyInfo &getResult() const { return SSI; }
void print(raw_ostream &O, const Module *M) const override;
void getAnalysisUsage(AnalysisUsage &AU) const override;
bool runOnFunction(Function &F) override;
};
/// This pass performs the global (interprocedural) stack safety analysis (new
/// pass manager).
class StackSafetyGlobalAnalysis
: public AnalysisInfoMixin<StackSafetyGlobalAnalysis> {
friend AnalysisInfoMixin<StackSafetyGlobalAnalysis>;
static AnalysisKey Key;
public:
using Result = StackSafetyGlobalInfo;
Result run(Module &M, ModuleAnalysisManager &AM);
};
/// Printer pass for the \c StackSafetyGlobalAnalysis results.
class StackSafetyGlobalPrinterPass
: public PassInfoMixin<StackSafetyGlobalPrinterPass> {
raw_ostream &OS;
public:
explicit StackSafetyGlobalPrinterPass(raw_ostream &OS) : OS(OS) {}
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
};
/// This pass performs the global (interprocedural) stack safety analysis
/// (legacy pass manager).
class StackSafetyGlobalInfoWrapperPass : public ModulePass {
StackSafetyGlobalInfo SSGI;
public:
static char ID;
StackSafetyGlobalInfoWrapperPass();
~StackSafetyGlobalInfoWrapperPass();
const StackSafetyGlobalInfo &getResult() const { return SSGI; }
void print(raw_ostream &O, const Module *M) const override;
void getAnalysisUsage(AnalysisUsage &AU) const override;
bool runOnModule(Module &M) override;
};
bool needsParamAccessSummary(const Module &M);
void generateParamAccessSummary(ModuleSummaryIndex &Index);
} // end namespace llvm
#endif // LLVM_ANALYSIS_STACKSAFETYANALYSIS_H
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
