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
202
203
204
205
206
207
208
|
// gold.h -- general definitions for gold -*- C++ -*-
#ifndef GOLD_GOLD_H
#include "config.h"
#include "ansidecl.h"
#ifdef ENABLE_NLS
# include <libintl.h>
# define _(String) gettext (String)
# ifdef gettext_noop
# define N_(String) gettext_noop (String)
# else
# define N_(String) (String)
# endif
#else
# define gettext(Msgid) (Msgid)
# define dgettext(Domainname, Msgid) (Msgid)
# define dcgettext(Domainname, Msgid, Category) (Msgid)
# define textdomain(Domainname) while (0) /* nothing */
# define bindtextdomain(Domainname, Dirname) while (0) /* nothing */
# define _(String) (String)
# define N_(String) (String)
#endif
// Figure out how to get a hash set and a hash map.
#if defined(HAVE_TR1_UNORDERED_SET) && defined(HAVE_TR1_UNORDERED_MAP)
#include <tr1/unordered_set>
#include <tr1/unordered_map>
// We need a template typedef here.
#define Unordered_set std::tr1::unordered_set
#define Unordered_map std::tr1::unordered_map
#elif defined(HAVE_EXT_HASH_MAP) && defined(HAVE_EXT_HASH_SET)
#include <ext/hash_map>
#include <ext/hash_set>
#include <string>
#define Unordered_set __gnu_cxx::hash_set
#define Unordered_map __gnu_cxx::hash_map
namespace __gnu_cxx
{
template<>
struct hash<std::string>
{
size_t
operator()(std::string s) const
{ return __stl_hash_string(s.c_str()); }
};
template<typename T>
struct hash<T*>
{
size_t
operator()(T* p) const
{ return reinterpret_cast<size_t>(p); }
};
}
#else
// The fallback is to just use set and map.
#include <set>
#include <map>
#define Unordered_set std::set
#define Unordered_map std::map
#endif
namespace gold
{
// This is a hack to work around a problem with older versions of g++.
// The problem is that they don't support calling a member template by
// specifying the template parameters. It works to pass in an
// argument for argument dependent lookup.
// To use this, the member template method declaration should put
// ACCEPT_SIZE or ACCEPT_SIZE_ENDIAN after the last parameter. If the
// method takes no parameters, use ACCEPT_SIZE_ONLY or
// ACCEPT_SIZE_ENDIAN_ONLY.
// When calling the method, instead of using fn<size>, use fn
// SELECT_SIZE_NAME or SELECT_SIZE_ENDIAN_NAME. And after the last
// argument, put SELECT_SIZE(size) or SELECT_SIZE_ENDIAN(size,
// big_endian). If there is only one argment, use the _ONLY variants.
#ifdef HAVE_MEMBER_TEMPLATE_SPECIFICATIONS
#define SELECT_SIZE_NAME(size) <size>
#define SELECT_SIZE(size)
#define SELECT_SIZE_ONLY(size)
#define ACCEPT_SIZE
#define ACCEPT_SIZE_ONLY
#define SELECT_SIZE_ENDIAN_NAME(size, big_endian) <size, big_endian>
#define SELECT_SIZE_ENDIAN(size, big_endian)
#define SELECT_SIZE_ENDIAN_ONLY(size, big_endian)
#define ACCEPT_SIZE_ENDIAN
#define ACCEPT_SIZE_ENDIAN_ONLY
#else // !defined(HAVE_MEMBER_TEMPLATE_SPECIFICATIONS)
template<int size>
class Select_size { };
template<int size, bool big_endian>
class Select_size_endian { };
#define SELECT_SIZE_NAME(size)
#define SELECT_SIZE(size) , Select_size<size>()
#define SELECT_SIZE_ONLY(size) Select_size<size>()
#define ACCEPT_SIZE , Select_size<size>
#define ACCEPT_SIZE_ONLY Select_size<size>
#define SELECT_SIZE_ENDIAN_NAME(size, big_endian)
#define SELECT_SIZE_ENDIAN(size, big_endian) \
, Select_size_endian<size, big_endian>()
#define SELECT_SIZE_ENDIAN_ONLY(size, big_endian) \
Select_size_endian<size, big_endian>()
#define ACCEPT_SIZE_ENDIAN , Select_size_endian<size, big_endian>
#define ACCEPT_SIZE_ENDIAN_ONLY Select_size_endian<size, big_endian>
#endif // !defined(HAVE_MEMBER_TEMPLATE_SPECIFICATIONS)
} // End namespace gold.
namespace gold
{
class General_options;
class Input_argument_list;
class Dirsearch;
class Input_objects;
class Symbol_table;
class Layout;
class Workqueue;
class Output_file;
// The name of the program as used in error messages.
extern const char* program_name;
// This function is called to exit the program. Status is true to
// exit success (0) and false to exit failure (1).
extern void
gold_exit(bool status) ATTRIBUTE_NORETURN;
// This function is called to emit an unexpected error message and a
// newline, and then exit with failure. If PERRNO is true, it reports
// the error in errno.
extern void
gold_fatal(const char* msg, bool perrno) ATTRIBUTE_NORETURN;
// This is function is called in some cases if we run out of memory.
extern void
gold_nomem() ATTRIBUTE_NORETURN;
// This macro and function are used in cases which can not arise if
// the code is written correctly.
#define gold_unreachable() \
(gold::do_gold_unreachable(__FILE__, __LINE__, __FUNCTION__))
extern void do_gold_unreachable(const char*, int, const char*)
ATTRIBUTE_NORETURN;
// Assertion check.
#define gold_assert(expr) ((void)(!(expr) ? gold_unreachable(), 0 : 0))
// Queue up the first set of tasks.
extern void
queue_initial_tasks(const General_options&,
const Dirsearch&,
const Input_argument_list&,
Workqueue*,
Input_objects*,
Symbol_table*,
Layout*);
// Queue up the middle set of tasks.
extern void
queue_middle_tasks(const General_options&,
const Input_objects*,
Symbol_table*,
Layout*,
Workqueue*);
// Queue up the final set of tasks.
extern void
queue_final_tasks(const General_options&,
const Input_objects*,
const Symbol_table*,
const Layout*,
Workqueue*,
Output_file* of);
} // End namespace gold.
#endif // !defined(GOLD_GOLD_H)
|
