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
|
//===-- 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_SYMBOL_REWRITER_H
#define LLVM_TRANSFORMS_UTILS_SYMBOL_REWRITER_H
#include "llvm/ADT/ilist.h"
#include "llvm/ADT/ilist_node.h"
#include "llvm/IR/Module.h"
namespace llvm {
class MemoryBuffer;
namespace yaml {
class KeyValueNode;
class MappingNode;
class ScalarNode;
class Stream;
}
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 ilist_node<RewriteDescriptor> {
RewriteDescriptor(const RewriteDescriptor &) = delete;
const RewriteDescriptor &
operator=(const RewriteDescriptor &) = delete;
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
};
virtual ~RewriteDescriptor() {}
Type getType() const { return Kind; }
virtual bool performOnModule(Module &M) = 0;
protected:
explicit RewriteDescriptor(Type T) : Kind(T) {}
private:
const Type Kind;
};
typedef iplist<RewriteDescriptor> RewriteDescriptorList;
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);
};
}
template <>
struct ilist_traits<SymbolRewriter::RewriteDescriptor>
: public ilist_default_traits<SymbolRewriter::RewriteDescriptor> {
mutable ilist_half_node<SymbolRewriter::RewriteDescriptor> Sentinel;
public:
// createSentinel is used to get a reference to a node marking the end of
// the list. Because the sentinel is relative to this instance, use a
// non-static method.
SymbolRewriter::RewriteDescriptor *createSentinel() const {
// since i[p] lists always publicly derive from the corresponding
// traits, placing a data member in this class will augment the
// i[p]list. Since the NodeTy is expected to publicly derive from
// ilist_node<NodeTy>, there is a legal viable downcast from it to
// NodeTy. We use this trick to superpose i[p]list with a "ghostly"
// NodeTy, which becomes the sentinel. Dereferencing the sentinel is
// forbidden (save the ilist_node<NodeTy>) so no one will ever notice
// the superposition.
return static_cast<SymbolRewriter::RewriteDescriptor *>(&Sentinel);
}
void destroySentinel(SymbolRewriter::RewriteDescriptor *) {}
SymbolRewriter::RewriteDescriptor *provideInitialHead() const {
return createSentinel();
}
SymbolRewriter::RewriteDescriptor *
ensureHead(SymbolRewriter::RewriteDescriptor *&) const {
return createSentinel();
}
static void noteHead(SymbolRewriter::RewriteDescriptor *,
SymbolRewriter::RewriteDescriptor *) {}
};
ModulePass *createRewriteSymbolsPass();
ModulePass *createRewriteSymbolsPass(SymbolRewriter::RewriteDescriptorList &);
}
#endif
|
