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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
|
/*
* Copyright (c) 2011, Chris Johns <chrisj@rtems.org>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/**
* @file
*
* @ingroup rtems-ld
*
* @brief RTEMS Linker symbols manages the symbols from all the object files.
*
*/
#if !defined (_RLD_SYMBOLS_H_)
#define _RLD_SYMBOLS_H_
#include <iostream>
#include <list>
#include <map>
#include <string>
#include <rld-elf-types.h>
namespace rld
{
/**
* Forward declarations.
*/
namespace files
{
class object;
}
namespace symbols
{
/**
* A symbol.
*/
class symbol
{
public:
/**
* Default constructor. No symbol has been defined.
*/
symbol ();
/**
* Construct an exported symbol with a object file.
*/
symbol (const std::string& name,
files::object& object,
const elf::elf_sym& esym);
/**
* Construct an unresolved symbol with no object file.
*/
symbol (const std::string& name, const elf::elf_sym& esym);
/**
* Construct a linker symbol that is internally created.
*/
symbol (const std::string& name,
const elf::elf_addr value);
/**
* Construct a linker symbol that is internally created.
*/
symbol (const char* name,
elf::elf_addr value = 0);
/**
* The symbol's name.
*/
const std::string& name () const;
/**
* The symbol's demangled name.
*/
const std::string& demangled () const;
/**
* Is the symbol a C++ name ?
*/
bool is_cplusplus () const;
/**
* The symbol's type.
*/
int type () const;
/**
* The symbol's binding, ie local, weak, or global.
*/
int binding () const;
/**
* The synbol's section index.
*/
int index () const;
/**
* The symbol's object file name.
*/
files::object* object () const;
/**
* Set the symbol's object file name. Used when resolving unresolved
* symbols.
*/
void set_object (files::object& obj);
/**
* The ELF symbol.
*/
const elf::elf_sym& esym () const;
/**
* Return the number of references.
*/
int references () const {
return references_;
}
/**
* Return the number of references.
*/
void referenced ();
/**
* Less than operator for the map container.
*/
bool operator< (const symbol& rhs) const;
/**
* Output to the a stream.
*/
void output (std::ostream& out) const;
private:
std::string name_; //< The name of the symbol.
std::string demangled_; //< If a C++ symbol the demangled name.
files::object* object_; //< The object file containing the symbol.
elf::elf_sym esym_; //< The ELF symbol.
int references_; //< The number of times if it referenced.
};
/**
* Container of symbols. A bucket of symbols.
*/
typedef std::list < symbol > bucket;
/**
* References to symbols. Should always point to symbols held in a bucket.
*/
typedef std::list < symbol* > pointers;
/**
* A symbols table is a map container of symbols. Should always point to
* symbols held in a bucket.
*/
typedef std::map < std::string, symbol* > table;
/**
* Load a table from a buckey.
*/
void load (bucket& bucket_, table& table_);
/**
* Given a container of symbols return how many are referenced.
*/
size_t referenced (pointers& symbols);
/**
* Output the symbol table.
*/
void output (std::ostream& out, const table& symbols);
}
}
/**
* Output stream operator.
*/
static inline std::ostream& operator<< (std::ostream& out,
const rld::symbols::symbol& sym) {
sym.output (out);
return out;
}
#endif
|
