1 // gold.h -- general definitions for gold -*- C++ -*- 2 3 // Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. 4 // Written by Ian Lance Taylor <iant@google.com>. 5 6 // This file is part of gold. 7 8 // This program is free software; you can redistribute it and/or modify 9 // it under the terms of the GNU General Public License as published by 10 // the Free Software Foundation; either version 3 of the License, or 11 // (at your option) any later version. 12 13 // This program is distributed in the hope that it will be useful, 14 // but WITHOUT ANY WARRANTY; without even the implied warranty of 15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 // GNU General Public License for more details. 17 18 // You should have received a copy of the GNU General Public License 19 // along with this program; if not, write to the Free Software 20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 21 // MA 02110-1301, USA. 22 23 #ifndef GOLD_GOLD_H 24 #define GOLD_GOLD_H 25 26 #include "config.h" 27 #include "ansidecl.h" 28 29 #include <cstddef> 30 #include <cstdlib> 31 #include <cstring> 32 #include <stdint.h> 33 #include <sys/types.h> 34 35 #ifndef ENABLE_NLS 36 // The Solaris version of locale.h always includes libintl.h. If we 37 // have been configured with --disable-nls then ENABLE_NLS will not 38 // be defined and the dummy definitions of bindtextdomain (et al) 39 // below will conflict with the definitions in libintl.h. So we 40 // define these values to prevent the bogus inclusion of libintl.h. 41 # define _LIBINTL_H 42 # define _LIBGETTEXT_H 43 #endif 44 45 #ifdef ENABLE_NLS 46 // On some systems, things go awry when <libintl.h> comes after <clocale>. 47 # include <libintl.h> 48 # include <clocale> 49 # define _(String) gettext (String) 50 # ifdef gettext_noop 51 # define N_(String) gettext_noop (String) 52 # else 53 # define N_(String) (String) 54 # endif 55 #else 56 // Include <clocale> first to avoid conflicts with these macros. 57 # include <clocale> 58 # define gettext(Msgid) (Msgid) 59 # define dgettext(Domainname, Msgid) (Msgid) 60 # define dcgettext(Domainname, Msgid, Category) (Msgid) 61 # define textdomain(Domainname) do {} while (0) /* nothing */ 62 # define bindtextdomain(Domainname, Dirname) do {} while (0) /* nothing */ 63 # define _(String) (String) 64 # define N_(String) (String) 65 #endif 66 67 // Figure out how to get a hash set and a hash map. 68 69 #if defined(HAVE_TR1_UNORDERED_SET) && defined(HAVE_TR1_UNORDERED_MAP) \ 70 && defined(HAVE_TR1_UNORDERED_MAP_REHASH) 71 72 #include <tr1/unordered_set> 73 #include <tr1/unordered_map> 74 75 // We need a template typedef here. 76 77 #define Unordered_set std::tr1::unordered_set 78 #define Unordered_map std::tr1::unordered_map 79 #define Unordered_multimap std::tr1::unordered_multimap 80 81 #define reserve_unordered_map(map, n) ((map)->rehash(n)) 82 83 #ifndef HAVE_TR1_HASH_OFF_T 84 // The library does not support hashes of off_t values. Add support 85 // here. This is likely to be specific to libstdc++. This issue 86 // arises with GCC 4.1.x when compiling in 32-bit mode with a 64-bit 87 // off_t type. 88 namespace std { namespace tr1 { 89 template<> 90 struct hash<off_t> : public std::unary_function<off_t, std::size_t> 91 { 92 std::size_t 93 operator()(off_t val) const 94 { return static_cast<std::size_t>(val); } 95 }; 96 } } // Close namespaces. 97 #endif // !defined(HAVE_TR1_HASH_OFF_T) 98 99 #elif defined(HAVE_EXT_HASH_MAP) && defined(HAVE_EXT_HASH_SET) 100 101 #include <ext/hash_map> 102 #include <ext/hash_set> 103 #include <string> 104 105 #define Unordered_set __gnu_cxx::hash_set 106 #define Unordered_map __gnu_cxx::hash_map 107 #define Unordered_multimap __gnu_cxx::hash_multimap 108 109 namespace __gnu_cxx 110 { 111 112 template<> 113 struct hash<std::string> 114 { 115 size_t 116 operator()(std::string s) const 117 { return __stl_hash_string(s.c_str()); } 118 }; 119 120 template<typename T> 121 struct hash<T*> 122 { 123 size_t 124 operator()(T* p) const 125 { return reinterpret_cast<size_t>(p); } 126 }; 127 128 } 129 130 #define reserve_unordered_map(map, n) ((map)->resize(n)) 131 132 #else 133 134 // The fallback is to just use set and map. 135 136 #include <set> 137 #include <map> 138 139 #define Unordered_set std::set 140 #define Unordered_map std::map 141 #define Unordered_multimap std::multimap 142 143 #define reserve_unordered_map(map, n) 144 145 #endif 146 147 #ifndef HAVE_PREAD 148 extern "C" ssize_t pread(int, void*, size_t, off_t); 149 #endif 150 151 #ifndef HAVE_FTRUNCATE 152 extern "C" int ftruncate(int, off_t); 153 #endif 154 155 #ifndef HAVE_FFSLL 156 extern "C" int ffsll(long long); 157 #endif 158 159 #if !HAVE_DECL_MEMMEM 160 extern "C" void *memmem(const void *, size_t, const void *, size_t); 161 #endif 162 163 #if !HAVE_DECL_STRNDUP 164 extern "C" char *strndup(const char *, size_t); 165 #endif 166 167 namespace gold 168 { 169 170 // General declarations. 171 172 class General_options; 173 class Command_line; 174 class Dirsearch; 175 class Input_objects; 176 class Mapfile; 177 class Symbol; 178 class Symbol_table; 179 class Layout; 180 class Task; 181 class Workqueue; 182 class Output_file; 183 template<int size, bool big_endian> 184 struct Relocate_info; 185 186 // Exit status codes. 187 188 enum Exit_status 189 { 190 GOLD_OK = EXIT_SUCCESS, 191 GOLD_ERR = EXIT_FAILURE, 192 GOLD_FALLBACK = EXIT_FAILURE + 1 193 }; 194 195 // Some basic types. For these we use lower case initial letters. 196 197 // For an offset in an input or output file, use off_t. Note that 198 // this will often be a 64-bit type even for a 32-bit build. 199 200 // The size of a section if we are going to look at the contents. 201 typedef size_t section_size_type; 202 203 // An offset within a section when we are looking at the contents. 204 typedef ptrdiff_t section_offset_type; 205 206 // The name of the program as used in error messages. 207 extern const char* program_name; 208 209 // This function is called to exit the program. Status is true to 210 // exit success (0) and false to exit failure (1). 211 extern void 212 gold_exit(Exit_status status) ATTRIBUTE_NORETURN; 213 214 // This function is called to emit an error message and then 215 // immediately exit with failure. 216 extern void 217 gold_fatal(const char* format, ...) ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF_1; 218 219 // This function is called to issue an error. This will cause gold to 220 // eventually exit with failure. 221 extern void 222 gold_error(const char* msg, ...) ATTRIBUTE_PRINTF_1; 223 224 // This function is called to issue a warning. 225 extern void 226 gold_warning(const char* msg, ...) ATTRIBUTE_PRINTF_1; 227 228 // This function is called to print an informational message. 229 extern void 230 gold_info(const char* msg, ...) ATTRIBUTE_PRINTF_1; 231 232 // This function is called to emit an error message and then 233 // immediately exit with fallback status (e.g., when 234 // --incremental-update fails and the link needs to be restarted 235 // with --incremental-full). 236 extern void 237 gold_fallback(const char* format, ...) ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF_1; 238 239 // Work around a bug in gcc 4.3.0. http://gcc.gnu.org/PR35546 . This 240 // can probably be removed after the bug has been fixed for a while. 241 #ifdef HAVE_TEMPLATE_ATTRIBUTES 242 #define TEMPLATE_ATTRIBUTE_PRINTF_4 ATTRIBUTE_PRINTF_4 243 #else 244 #define TEMPLATE_ATTRIBUTE_PRINTF_4 245 #endif 246 247 // This function is called to issue an error at the location of a 248 // reloc. 249 template<int size, bool big_endian> 250 extern void 251 gold_error_at_location(const Relocate_info<size, big_endian>*, 252 size_t, off_t, const char* format, ...) 253 TEMPLATE_ATTRIBUTE_PRINTF_4; 254 255 // This function is called to issue a warning at the location of a 256 // reloc. 257 template<int size, bool big_endian> 258 extern void 259 gold_warning_at_location(const Relocate_info<size, big_endian>*, 260 size_t, off_t, const char* format, ...) 261 TEMPLATE_ATTRIBUTE_PRINTF_4; 262 263 // This function is called to report an undefined symbol without 264 // a relocation (e.g., referenced by a dynamic object). SYM is 265 // the undefined symbol. The file name associated with the SYM 266 // is used to print a location for the undefined symbol. 267 extern void 268 gold_undefined_symbol(const Symbol*); 269 270 // This function is called to report an undefined symbol resulting 271 // from a relocation. SYM is the undefined symbol. RELINFO is the 272 // general relocation info. RELNUM is the number of the reloc, 273 // and RELOFFSET is the reloc's offset. 274 template<int size, bool big_endian> 275 extern void 276 gold_undefined_symbol_at_location(const Symbol*, 277 const Relocate_info<size, big_endian>*, 278 size_t, off_t); 279 280 // This is function is called in some cases if we run out of memory. 281 extern void 282 gold_nomem() ATTRIBUTE_NORETURN; 283 284 // In versions of gcc before 4.3, using __FUNCTION__ in a template 285 // function can cause gcc to get confused about whether or not the 286 // function can return. See http://gcc.gnu.org/PR30988. Use a macro 287 // to avoid the problem. This can be removed when we no longer need 288 // to care about gcc versions before 4.3. 289 #if defined(__GNUC__) && GCC_VERSION < 4003 290 #define FUNCTION_NAME static_cast<const char*>(__FUNCTION__) 291 #else 292 #define FUNCTION_NAME __FUNCTION__ 293 #endif 294 295 // This macro and function are used in cases which can not arise if 296 // the code is written correctly. 297 298 #define gold_unreachable() \ 299 (gold::do_gold_unreachable(__FILE__, __LINE__, FUNCTION_NAME)) 300 301 extern void do_gold_unreachable(const char*, int, const char*) 302 ATTRIBUTE_NORETURN; 303 304 // Assertion check. 305 306 #define gold_assert(expr) ((void)(!(expr) ? gold_unreachable(), 0 : 0)) 307 308 // Print version information. 309 extern void 310 print_version(bool print_short); 311 312 // Get the version string. 313 extern const char* 314 get_version_string(); 315 316 // Convert numeric types without unnoticed loss of precision. 317 template<typename To, typename From> 318 inline To 319 convert_types(const From from) 320 { 321 To to = from; 322 gold_assert(static_cast<From>(to) == from); 323 return to; 324 } 325 326 // A common case of convert_types<>: convert to section_size_type. 327 template<typename From> 328 inline section_size_type 329 convert_to_section_size_type(const From from) 330 { return convert_types<section_size_type, From>(from); } 331 332 // Queue up the first set of tasks. 333 extern void 334 queue_initial_tasks(const General_options&, 335 Dirsearch&, 336 const Command_line&, 337 Workqueue*, 338 Input_objects*, 339 Symbol_table*, 340 Layout*, 341 Mapfile*); 342 343 // Queue up the set of tasks to be done before 344 // the middle set of tasks. Only used when garbage 345 // collection is to be done. 346 extern void 347 queue_middle_gc_tasks(const General_options&, 348 const Task*, 349 const Input_objects*, 350 Symbol_table*, 351 Layout*, 352 Workqueue*, 353 Mapfile*); 354 355 // Queue up the middle set of tasks. 356 extern void 357 queue_middle_tasks(const General_options&, 358 const Task*, 359 const Input_objects*, 360 Symbol_table*, 361 Layout*, 362 Workqueue*, 363 Mapfile*); 364 365 // Queue up the final set of tasks. 366 extern void 367 queue_final_tasks(const General_options&, 368 const Input_objects*, 369 const Symbol_table*, 370 Layout*, 371 Workqueue*, 372 Output_file* of); 373 374 inline bool 375 is_prefix_of(const char* prefix, const char* str) 376 { 377 return strncmp(prefix, str, strlen(prefix)) == 0; 378 } 379 380 const char* const cident_section_start_prefix = "__start_"; 381 const char* const cident_section_stop_prefix = "__stop_"; 382 383 // Returns true if the name is a valid C identifier 384 inline bool 385 is_cident(const char* name) 386 { 387 return (name[strspn(name, 388 ("0123456789" 389 "ABCDEFGHIJKLMNOPWRSTUVWXYZ" 390 "abcdefghijklmnopqrstuvwxyz" 391 "_"))] 392 == '\0'); 393 } 394 395 // We sometimes need to hash strings. Ideally we should use std::tr1::hash or 396 // __gnu_cxx::hash on some systems but there is no guarantee that either 397 // one is available. For portability, we define simple string hash functions. 398 399 template<typename Char_type> 400 inline size_t 401 string_hash(const Char_type* s, size_t length) 402 { 403 // This is the hash function used by the dynamic linker for 404 // DT_GNU_HASH entries. I compared this to a Fowler/Noll/Vo hash 405 // for a C++ program with 385,775 global symbols. This hash 406 // function was very slightly worse. However, it is much faster to 407 // compute. Overall wall clock time was a win. 408 const unsigned char* p = reinterpret_cast<const unsigned char*>(s); 409 size_t h = 5381; 410 for (size_t i = 0; i < length * sizeof(Char_type); ++i) 411 h = h * 33 + *p++; 412 return h; 413 } 414 415 // Same as above except we expect the string to be zero terminated. 416 417 template<typename Char_type> 418 inline size_t 419 string_hash(const Char_type* s) 420 { 421 const unsigned char* p = reinterpret_cast<const unsigned char*>(s); 422 size_t h = 5381; 423 for (size_t i = 0; s[i] != 0; ++i) 424 { 425 for (size_t j = 0; j < sizeof(Char_type); j++) 426 h = h * 33 + *p++; 427 } 428 429 return h; 430 } 431 432 // Return whether STRING contains a wildcard character. This is used 433 // to speed up matching. 434 435 inline bool 436 is_wildcard_string(const char* s) 437 { 438 return strpbrk(s, "?*[") != NULL; 439 } 440 441 } // End namespace gold. 442 443 #endif // !defined(GOLD_GOLD_H) 444