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
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//===- SymbolRemappingReader.h - Read symbol remapping file -----*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file contains definitions needed for reading and applying symbol
// remapping files.
//
// Support is provided only for the Itanium C++ name mangling scheme for now.
//
// NOTE: If you are making changes to this file format, please remember
// to document them in the Clang documentation at
// tools/clang/docs/UsersManual.rst.
//
// File format
// -----------
//
// The symbol remappings are written as an ASCII text file. Blank lines and
// lines starting with a # are ignored. All other lines specify a kind of
// mangled name fragment, along with two fragments of that kind that should
// be treated as equivalent, separated by spaces.
//
// See http://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling for a
// description of the Itanium name mangling scheme.
//
// The accepted fragment kinds are:
//
// * name A <name>, such as 6foobar or St3__1
// * type A <type>, such as Ss or N4llvm9StringRefE
// * encoding An <encoding> (a complete mangling without the leading _Z)
//
// For example:
//
// # Ignore int / long differences to treat symbols from 32-bit and 64-bit
// # builds with differing size_t / ptrdiff_t / intptr_t as equivalent.
// type i l
// type j m
//
// # Ignore differences between libc++ and libstdc++, and between libstdc++'s
// # C++98 and C++11 ABIs.
// name 3std St3__1
// name 3std St7__cxx11
//
// # Remap a function overload to a specialization of a template (including
// # any local symbols declared within it).
// encoding N2NS1fEi N2NS1fIiEEvT_
//
// # Substitutions must be remapped separately from namespace 'std' for now.
// name Sa NSt3__19allocatorE
// name Sb NSt3__112basic_stringE
// type Ss NSt3__112basic_stringIcSt11char_traitsIcESaE
// # ...
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H
#define LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Error.h"
#include "llvm/Support/ItaniumManglingCanonicalizer.h"
namespace llvm {
class MemoryBuffer;
class SymbolRemappingParseError : public ErrorInfo<SymbolRemappingParseError> {
public:
SymbolRemappingParseError(StringRef File, int64_t Line, const Twine &Message)
: File(File), Line(Line), Message(Message.str()) {}
void log(llvm::raw_ostream &OS) const override {
OS << File << ':' << Line << ": " << Message;
}
std::error_code convertToErrorCode() const override {
return llvm::inconvertibleErrorCode();
}
StringRef getFileName() const { return File; }
int64_t getLineNum() const { return Line; }
StringRef getMessage() const { return Message; }
static char ID;
private:
std::string File;
int64_t Line;
std::string Message;
};
/// Reader for symbol remapping files.
///
/// Remaps the symbol names in profile data to match those in the program
/// according to a set of rules specified in a given file.
class SymbolRemappingReader {
public:
/// Read remappings from the given buffer, which must live as long as
/// the remapper.
Error read(MemoryBuffer &B);
/// A Key represents an equivalence class of symbol names.
using Key = uintptr_t;
/// Construct a key for the given symbol, or return an existing one if an
/// equivalent name has already been inserted. The symbol name must live
/// as long as the remapper.
///
/// The result will be Key() if the name cannot be remapped (typically
/// because it is not a valid mangled name).
Key insert(StringRef FunctionName) {
return Canonicalizer.canonicalize(FunctionName);
}
/// Map the given symbol name into the key for the corresponding equivalence
/// class.
///
/// The result will typically be Key() if no equivalent symbol has been
/// inserted, but this is not guaranteed: a Key different from all keys ever
/// returned by \c insert may be returned instead.
Key lookup(StringRef FunctionName) {
return Canonicalizer.lookup(FunctionName);
}
private:
ItaniumManglingCanonicalizer Canonicalizer;
};
} // end namespace llvm
#endif // LLVM_SUPPORT_SYMBOLREMAPPINGREADER_H
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
