LLVM  9.0.0svn
SymbolRemappingReader.h
Go to the documentation of this file.
1 //===- SymbolRemappingReader.h - Read symbol remapping file -----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file contains definitions needed for reading and applying symbol
10 // remapping files.
11 //
12 // Support is provided only for the Itanium C++ name mangling scheme for now.
13 //
14 // NOTE: If you are making changes to this file format, please remember
15 // to document them in the Clang documentation at
16 // tools/clang/docs/UsersManual.rst.
17 //
18 // File format
19 // -----------
20 //
21 // The symbol remappings are written as an ASCII text file. Blank lines and
22 // lines starting with a # are ignored. All other lines specify a kind of
23 // mangled name fragment, along with two fragments of that kind that should
24 // be treated as equivalent, separated by spaces.
25 //
26 // See http://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling for a
27 // description of the Itanium name mangling scheme.
28 //
29 // The accepted fragment kinds are:
30 //
31 // * name A <name>, such as 6foobar or St3__1
32 // * type A <type>, such as Ss or N4llvm9StringRefE
33 // * encoding An <encoding> (a complete mangling without the leading _Z)
34 //
35 // For example:
36 //
37 // # Ignore int / long differences to treat symbols from 32-bit and 64-bit
38 // # builds with differing size_t / ptrdiff_t / intptr_t as equivalent.
39 // type i l
40 // type j m
41 //
42 // # Ignore differences between libc++ and libstdc++, and between libstdc++'s
43 // # C++98 and C++11 ABIs.
44 // name 3std St3__1
45 // name 3std St7__cxx11
46 //
47 // # Remap a function overload to a specialization of a template (including
48 // # any local symbols declared within it).
49 // encoding N2NS1fEi N2NS1fIiEEvT_
50 //
51 // # Substitutions must be remapped separately from namespace 'std' for now.
52 // name Sa NSt3__19allocatorE
53 // name Sb NSt3__112basic_stringE
54 // type Ss NSt3__112basic_stringIcSt11char_traitsIcESaE
55 // # ...
56 //
57 //===----------------------------------------------------------------------===//
58 
59 #ifndef LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H
60 #define LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H
61 
62 #include "llvm/ADT/StringRef.h"
63 #include "llvm/Support/Error.h"
66 
67 namespace llvm {
68 
69 class SymbolRemappingParseError : public ErrorInfo<SymbolRemappingParseError> {
70 public:
71  SymbolRemappingParseError(StringRef File, int64_t Line, Twine Message)
72  : File(File), Line(Line), Message(Message.str()) {}
73 
74  void log(llvm::raw_ostream &OS) const override {
75  OS << File << ':' << Line << ": " << Message;
76  }
77  std::error_code convertToErrorCode() const override {
79  }
80 
81  StringRef getFileName() const { return File; }
82  int64_t getLineNum() const { return Line; }
83  StringRef getMessage() const { return Message; }
84 
85  static char ID;
86 
87 private:
88  std::string File;
89  int64_t Line;
90  std::string Message;
91 };
92 
93 /// Reader for symbol remapping files.
94 ///
95 /// Remaps the symbol names in profile data to match those in the program
96 /// according to a set of rules specified in a given file.
98 public:
99  /// Read remappings from the given buffer, which must live as long as
100  /// the remapper.
102 
103  /// A Key represents an equivalence class of symbol names.
104  using Key = uintptr_t;
105 
106  /// Construct a key for the given symbol, or return an existing one if an
107  /// equivalent name has already been inserted. The symbol name must live
108  /// as long as the remapper.
109  ///
110  /// The result will be Key() if the name cannot be remapped (typically
111  /// because it is not a valid mangled name).
112  Key insert(StringRef FunctionName) {
113  return Canonicalizer.canonicalize(FunctionName);
114  }
115 
116  /// Map the given symbol name into the key for the corresponding equivalence
117  /// class.
118  ///
119  /// The result will typically be Key() if no equivalent symbol has been
120  /// inserted, but this is not guaranteed: a Key different from all keys ever
121  /// returned by \c insert may be returned instead.
122  Key lookup(StringRef FunctionName) {
123  return Canonicalizer.lookup(FunctionName);
124  }
125 
126 private:
127  ItaniumManglingCanonicalizer Canonicalizer;
128 };
129 
130 } // end namespace llvm
131 
132 #endif // LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H
This class represents lattice values for constants.
Definition: AllocatorList.h:23
Key insert(StringRef FunctionName)
Construct a key for the given symbol, or return an existing one if an equivalent name has already bee...
Key lookup(StringRef FunctionName)
Map the given symbol name into the key for the corresponding equivalence class.
SymbolRemappingParseError(StringRef File, int64_t Line, Twine Message)
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
uintptr_t Key
A Key represents an equivalence class of symbol names.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
void log(llvm::raw_ostream &OS) const override
Print an error message to an output stream.
Canonicalizer for mangled names.
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:41
Base class for user error types.
Definition: Error.h:344
Reader for symbol remapping files.
value_type read(const void *memory, endianness endian)
Read a value of a particular endianness from memory.
Definition: Endian.h:65
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:77