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
|
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef SIMPLE_PERF_DSO_H_
#define SIMPLE_PERF_DSO_H_
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
#include <vector>
#include "build_id.h"
struct Symbol {
uint64_t addr;
uint64_t len;
Symbol(const std::string& name, uint64_t addr, uint64_t len);
const char* Name() const { return name_; }
const char* DemangledName() const;
bool HasDumped() const { return has_dumped_; }
void SetDumped() const { has_dumped_ = true; }
private:
const char* name_;
mutable const char* demangled_name_;
mutable bool has_dumped_;
};
struct SymbolComparator {
bool operator()(const Symbol& symbol1, const Symbol& symbol2) {
return symbol1.addr < symbol2.addr;
}
};
enum DsoType {
DSO_KERNEL,
DSO_KERNEL_MODULE,
DSO_ELF_FILE,
};
struct KernelSymbol;
struct ElfFileSymbol;
struct Dso {
public:
static void SetDemangle(bool demangle);
static std::string Demangle(const std::string& name);
static bool SetSymFsDir(const std::string& symfs_dir);
static void SetVmlinux(const std::string& vmlinux);
static void SetKallsyms(std::string kallsyms) {
if (!kallsyms.empty()) {
kallsyms_ = std::move(kallsyms);
}
}
static void SetBuildIds(
const std::vector<std::pair<std::string, BuildId>>& build_ids);
static std::unique_ptr<Dso> CreateDso(DsoType dso_type,
const std::string& dso_path);
~Dso();
DsoType type() const { return type_; }
uint64_t id() const { return id_; }
// Return the path recorded in perf.data.
const std::string& Path() const { return path_; }
// Return the path containing symbol table and debug information.
const std::string& GetDebugFilePath() const { return debug_file_path_; }
bool HasDumped() const { return has_dumped_; }
void SetDumped() { has_dumped_ = true; }
// Return the minimum virtual address in program header.
uint64_t MinVirtualAddress();
void SetMinVirtualAddress(uint64_t min_vaddr) { min_vaddr_ = min_vaddr; }
const Symbol* FindSymbol(uint64_t vaddr_in_dso);
void InsertSymbol(const Symbol& symbol);
private:
static bool demangle_;
static std::string symfs_dir_;
static std::string vmlinux_;
static std::string kallsyms_;
static std::unordered_map<std::string, BuildId> build_id_map_;
static size_t dso_count_;
Dso(DsoType type, uint64_t id, const std::string& path);
bool Load();
bool LoadKernel();
bool LoadKernelModule();
bool LoadElfFile();
bool LoadEmbeddedElfFile();
void FixupSymbolLength();
BuildId GetExpectedBuildId();
const DsoType type_;
const uint64_t id_;
// path of the shared library used by the profiled program
const std::string path_;
// path of the shared library having symbol table and debug information
// It is the same as path_, or has the same build id as path_.
std::string debug_file_path_;
uint64_t min_vaddr_;
std::set<Symbol, SymbolComparator> symbols_;
bool is_loaded_;
bool has_dumped_;
};
const char* DsoTypeToString(DsoType dso_type);
#endif // SIMPLE_PERF_DSO_H_
|
