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_PROFILEDATA_SYMBOLREMAPPINGREADER_H
60#define LLVM_PROFILEDATA_SYMBOLREMAPPINGREADER_H
61
62#include "llvm/ADT/StringRef.h"
63#include "llvm/ProfileData/ItaniumManglingCanonicalizer.h"
64#include "llvm/Support/Error.h"
65
66namespace llvm {
67
68class MemoryBuffer;
69
70class SymbolRemappingParseError : public ErrorInfo<SymbolRemappingParseError> {
71public:
72 SymbolRemappingParseError(StringRef File, int64_t Line, const Twine &Message)
73 : File(File), Line(Line), Message(Message.str()) {}
74
75 void log(llvm::raw_ostream &OS) const override {
76 OS << File << ':' << Line << ": " << Message;
77 }
78 std::error_code convertToErrorCode() const override {
79 return llvm::inconvertibleErrorCode();
80 }
81
82 StringRef getFileName() const { return File; }
83 int64_t getLineNum() const { return Line; }
84 StringRef getMessage() const { return Message; }
85
86 static char ID;
87
88private:
89 std::string File;
90 int64_t Line;
91 std::string Message;
92};
93
94/// Reader for symbol remapping files.
95///
96/// Remaps the symbol names in profile data to match those in the program
97/// according to a set of rules specified in a given file.
98class SymbolRemappingReader {
99public:
100 /// Read remappings from the given buffer, which must live as long as
101 /// the remapper.
102 Error read(MemoryBuffer &B);
103
104 /// A Key represents an equivalence class of symbol names.
105 using Key = uintptr_t;
106
107 /// Construct a key for the given symbol, or return an existing one if an
108 /// equivalent name has already been inserted. The symbol name must live
109 /// as long as the remapper.
110 ///
111 /// The result will be Key() if the name cannot be remapped (typically
112 /// because it is not a valid mangled name).
113 Key insert(StringRef FunctionName) {
114 return Canonicalizer.canonicalize(Mangling: FunctionName);
115 }
116
117 /// Map the given symbol name into the key for the corresponding equivalence
118 /// class.
119 ///
120 /// The result will typically be Key() if no equivalent symbol has been
121 /// inserted, but this is not guaranteed: a Key different from all keys ever
122 /// returned by \c insert may be returned instead.
123 Key lookup(StringRef FunctionName) {
124 return Canonicalizer.lookup(Mangling: FunctionName);
125 }
126
127private:
128 ItaniumManglingCanonicalizer Canonicalizer;
129};
130
131} // end namespace llvm
132
133#endif // LLVM_PROFILEDATA_SYMBOLREMAPPINGREADER_H
134

source code of llvm/include/llvm/ProfileData/SymbolRemappingReader.h