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
|
//===- SymbolRewriter.h - Symbol Rewriting Pass -----------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file provides the prototypes and definitions related to the Symbol
// Rewriter pass.
//
// The Symbol Rewriter pass takes a set of rewrite descriptors which define
// transformations for symbol names. These can be either single name to name
// trnsformation or more broad regular expression based transformations.
//
// All the functions are re-written at the IR level. The Symbol Rewriter itself
// is exposed as a module level pass. All symbols at the module level are
// iterated. For any matching symbol, the requested transformation is applied,
// updating references to it as well (a la RAUW). The resulting binary will
// only contain the rewritten symbols.
//
// By performing this operation in the compiler, we are able to catch symbols
// that would otherwise not be possible to catch (e.g. inlined symbols).
//
// This makes it possible to cleanly transform symbols without resorting to
// overly-complex macro tricks and the pre-processor. An example of where this
// is useful is the sanitizers where we would like to intercept a well-defined
// set of functions across the module.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TRANSFORMS_UTILS_SYMBOLREWRITER_H
#define LLVM_TRANSFORMS_UTILS_SYMBOLREWRITER_H
#include "llvm/IR/PassManager.h"
#include <list>
#include <memory>
#include <string>
namespace llvm {
class MemoryBuffer;
class Module;
class ModulePass;
namespace yaml {
class KeyValueNode;
class MappingNode;
class ScalarNode;
class Stream;
} // end namespace yaml
namespace SymbolRewriter {
/// The basic entity representing a rewrite operation. It serves as the base
/// class for any rewrite descriptor. It has a certain set of specializations
/// which describe a particular rewrite.
///
/// The RewriteMapParser can be used to parse a mapping file that provides the
/// mapping for rewriting the symbols. The descriptors individually describe
/// whether to rewrite a function, global variable, or global alias. Each of
/// these can be selected either by explicitly providing a name for the ones to
/// be rewritten or providing a (posix compatible) regular expression that will
/// select the symbols to rewrite. This descriptor list is passed to the
/// SymbolRewriter pass.
class RewriteDescriptor {
public:
enum class Type {
Invalid, /// invalid
Function, /// function - descriptor rewrites a function
GlobalVariable, /// global variable - descriptor rewrites a global variable
NamedAlias, /// named alias - descriptor rewrites a global alias
};
RewriteDescriptor(const RewriteDescriptor &) = delete;
RewriteDescriptor &operator=(const RewriteDescriptor &) = delete;
virtual ~RewriteDescriptor() = default;
Type getType() const { return Kind; }
virtual bool performOnModule(Module &M) = 0;
protected:
explicit RewriteDescriptor(Type T) : Kind(T) {}
private:
const Type Kind;
};
using RewriteDescriptorList = std::list<std::unique_ptr<RewriteDescriptor>>;
class RewriteMapParser {
public:
bool parse(const std::string &MapFile, RewriteDescriptorList *Descriptors);
private:
bool parse(std::unique_ptr<MemoryBuffer> &MapFile, RewriteDescriptorList *DL);
bool parseEntry(yaml::Stream &Stream, yaml::KeyValueNode &Entry,
RewriteDescriptorList *DL);
bool parseRewriteFunctionDescriptor(yaml::Stream &Stream,
yaml::ScalarNode *Key,
yaml::MappingNode *Value,
RewriteDescriptorList *DL);
bool parseRewriteGlobalVariableDescriptor(yaml::Stream &Stream,
yaml::ScalarNode *Key,
yaml::MappingNode *Value,
RewriteDescriptorList *DL);
bool parseRewriteGlobalAliasDescriptor(yaml::Stream &YS, yaml::ScalarNode *K,
yaml::MappingNode *V,
RewriteDescriptorList *DL);
};
} // end namespace SymbolRewriter
ModulePass *createRewriteSymbolsPass();
ModulePass *createRewriteSymbolsPass(SymbolRewriter::RewriteDescriptorList &);
class RewriteSymbolPass : public PassInfoMixin<RewriteSymbolPass> {
public:
RewriteSymbolPass() { loadAndParseMapFiles(); }
RewriteSymbolPass(SymbolRewriter::RewriteDescriptorList &DL) {
Descriptors.splice(Descriptors.begin(), DL);
}
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
// Glue for old PM
bool runImpl(Module &M);
private:
void loadAndParseMapFiles();
SymbolRewriter::RewriteDescriptorList Descriptors;
};
} // end namespace llvm
#endif //LLVM_TRANSFORMS_UTILS_SYMBOLREWRITER_H
|
