1 //===- SymbolRewriter.cpp - Symbol Rewriter ---------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // SymbolRewriter is a LLVM pass which can rewrite symbols transparently within
11 // existing code.  It is implemented as a compiler pass and is configured via a
12 // YAML configuration file.
13 //
14 // The YAML configuration file format is as follows:
15 //
16 // RewriteMapFile := RewriteDescriptors
17 // RewriteDescriptors := RewriteDescriptor | RewriteDescriptors
18 // RewriteDescriptor := RewriteDescriptorType ':' '{' RewriteDescriptorFields '}'
19 // RewriteDescriptorFields := RewriteDescriptorField | RewriteDescriptorFields
20 // RewriteDescriptorField := FieldIdentifier ':' FieldValue ','
21 // RewriteDescriptorType := Identifier
22 // FieldIdentifier := Identifier
23 // FieldValue := Identifier
24 // Identifier := [0-9a-zA-Z]+
25 //
26 // Currently, the following descriptor types are supported:
27 //
28 // - function:          (function rewriting)
29 //      + Source        (original name of the function)
30 //      + Target        (explicit transformation)
31 //      + Transform     (pattern transformation)
32 //      + Naked         (boolean, whether the function is undecorated)
33 // - global variable:   (external linkage global variable rewriting)
34 //      + Source        (original name of externally visible variable)
35 //      + Target        (explicit transformation)
36 //      + Transform     (pattern transformation)
37 // - global alias:      (global alias rewriting)
38 //      + Source        (original name of the aliased name)
39 //      + Target        (explicit transformation)
40 //      + Transform     (pattern transformation)
41 //
42 // Note that source and exactly one of [Target, Transform] must be provided
43 //
44 // New rewrite descriptors can be created.  Addding a new rewrite descriptor
45 // involves:
46 //
47 //  a) extended the rewrite descriptor kind enumeration
48 //     (<anonymous>::RewriteDescriptor::RewriteDescriptorType)
49 //  b) implementing the new descriptor
50 //     (c.f. <anonymous>::ExplicitRewriteFunctionDescriptor)
51 //  c) extending the rewrite map parser
52 //     (<anonymous>::RewriteMapParser::parseEntry)
53 //
54 //  Specify to rewrite the symbols using the `-rewrite-symbols` option, and
55 //  specify the map file to use for the rewriting via the `-rewrite-map-file`
56 //  option.
57 //
58 //===----------------------------------------------------------------------===//
59 
60 #define DEBUG_TYPE "symbol-rewriter"
61 #include "llvm/CodeGen/Passes.h"
62 #include "llvm/Pass.h"
63 #include "llvm/ADT/SmallString.h"
64 #include "llvm/IR/LegacyPassManager.h"
65 #include "llvm/Support/CommandLine.h"
66 #include "llvm/Support/Debug.h"
67 #include "llvm/Support/MemoryBuffer.h"
68 #include "llvm/Support/Regex.h"
69 #include "llvm/Support/SourceMgr.h"
70 #include "llvm/Support/YAMLParser.h"
71 #include "llvm/Support/raw_ostream.h"
72 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
73 #include "llvm/Transforms/Utils/SymbolRewriter.h"
74 
75 using namespace llvm;
76 using namespace SymbolRewriter;
77 
78 static cl::list<std::string> RewriteMapFiles("rewrite-map-file",
79                                              cl::desc("Symbol Rewrite Map"),
80                                              cl::value_desc("filename"));
81 
82 static void rewriteComdat(Module &M, GlobalObject *GO,
83                           const std::string &Source,
84                           const std::string &Target) {
85   if (Comdat *CD = GO->getComdat()) {
86     auto &Comdats = M.getComdatSymbolTable();
87 
88     Comdat *C = M.getOrInsertComdat(Target);
89     C->setSelectionKind(CD->getSelectionKind());
90     GO->setComdat(C);
91 
92     Comdats.erase(Comdats.find(Source));
93   }
94 }
95 
96 namespace {
97 template <RewriteDescriptor::Type DT, typename ValueType,
98           ValueType *(llvm::Module::*Get)(StringRef) const>
99 class ExplicitRewriteDescriptor : public RewriteDescriptor {
100 public:
101   const std::string Source;
102   const std::string Target;
103 
104   ExplicitRewriteDescriptor(StringRef S, StringRef T, const bool Naked)
105       : RewriteDescriptor(DT), Source(Naked ? StringRef("\01" + S.str()) : S),
106         Target(T) {}
107 
108   bool performOnModule(Module &M) override;
109 
110   static bool classof(const RewriteDescriptor *RD) {
111     return RD->getType() == DT;
112   }
113 };
114 
115 template <RewriteDescriptor::Type DT, typename ValueType,
116           ValueType *(llvm::Module::*Get)(StringRef) const>
117 bool ExplicitRewriteDescriptor<DT, ValueType, Get>::performOnModule(Module &M) {
118   bool Changed = false;
119   if (ValueType *S = (M.*Get)(Source)) {
120     if (GlobalObject *GO = dyn_cast<GlobalObject>(S))
121       rewriteComdat(M, GO, Source, Target);
122 
123     if (Value *T = (M.*Get)(Target))
124       S->setValueName(T->getValueName());
125     else
126       S->setName(Target);
127 
128     Changed = true;
129   }
130   return Changed;
131 }
132 
133 template <RewriteDescriptor::Type DT, typename ValueType,
134           ValueType *(llvm::Module::*Get)(StringRef) const,
135           iterator_range<typename iplist<ValueType>::iterator>
136           (llvm::Module::*Iterator)()>
137 class PatternRewriteDescriptor : public RewriteDescriptor {
138 public:
139   const std::string Pattern;
140   const std::string Transform;
141 
142   PatternRewriteDescriptor(StringRef P, StringRef T)
143     : RewriteDescriptor(DT), Pattern(P), Transform(T) { }
144 
145   bool performOnModule(Module &M) override;
146 
147   static bool classof(const RewriteDescriptor *RD) {
148     return RD->getType() == DT;
149   }
150 };
151 
152 template <RewriteDescriptor::Type DT, typename ValueType,
153           ValueType *(llvm::Module::*Get)(StringRef) const,
154           iterator_range<typename iplist<ValueType>::iterator>
155           (llvm::Module::*Iterator)()>
156 bool PatternRewriteDescriptor<DT, ValueType, Get, Iterator>::
157 performOnModule(Module &M) {
158   bool Changed = false;
159   for (auto &C : (M.*Iterator)()) {
160     std::string Error;
161 
162     std::string Name = Regex(Pattern).sub(Transform, C.getName(), &Error);
163     if (!Error.empty())
164       report_fatal_error("unable to transforn " + C.getName() + " in " +
165                          M.getModuleIdentifier() + ": " + Error);
166 
167     if (C.getName() == Name)
168       continue;
169 
170     if (GlobalObject *GO = dyn_cast<GlobalObject>(&C))
171       rewriteComdat(M, GO, C.getName(), Name);
172 
173     if (Value *V = (M.*Get)(Name))
174       C.setValueName(V->getValueName());
175     else
176       C.setName(Name);
177 
178     Changed = true;
179   }
180   return Changed;
181 }
182 
183 /// Represents a rewrite for an explicitly named (function) symbol.  Both the
184 /// source function name and target function name of the transformation are
185 /// explicitly spelt out.
186 typedef ExplicitRewriteDescriptor<RewriteDescriptor::Type::Function,
187                                   llvm::Function, &llvm::Module::getFunction>
188     ExplicitRewriteFunctionDescriptor;
189 
190 /// Represents a rewrite for an explicitly named (global variable) symbol.  Both
191 /// the source variable name and target variable name are spelt out.  This
192 /// applies only to module level variables.
193 typedef ExplicitRewriteDescriptor<RewriteDescriptor::Type::GlobalVariable,
194                                   llvm::GlobalVariable,
195                                   &llvm::Module::getGlobalVariable>
196     ExplicitRewriteGlobalVariableDescriptor;
197 
198 /// Represents a rewrite for an explicitly named global alias.  Both the source
199 /// and target name are explicitly spelt out.
200 typedef ExplicitRewriteDescriptor<RewriteDescriptor::Type::NamedAlias,
201                                   llvm::GlobalAlias,
202                                   &llvm::Module::getNamedAlias>
203     ExplicitRewriteNamedAliasDescriptor;
204 
205 /// Represents a rewrite for a regular expression based pattern for functions.
206 /// A pattern for the function name is provided and a transformation for that
207 /// pattern to determine the target function name create the rewrite rule.
208 typedef PatternRewriteDescriptor<RewriteDescriptor::Type::Function,
209                                  llvm::Function, &llvm::Module::getFunction,
210                                  &llvm::Module::functions>
211     PatternRewriteFunctionDescriptor;
212 
213 /// Represents a rewrite for a global variable based upon a matching pattern.
214 /// Each global variable matching the provided pattern will be transformed as
215 /// described in the transformation pattern for the target.  Applies only to
216 /// module level variables.
217 typedef PatternRewriteDescriptor<RewriteDescriptor::Type::GlobalVariable,
218                                  llvm::GlobalVariable,
219                                  &llvm::Module::getGlobalVariable,
220                                  &llvm::Module::globals>
221     PatternRewriteGlobalVariableDescriptor;
222 
223 /// PatternRewriteNamedAliasDescriptor - represents a rewrite for global
224 /// aliases which match a given pattern.  The provided transformation will be
225 /// applied to each of the matching names.
226 typedef PatternRewriteDescriptor<RewriteDescriptor::Type::NamedAlias,
227                                  llvm::GlobalAlias,
228                                  &llvm::Module::getNamedAlias,
229                                  &llvm::Module::aliases>
230     PatternRewriteNamedAliasDescriptor;
231 } // namespace
232 
233 bool RewriteMapParser::parse(const std::string &MapFile,
234                              RewriteDescriptorList *DL) {
235   ErrorOr<std::unique_ptr<MemoryBuffer>> Mapping =
236       MemoryBuffer::getFile(MapFile);
237 
238   if (!Mapping)
239     report_fatal_error("unable to read rewrite map '" + MapFile + "': " +
240                        Mapping.getError().message());
241 
242   if (!parse(*Mapping, DL))
243     report_fatal_error("unable to parse rewrite map '" + MapFile + "'");
244 
245   return true;
246 }
247 
248 bool RewriteMapParser::parse(std::unique_ptr<MemoryBuffer> &MapFile,
249                              RewriteDescriptorList *DL) {
250   SourceMgr SM;
251   yaml::Stream YS(MapFile->getBuffer(), SM);
252 
253   for (auto &Document : YS) {
254     yaml::MappingNode *DescriptorList;
255 
256     // ignore empty documents
257     if (isa<yaml::NullNode>(Document.getRoot()))
258       continue;
259 
260     DescriptorList = dyn_cast<yaml::MappingNode>(Document.getRoot());
261     if (!DescriptorList) {
262       YS.printError(Document.getRoot(), "DescriptorList node must be a map");
263       return false;
264     }
265 
266     for (auto &Descriptor : *DescriptorList)
267       if (!parseEntry(YS, Descriptor, DL))
268         return false;
269   }
270 
271   return true;
272 }
273 
274 bool RewriteMapParser::parseEntry(yaml::Stream &YS, yaml::KeyValueNode &Entry,
275                                   RewriteDescriptorList *DL) {
276   yaml::ScalarNode *Key;
277   yaml::MappingNode *Value;
278   SmallString<32> KeyStorage;
279   StringRef RewriteType;
280 
281   Key = dyn_cast<yaml::ScalarNode>(Entry.getKey());
282   if (!Key) {
283     YS.printError(Entry.getKey(), "rewrite type must be a scalar");
284     return false;
285   }
286 
287   Value = dyn_cast<yaml::MappingNode>(Entry.getValue());
288   if (!Value) {
289     YS.printError(Entry.getValue(), "rewrite descriptor must be a map");
290     return false;
291   }
292 
293   RewriteType = Key->getValue(KeyStorage);
294   if (RewriteType.equals("function"))
295     return parseRewriteFunctionDescriptor(YS, Key, Value, DL);
296   else if (RewriteType.equals("global variable"))
297     return parseRewriteGlobalVariableDescriptor(YS, Key, Value, DL);
298   else if (RewriteType.equals("global alias"))
299     return parseRewriteGlobalAliasDescriptor(YS, Key, Value, DL);
300 
301   YS.printError(Entry.getKey(), "unknown rewrite type");
302   return false;
303 }
304 
305 bool RewriteMapParser::
306 parseRewriteFunctionDescriptor(yaml::Stream &YS, yaml::ScalarNode *K,
307                                yaml::MappingNode *Descriptor,
308                                RewriteDescriptorList *DL) {
309   bool Naked = false;
310   std::string Source;
311   std::string Target;
312   std::string Transform;
313 
314   for (auto &Field : *Descriptor) {
315     yaml::ScalarNode *Key;
316     yaml::ScalarNode *Value;
317     SmallString<32> KeyStorage;
318     SmallString<32> ValueStorage;
319     StringRef KeyValue;
320 
321     Key = dyn_cast<yaml::ScalarNode>(Field.getKey());
322     if (!Key) {
323       YS.printError(Field.getKey(), "descriptor key must be a scalar");
324       return false;
325     }
326 
327     Value = dyn_cast<yaml::ScalarNode>(Field.getValue());
328     if (!Value) {
329       YS.printError(Field.getValue(), "descriptor value must be a scalar");
330       return false;
331     }
332 
333     KeyValue = Key->getValue(KeyStorage);
334     if (KeyValue.equals("source")) {
335       std::string Error;
336 
337       Source = Value->getValue(ValueStorage);
338       if (!Regex(Source).isValid(Error)) {
339         YS.printError(Field.getKey(), "invalid regex: " + Error);
340         return false;
341       }
342     } else if (KeyValue.equals("target")) {
343       Target = Value->getValue(ValueStorage);
344     } else if (KeyValue.equals("transform")) {
345       Transform = Value->getValue(ValueStorage);
346     } else if (KeyValue.equals("naked")) {
347       std::string Undecorated;
348 
349       Undecorated = Value->getValue(ValueStorage);
350       Naked = StringRef(Undecorated).lower() == "true" || Undecorated == "1";
351     } else {
352       YS.printError(Field.getKey(), "unknown key for function");
353       return false;
354     }
355   }
356 
357   if (Transform.empty() == Target.empty()) {
358     YS.printError(Descriptor,
359                   "exactly one of transform or target must be specified");
360     return false;
361   }
362 
363   // TODO see if there is a more elegant solution to selecting the rewrite
364   // descriptor type
365   if (!Target.empty())
366     DL->push_back(new ExplicitRewriteFunctionDescriptor(Source, Target, Naked));
367   else
368     DL->push_back(new PatternRewriteFunctionDescriptor(Source, Transform));
369 
370   return true;
371 }
372 
373 bool RewriteMapParser::
374 parseRewriteGlobalVariableDescriptor(yaml::Stream &YS, yaml::ScalarNode *K,
375                                      yaml::MappingNode *Descriptor,
376                                      RewriteDescriptorList *DL) {
377   std::string Source;
378   std::string Target;
379   std::string Transform;
380 
381   for (auto &Field : *Descriptor) {
382     yaml::ScalarNode *Key;
383     yaml::ScalarNode *Value;
384     SmallString<32> KeyStorage;
385     SmallString<32> ValueStorage;
386     StringRef KeyValue;
387 
388     Key = dyn_cast<yaml::ScalarNode>(Field.getKey());
389     if (!Key) {
390       YS.printError(Field.getKey(), "descriptor Key must be a scalar");
391       return false;
392     }
393 
394     Value = dyn_cast<yaml::ScalarNode>(Field.getValue());
395     if (!Value) {
396       YS.printError(Field.getValue(), "descriptor value must be a scalar");
397       return false;
398     }
399 
400     KeyValue = Key->getValue(KeyStorage);
401     if (KeyValue.equals("source")) {
402       std::string Error;
403 
404       Source = Value->getValue(ValueStorage);
405       if (!Regex(Source).isValid(Error)) {
406         YS.printError(Field.getKey(), "invalid regex: " + Error);
407         return false;
408       }
409     } else if (KeyValue.equals("target")) {
410       Target = Value->getValue(ValueStorage);
411     } else if (KeyValue.equals("transform")) {
412       Transform = Value->getValue(ValueStorage);
413     } else {
414       YS.printError(Field.getKey(), "unknown Key for Global Variable");
415       return false;
416     }
417   }
418 
419   if (Transform.empty() == Target.empty()) {
420     YS.printError(Descriptor,
421                   "exactly one of transform or target must be specified");
422     return false;
423   }
424 
425   if (!Target.empty())
426     DL->push_back(new ExplicitRewriteGlobalVariableDescriptor(Source, Target,
427                                                               /*Naked*/false));
428   else
429     DL->push_back(new PatternRewriteGlobalVariableDescriptor(Source,
430                                                              Transform));
431 
432   return true;
433 }
434 
435 bool RewriteMapParser::
436 parseRewriteGlobalAliasDescriptor(yaml::Stream &YS, yaml::ScalarNode *K,
437                                   yaml::MappingNode *Descriptor,
438                                   RewriteDescriptorList *DL) {
439   std::string Source;
440   std::string Target;
441   std::string Transform;
442 
443   for (auto &Field : *Descriptor) {
444     yaml::ScalarNode *Key;
445     yaml::ScalarNode *Value;
446     SmallString<32> KeyStorage;
447     SmallString<32> ValueStorage;
448     StringRef KeyValue;
449 
450     Key = dyn_cast<yaml::ScalarNode>(Field.getKey());
451     if (!Key) {
452       YS.printError(Field.getKey(), "descriptor key must be a scalar");
453       return false;
454     }
455 
456     Value = dyn_cast<yaml::ScalarNode>(Field.getValue());
457     if (!Value) {
458       YS.printError(Field.getValue(), "descriptor value must be a scalar");
459       return false;
460     }
461 
462     KeyValue = Key->getValue(KeyStorage);
463     if (KeyValue.equals("source")) {
464       std::string Error;
465 
466       Source = Value->getValue(ValueStorage);
467       if (!Regex(Source).isValid(Error)) {
468         YS.printError(Field.getKey(), "invalid regex: " + Error);
469         return false;
470       }
471     } else if (KeyValue.equals("target")) {
472       Target = Value->getValue(ValueStorage);
473     } else if (KeyValue.equals("transform")) {
474       Transform = Value->getValue(ValueStorage);
475     } else {
476       YS.printError(Field.getKey(), "unknown key for Global Alias");
477       return false;
478     }
479   }
480 
481   if (Transform.empty() == Target.empty()) {
482     YS.printError(Descriptor,
483                   "exactly one of transform or target must be specified");
484     return false;
485   }
486 
487   if (!Target.empty())
488     DL->push_back(new ExplicitRewriteNamedAliasDescriptor(Source, Target,
489                                                           /*Naked*/false));
490   else
491     DL->push_back(new PatternRewriteNamedAliasDescriptor(Source, Transform));
492 
493   return true;
494 }
495 
496 namespace {
497 class RewriteSymbols : public ModulePass {
498 public:
499   static char ID; // Pass identification, replacement for typeid
500 
501   RewriteSymbols();
502   RewriteSymbols(SymbolRewriter::RewriteDescriptorList &DL);
503 
504   bool runOnModule(Module &M) override;
505 
506 private:
507   void loadAndParseMapFiles();
508 
509   SymbolRewriter::RewriteDescriptorList Descriptors;
510 };
511 
512 char RewriteSymbols::ID = 0;
513 
514 RewriteSymbols::RewriteSymbols() : ModulePass(ID) {
515   initializeRewriteSymbolsPass(*PassRegistry::getPassRegistry());
516   loadAndParseMapFiles();
517 }
518 
519 RewriteSymbols::RewriteSymbols(SymbolRewriter::RewriteDescriptorList &DL)
520     : ModulePass(ID) {
521   Descriptors.splice(Descriptors.begin(), DL);
522 }
523 
524 bool RewriteSymbols::runOnModule(Module &M) {
525   bool Changed;
526 
527   Changed = false;
528   for (auto &Descriptor : Descriptors)
529     Changed |= Descriptor.performOnModule(M);
530 
531   return Changed;
532 }
533 
534 void RewriteSymbols::loadAndParseMapFiles() {
535   const std::vector<std::string> MapFiles(RewriteMapFiles);
536   SymbolRewriter::RewriteMapParser parser;
537 
538   for (const auto &MapFile : MapFiles)
539     parser.parse(MapFile, &Descriptors);
540 }
541 }
542 
543 INITIALIZE_PASS(RewriteSymbols, "rewrite-symbols", "Rewrite Symbols", false,
544                 false)
545 
546 ModulePass *llvm::createRewriteSymbolsPass() { return new RewriteSymbols(); }
547 
548 ModulePass *
549 llvm::createRewriteSymbolsPass(SymbolRewriter::RewriteDescriptorList &DL) {
550   return new RewriteSymbols(DL);
551 }
552