| 1 | // gdb-index.cc -- generate .gdb_index section for fast debug lookup |
| 2 | |
| 3 | // Copyright (C) 2012-2019 Free Software Foundation, Inc. |
| 4 | // Written by Cary Coutant <ccoutant@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 | #include "gold.h" |
| 24 | |
| 25 | #include "gdb-index.h" |
| 26 | #include "dwarf_reader.h" |
| 27 | #include "dwarf.h" |
| 28 | #include "object.h" |
| 29 | #include "output.h" |
| 30 | #include "demangle.h" |
| 31 | |
| 32 | namespace gold |
| 33 | { |
| 34 | |
| 35 | const int gdb_index_version = 7; |
| 36 | |
| 37 | // Sizes of various records in the .gdb_index section. |
| 38 | const int gdb_index_offset_size = 4; |
| 39 | const int gdb_index_hdr_size = 6 * gdb_index_offset_size; |
| 40 | const int gdb_index_cu_size = 16; |
| 41 | const int gdb_index_tu_size = 24; |
| 42 | const int gdb_index_addr_size = 16 + gdb_index_offset_size; |
| 43 | const int gdb_index_sym_size = 2 * gdb_index_offset_size; |
| 44 | |
| 45 | // This class manages the hashed symbol table for the .gdb_index section. |
| 46 | // It is essentially equivalent to the hashtab implementation in libiberty, |
| 47 | // but is copied into gdb sources and here for compatibility because its |
| 48 | // data structure is exposed on disk. |
| 49 | |
| 50 | template <typename T> |
| 51 | class Gdb_hashtab |
| 52 | { |
| 53 | public: |
| 54 | Gdb_hashtab() |
| 55 | : size_(0), capacity_(0), hashtab_(NULL) |
| 56 | { } |
| 57 | |
| 58 | ~Gdb_hashtab() |
| 59 | { |
| 60 | for (size_t i = 0; i < this->capacity_; ++i) |
| 61 | if (this->hashtab_[i] != NULL) |
| 62 | delete this->hashtab_[i]; |
| 63 | delete[] this->hashtab_; |
| 64 | } |
| 65 | |
| 66 | // Add a symbol. |
| 67 | T* |
| 68 | add(T* symbol) |
| 69 | { |
| 70 | // Resize the hash table if necessary. |
| 71 | if (4 * this->size_ / 3 >= this->capacity_) |
| 72 | this->expand(); |
| 73 | |
| 74 | T** slot = this->find_slot(symbol); |
| 75 | if (*slot == NULL) |
| 76 | { |
| 77 | ++this->size_; |
| 78 | *slot = symbol; |
| 79 | } |
| 80 | |
| 81 | return *slot; |
| 82 | } |
| 83 | |
| 84 | // Return the current size. |
| 85 | size_t |
| 86 | size() const |
| 87 | { return this->size_; } |
| 88 | |
| 89 | // Return the current capacity. |
| 90 | size_t |
| 91 | capacity() const |
| 92 | { return this->capacity_; } |
| 93 | |
| 94 | // Return the contents of slot N. |
| 95 | T* |
| 96 | operator[](size_t n) |
| 97 | { return this->hashtab_[n]; } |
| 98 | |
| 99 | private: |
| 100 | // Find a symbol in the hash table, or return an empty slot if |
| 101 | // the symbol is not in the table. |
| 102 | T** |
| 103 | find_slot(T* symbol) |
| 104 | { |
| 105 | unsigned int index = symbol->hash() & (this->capacity_ - 1); |
| 106 | unsigned int step = ((symbol->hash() * 17) & (this->capacity_ - 1)) | 1; |
| 107 | |
| 108 | for (;;) |
| 109 | { |
| 110 | if (this->hashtab_[index] == NULL |
| 111 | || this->hashtab_[index]->equal(symbol)) |
| 112 | return &this->hashtab_[index]; |
| 113 | index = (index + step) & (this->capacity_ - 1); |
| 114 | } |
| 115 | } |
| 116 | |
| 117 | // Expand the hash table. |
| 118 | void |
| 119 | expand() |
| 120 | { |
| 121 | if (this->capacity_ == 0) |
| 122 | { |
| 123 | // Allocate the hash table for the first time. |
| 124 | this->capacity_ = Gdb_hashtab::initial_size; |
| 125 | this->hashtab_ = new T*[this->capacity_]; |
| 126 | memset(this->hashtab_, 0, this->capacity_ * sizeof(T*)); |
| 127 | } |
| 128 | else |
| 129 | { |
| 130 | // Expand and rehash. |
| 131 | unsigned int old_cap = this->capacity_; |
| 132 | T** old_hashtab = this->hashtab_; |
| 133 | this->capacity_ *= 2; |
| 134 | this->hashtab_ = new T*[this->capacity_]; |
| 135 | memset(this->hashtab_, 0, this->capacity_ * sizeof(T*)); |
| 136 | for (size_t i = 0; i < old_cap; ++i) |
| 137 | { |
| 138 | if (old_hashtab[i] != NULL) |
| 139 | { |
| 140 | T** slot = this->find_slot(old_hashtab[i]); |
| 141 | *slot = old_hashtab[i]; |
| 142 | } |
| 143 | } |
| 144 | delete[] old_hashtab; |
| 145 | } |
| 146 | } |
| 147 | |
| 148 | // Initial size of the hash table; must be a power of 2. |
| 149 | static const int initial_size = 1024; |
| 150 | size_t size_; |
| 151 | size_t capacity_; |
| 152 | T** hashtab_; |
| 153 | }; |
| 154 | |
| 155 | // The hash function for strings in the mapped index. This is copied |
| 156 | // directly from gdb/dwarf2read.c. |
| 157 | |
| 158 | static unsigned int |
| 159 | mapped_index_string_hash(const unsigned char* str) |
| 160 | { |
| 161 | unsigned int r = 0; |
| 162 | unsigned char c; |
| 163 | |
| 164 | while ((c = *str++) != 0) |
| 165 | { |
| 166 | if (gdb_index_version >= 5) |
| 167 | c = tolower (c); |
| 168 | r = r * 67 + c - 113; |
| 169 | } |
| 170 | |
| 171 | return r; |
| 172 | } |
| 173 | |
| 174 | // A specialization of Dwarf_info_reader, for building the .gdb_index. |
| 175 | |
| 176 | class Gdb_index_info_reader : public Dwarf_info_reader |
| 177 | { |
| 178 | public: |
| 179 | Gdb_index_info_reader(bool is_type_unit, |
| 180 | Relobj* object, |
| 181 | const unsigned char* symbols, |
| 182 | off_t symbols_size, |
| 183 | unsigned int shndx, |
| 184 | unsigned int reloc_shndx, |
| 185 | unsigned int reloc_type, |
| 186 | Gdb_index* gdb_index) |
| 187 | : Dwarf_info_reader(is_type_unit, object, symbols, symbols_size, shndx, |
| 188 | reloc_shndx, reloc_type), |
| 189 | gdb_index_(gdb_index), cu_index_(0), cu_language_(0) |
| 190 | { } |
| 191 | |
| 192 | ~Gdb_index_info_reader() |
| 193 | { this->clear_declarations(); } |
| 194 | |
| 195 | // Print usage statistics. |
| 196 | static void |
| 197 | print_stats(); |
| 198 | |
| 199 | protected: |
| 200 | // Visit a compilation unit. |
| 201 | virtual void |
| 202 | visit_compilation_unit(off_t cu_offset, off_t cu_length, Dwarf_die*); |
| 203 | |
| 204 | // Visit a type unit. |
| 205 | virtual void |
| 206 | visit_type_unit(off_t tu_offset, off_t tu_length, off_t type_offset, |
| 207 | uint64_t signature, Dwarf_die*); |
| 208 | |
| 209 | private: |
| 210 | // A map for recording DIEs we've seen that may be referred to be |
| 211 | // later DIEs (via DW_AT_specification or DW_AT_abstract_origin). |
| 212 | // The map is indexed by a DIE offset within the compile unit. |
| 213 | // PARENT_OFFSET_ is the offset of the DIE that represents the |
| 214 | // outer context, and NAME_ is a pointer to a component of the |
| 215 | // fully-qualified name. |
| 216 | // Normally, the names we point to are in a string table, so we don't |
| 217 | // have to manage them, but when we have a fully-qualified name |
| 218 | // computed, we put it in the table, and set PARENT_OFFSET_ to -1 |
| 219 | // indicate a string that we are managing. |
| 220 | struct Declaration_pair |
| 221 | { |
| 222 | Declaration_pair(off_t parent_offset, const char* name) |
| 223 | : parent_offset_(parent_offset), name_(name) |
| 224 | { } |
| 225 | |
| 226 | off_t parent_offset_; |
| 227 | const char* name_; |
| 228 | }; |
| 229 | typedef Unordered_map<off_t, Declaration_pair> Declaration_map; |
| 230 | |
| 231 | // Visit a top-level DIE. |
| 232 | void |
| 233 | visit_top_die(Dwarf_die* die); |
| 234 | |
| 235 | // Visit the children of a DIE. |
| 236 | void |
| 237 | visit_children(Dwarf_die* die, Dwarf_die* context); |
| 238 | |
| 239 | // Visit a DIE. |
| 240 | void |
| 241 | visit_die(Dwarf_die* die, Dwarf_die* context); |
| 242 | |
| 243 | // Visit the children of a DIE. |
| 244 | void |
| 245 | visit_children_for_decls(Dwarf_die* die); |
| 246 | |
| 247 | // Visit a DIE. |
| 248 | void |
| 249 | visit_die_for_decls(Dwarf_die* die, Dwarf_die* context); |
| 250 | |
| 251 | // Guess a fully-qualified name for a class type, based on member function |
| 252 | // linkage names. |
| 253 | std::string |
| 254 | guess_full_class_name(Dwarf_die* die); |
| 255 | |
| 256 | // Add a declaration DIE to the table of declarations. |
| 257 | void |
| 258 | add_declaration(Dwarf_die* die, Dwarf_die* context); |
| 259 | |
| 260 | // Add a declaration whose fully-qualified name is already known. |
| 261 | void |
| 262 | add_declaration_with_full_name(Dwarf_die* die, const char* full_name); |
| 263 | |
| 264 | // Return the context for a DIE whose parent is at DIE_OFFSET. |
| 265 | std::string |
| 266 | get_context(off_t die_offset); |
| 267 | |
| 268 | // Construct a fully-qualified name for DIE. |
| 269 | std::string |
| 270 | get_qualified_name(Dwarf_die* die, Dwarf_die* context); |
| 271 | |
| 272 | // Record the address ranges for a compilation unit. |
| 273 | void |
| 274 | record_cu_ranges(Dwarf_die* die); |
| 275 | |
| 276 | // Wrapper for read_pubtable. |
| 277 | bool |
| 278 | read_pubnames_and_pubtypes(Dwarf_die* die); |
| 279 | |
| 280 | // Read the .debug_pubnames and .debug_pubtypes tables. |
| 281 | bool |
| 282 | read_pubtable(Dwarf_pubnames_table* table, off_t offset); |
| 283 | |
| 284 | // Clear the declarations map. |
| 285 | void |
| 286 | clear_declarations(); |
| 287 | |
| 288 | // The Gdb_index section. |
| 289 | Gdb_index* gdb_index_; |
| 290 | // The current CU index (negative for a TU). |
| 291 | int cu_index_; |
| 292 | // The language of the current CU or TU. |
| 293 | unsigned int cu_language_; |
| 294 | // Map from DIE offset to (parent offset, name) pair, |
| 295 | // for DW_AT_specification. |
| 296 | Declaration_map declarations_; |
| 297 | |
| 298 | // Statistics. |
| 299 | // Total number of DWARF compilation units processed. |
| 300 | static unsigned int dwarf_cu_count; |
| 301 | // Number of DWARF compilation units with pubnames/pubtypes. |
| 302 | static unsigned int dwarf_cu_nopubnames_count; |
| 303 | // Total number of DWARF type units processed. |
| 304 | static unsigned int dwarf_tu_count; |
| 305 | // Number of DWARF type units with pubnames/pubtypes. |
| 306 | static unsigned int dwarf_tu_nopubnames_count; |
| 307 | }; |
| 308 | |
| 309 | // Total number of DWARF compilation units processed. |
| 310 | unsigned int Gdb_index_info_reader::dwarf_cu_count = 0; |
| 311 | // Number of DWARF compilation units without pubnames/pubtypes. |
| 312 | unsigned int Gdb_index_info_reader::dwarf_cu_nopubnames_count = 0; |
| 313 | // Total number of DWARF type units processed. |
| 314 | unsigned int Gdb_index_info_reader::dwarf_tu_count = 0; |
| 315 | // Number of DWARF type units without pubnames/pubtypes. |
| 316 | unsigned int Gdb_index_info_reader::dwarf_tu_nopubnames_count = 0; |
| 317 | |
| 318 | // Process a compilation unit and parse its child DIE. |
| 319 | |
| 320 | void |
| 321 | Gdb_index_info_reader::visit_compilation_unit(off_t cu_offset, off_t cu_length, |
| 322 | Dwarf_die* root_die) |
| 323 | { |
| 324 | ++Gdb_index_info_reader::dwarf_cu_count; |
| 325 | this->cu_index_ = this->gdb_index_->add_comp_unit(cu_offset, cu_length); |
| 326 | this->visit_top_die(root_die); |
| 327 | } |
| 328 | |
| 329 | // Process a type unit and parse its child DIE. |
| 330 | |
| 331 | void |
| 332 | Gdb_index_info_reader::visit_type_unit(off_t tu_offset, off_t, |
| 333 | off_t type_offset, uint64_t signature, |
| 334 | Dwarf_die* root_die) |
| 335 | { |
| 336 | ++Gdb_index_info_reader::dwarf_tu_count; |
| 337 | // Use a negative index to flag this as a TU instead of a CU. |
| 338 | this->cu_index_ = -1 - this->gdb_index_->add_type_unit(tu_offset, type_offset, |
| 339 | signature); |
| 340 | this->visit_top_die(root_die); |
| 341 | } |
| 342 | |
| 343 | // Process a top-level DIE. |
| 344 | // For compile_unit DIEs, record the address ranges. For all |
| 345 | // interesting tags, add qualified names to the symbol table |
| 346 | // and process interesting children. We may need to process |
| 347 | // certain children just for saving declarations that might be |
| 348 | // referenced by later DIEs with a DW_AT_specification attribute. |
| 349 | |
| 350 | void |
| 351 | Gdb_index_info_reader::visit_top_die(Dwarf_die* die) |
| 352 | { |
| 353 | this->clear_declarations(); |
| 354 | |
| 355 | switch (die->tag()) |
| 356 | { |
| 357 | case elfcpp::DW_TAG_compile_unit: |
| 358 | case elfcpp::DW_TAG_type_unit: |
| 359 | this->cu_language_ = die->int_attribute(elfcpp::DW_AT_language); |
| 360 | if (die->tag() == elfcpp::DW_TAG_compile_unit) |
| 361 | this->record_cu_ranges(die); |
| 362 | // If there is a pubnames and/or pubtypes section for this |
| 363 | // compilation unit, use those; otherwise, parse the DWARF |
| 364 | // info to extract the names. |
| 365 | if (!this->read_pubnames_and_pubtypes(die)) |
| 366 | { |
| 367 | // Check for languages that require specialized knowledge to |
| 368 | // construct fully-qualified names, that we don't yet support. |
| 369 | if (this->cu_language_ == elfcpp::DW_LANG_Ada83 |
| 370 | || this->cu_language_ == elfcpp::DW_LANG_Fortran77 |
| 371 | || this->cu_language_ == elfcpp::DW_LANG_Fortran90 |
| 372 | || this->cu_language_ == elfcpp::DW_LANG_Java |
| 373 | || this->cu_language_ == elfcpp::DW_LANG_Ada95 |
| 374 | || this->cu_language_ == elfcpp::DW_LANG_Fortran95 |
| 375 | || this->cu_language_ == elfcpp::DW_LANG_Fortran03 |
| 376 | || this->cu_language_ == elfcpp::DW_LANG_Fortran08) |
| 377 | { |
| 378 | gold_warning(_("%s: --gdb-index currently supports " |
| 379 | "only C and C++ languages"), |
| 380 | this->object()->name().c_str()); |
| 381 | return; |
| 382 | } |
| 383 | if (die->tag() == elfcpp::DW_TAG_compile_unit) |
| 384 | ++Gdb_index_info_reader::dwarf_cu_nopubnames_count; |
| 385 | else |
| 386 | ++Gdb_index_info_reader::dwarf_tu_nopubnames_count; |
| 387 | this->visit_children(die, NULL); |
| 388 | } |
| 389 | break; |
| 390 | default: |
| 391 | // The top level DIE should be one of the above. |
| 392 | gold_warning(_("%s: top level DIE is not DW_TAG_compile_unit " |
| 393 | "or DW_TAG_type_unit"), |
| 394 | this->object()->name().c_str()); |
| 395 | return; |
| 396 | } |
| 397 | } |
| 398 | |
| 399 | // Visit the children of PARENT, looking for symbols to add to the index. |
| 400 | // CONTEXT points to the DIE to use for constructing the qualified name -- |
| 401 | // NULL if PARENT is the top-level DIE; otherwise it is the same as PARENT. |
| 402 | |
| 403 | void |
| 404 | Gdb_index_info_reader::visit_children(Dwarf_die* parent, Dwarf_die* context) |
| 405 | { |
| 406 | off_t next_offset = 0; |
| 407 | for (off_t die_offset = parent->child_offset(); |
| 408 | die_offset != 0; |
| 409 | die_offset = next_offset) |
| 410 | { |
| 411 | Dwarf_die die(this, die_offset, parent); |
| 412 | if (die.tag() == 0) |
| 413 | break; |
| 414 | this->visit_die(&die, context); |
| 415 | next_offset = die.sibling_offset(); |
| 416 | } |
| 417 | } |
| 418 | |
| 419 | // Visit a child DIE, looking for symbols to add to the index. |
| 420 | // CONTEXT is the parent DIE, used for constructing the qualified name; |
| 421 | // it is NULL if the parent DIE is the top-level DIE. |
| 422 | |
| 423 | void |
| 424 | Gdb_index_info_reader::visit_die(Dwarf_die* die, Dwarf_die* context) |
| 425 | { |
| 426 | switch (die->tag()) |
| 427 | { |
| 428 | case elfcpp::DW_TAG_subprogram: |
| 429 | case elfcpp::DW_TAG_constant: |
| 430 | case elfcpp::DW_TAG_variable: |
| 431 | case elfcpp::DW_TAG_enumerator: |
| 432 | case elfcpp::DW_TAG_base_type: |
| 433 | if (die->is_declaration()) |
| 434 | this->add_declaration(die, context); |
| 435 | else |
| 436 | { |
| 437 | // If the DIE is not a declaration, add it to the index. |
| 438 | std::string full_name = this->get_qualified_name(die, context); |
| 439 | if (!full_name.empty()) |
| 440 | this->gdb_index_->add_symbol(this->cu_index_, |
| 441 | full_name.c_str(), 0); |
| 442 | } |
| 443 | break; |
| 444 | case elfcpp::DW_TAG_typedef: |
| 445 | case elfcpp::DW_TAG_union_type: |
| 446 | case elfcpp::DW_TAG_class_type: |
| 447 | case elfcpp::DW_TAG_interface_type: |
| 448 | case elfcpp::DW_TAG_structure_type: |
| 449 | case elfcpp::DW_TAG_enumeration_type: |
| 450 | case elfcpp::DW_TAG_subrange_type: |
| 451 | case elfcpp::DW_TAG_namespace: |
| 452 | { |
| 453 | std::string full_name; |
| 454 | |
| 455 | // For classes at the top level, we need to look for a |
| 456 | // member function with a linkage name in order to get |
| 457 | // the properly-canonicalized name. |
| 458 | if (context == NULL |
| 459 | && (die->tag() == elfcpp::DW_TAG_class_type |
| 460 | || die->tag() == elfcpp::DW_TAG_structure_type |
| 461 | || die->tag() == elfcpp::DW_TAG_union_type)) |
| 462 | full_name.assign(this->guess_full_class_name(die)); |
| 463 | |
| 464 | // Because we will visit the children, we need to add this DIE |
| 465 | // to the declarations table. |
| 466 | if (full_name.empty()) |
| 467 | this->add_declaration(die, context); |
| 468 | else |
| 469 | this->add_declaration_with_full_name(die, full_name.c_str()); |
| 470 | |
| 471 | // If the DIE is not a declaration, add it to the index. |
| 472 | // Gdb stores a namespace in the index even when it is |
| 473 | // a declaration. |
| 474 | if (die->tag() == elfcpp::DW_TAG_namespace |
| 475 | || !die->is_declaration()) |
| 476 | { |
| 477 | if (full_name.empty()) |
| 478 | full_name = this->get_qualified_name(die, context); |
| 479 | if (!full_name.empty()) |
| 480 | this->gdb_index_->add_symbol(this->cu_index_, |
| 481 | full_name.c_str(), 0); |
| 482 | } |
| 483 | |
| 484 | // We're interested in the children only for namespaces and |
| 485 | // enumeration types. For enumeration types, we do not include |
| 486 | // the enumeration tag as part of the full name. For other tags, |
| 487 | // visit the children only to collect declarations. |
| 488 | if (die->tag() == elfcpp::DW_TAG_namespace |
| 489 | || die->tag() == elfcpp::DW_TAG_enumeration_type) |
| 490 | this->visit_children(die, die); |
| 491 | else |
| 492 | this->visit_children_for_decls(die); |
| 493 | } |
| 494 | break; |
| 495 | default: |
| 496 | break; |
| 497 | } |
| 498 | } |
| 499 | |
| 500 | // Visit the children of PARENT, looking only for declarations that |
| 501 | // may be referenced by later specification DIEs. |
| 502 | |
| 503 | void |
| 504 | Gdb_index_info_reader::visit_children_for_decls(Dwarf_die* parent) |
| 505 | { |
| 506 | off_t next_offset = 0; |
| 507 | for (off_t die_offset = parent->child_offset(); |
| 508 | die_offset != 0; |
| 509 | die_offset = next_offset) |
| 510 | { |
| 511 | Dwarf_die die(this, die_offset, parent); |
| 512 | if (die.tag() == 0) |
| 513 | break; |
| 514 | this->visit_die_for_decls(&die, parent); |
| 515 | next_offset = die.sibling_offset(); |
| 516 | } |
| 517 | } |
| 518 | |
| 519 | // Visit a child DIE, looking only for declarations that |
| 520 | // may be referenced by later specification DIEs. |
| 521 | |
| 522 | void |
| 523 | Gdb_index_info_reader::visit_die_for_decls(Dwarf_die* die, Dwarf_die* context) |
| 524 | { |
| 525 | switch (die->tag()) |
| 526 | { |
| 527 | case elfcpp::DW_TAG_subprogram: |
| 528 | case elfcpp::DW_TAG_constant: |
| 529 | case elfcpp::DW_TAG_variable: |
| 530 | case elfcpp::DW_TAG_enumerator: |
| 531 | case elfcpp::DW_TAG_base_type: |
| 532 | { |
| 533 | if (die->is_declaration()) |
| 534 | this->add_declaration(die, context); |
| 535 | } |
| 536 | break; |
| 537 | case elfcpp::DW_TAG_typedef: |
| 538 | case elfcpp::DW_TAG_union_type: |
| 539 | case elfcpp::DW_TAG_class_type: |
| 540 | case elfcpp::DW_TAG_interface_type: |
| 541 | case elfcpp::DW_TAG_structure_type: |
| 542 | case elfcpp::DW_TAG_enumeration_type: |
| 543 | case elfcpp::DW_TAG_subrange_type: |
| 544 | case elfcpp::DW_TAG_namespace: |
| 545 | { |
| 546 | if (die->is_declaration()) |
| 547 | this->add_declaration(die, context); |
| 548 | this->visit_children_for_decls(die); |
| 549 | } |
| 550 | break; |
| 551 | default: |
| 552 | break; |
| 553 | } |
| 554 | } |
| 555 | |
| 556 | // Extract the class name from the linkage name of a member function. |
| 557 | // This code is adapted from ../gdb/cp-support.c. |
| 558 | |
| 559 | #define d_left(dc) (dc)->u.s_binary.left |
| 560 | #define d_right(dc) (dc)->u.s_binary.right |
| 561 | |
| 562 | static char* |
| 563 | class_name_from_linkage_name(const char* linkage_name) |
| 564 | { |
| 565 | void* storage; |
| 566 | struct demangle_component* tree = |
| 567 | cplus_demangle_v3_components(linkage_name, DMGL_NO_OPTS, &storage); |
| 568 | if (tree == NULL) |
| 569 | return NULL; |
| 570 | |
| 571 | int done = 0; |
| 572 | |
| 573 | // First strip off any qualifiers, if we have a function or |
| 574 | // method. |
| 575 | while (!done) |
| 576 | switch (tree->type) |
| 577 | { |
| 578 | case DEMANGLE_COMPONENT_CONST: |
| 579 | case DEMANGLE_COMPONENT_RESTRICT: |
| 580 | case DEMANGLE_COMPONENT_VOLATILE: |
| 581 | case DEMANGLE_COMPONENT_CONST_THIS: |
| 582 | case DEMANGLE_COMPONENT_RESTRICT_THIS: |
| 583 | case DEMANGLE_COMPONENT_VOLATILE_THIS: |
| 584 | case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: |
| 585 | tree = d_left(tree); |
| 586 | break; |
| 587 | default: |
| 588 | done = 1; |
| 589 | break; |
| 590 | } |
| 591 | |
| 592 | // If what we have now is a function, discard the argument list. |
| 593 | if (tree->type == DEMANGLE_COMPONENT_TYPED_NAME) |
| 594 | tree = d_left(tree); |
| 595 | |
| 596 | // If what we have now is a template, strip off the template |
| 597 | // arguments. The left subtree may be a qualified name. |
| 598 | if (tree->type == DEMANGLE_COMPONENT_TEMPLATE) |
| 599 | tree = d_left(tree); |
| 600 | |
| 601 | // What we have now should be a name, possibly qualified. |
| 602 | // Additional qualifiers could live in the left subtree or the right |
| 603 | // subtree. Find the last piece. |
| 604 | done = 0; |
| 605 | struct demangle_component* prev_comp = NULL; |
| 606 | struct demangle_component* cur_comp = tree; |
| 607 | while (!done) |
| 608 | switch (cur_comp->type) |
| 609 | { |
| 610 | case DEMANGLE_COMPONENT_QUAL_NAME: |
| 611 | case DEMANGLE_COMPONENT_LOCAL_NAME: |
| 612 | prev_comp = cur_comp; |
| 613 | cur_comp = d_right(cur_comp); |
| 614 | break; |
| 615 | case DEMANGLE_COMPONENT_TEMPLATE: |
| 616 | case DEMANGLE_COMPONENT_NAME: |
| 617 | case DEMANGLE_COMPONENT_CTOR: |
| 618 | case DEMANGLE_COMPONENT_DTOR: |
| 619 | case DEMANGLE_COMPONENT_OPERATOR: |
| 620 | case DEMANGLE_COMPONENT_EXTENDED_OPERATOR: |
| 621 | done = 1; |
| 622 | break; |
| 623 | default: |
| 624 | done = 1; |
| 625 | cur_comp = NULL; |
| 626 | break; |
| 627 | } |
| 628 | |
| 629 | char* ret = NULL; |
| 630 | if (cur_comp != NULL && prev_comp != NULL) |
| 631 | { |
| 632 | // We want to discard the rightmost child of PREV_COMP. |
| 633 | *prev_comp = *d_left(prev_comp); |
| 634 | size_t allocated_size; |
| 635 | ret = cplus_demangle_print(DMGL_NO_OPTS, tree, 30, &allocated_size); |
| 636 | } |
| 637 | |
| 638 | free(storage); |
| 639 | return ret; |
| 640 | } |
| 641 | |
| 642 | // Guess a fully-qualified name for a class type, based on member function |
| 643 | // linkage names. This is needed for class/struct/union types at the |
| 644 | // top level, because GCC does not always properly embed them within |
| 645 | // the namespace. As in gdb, we look for a member function with a linkage |
| 646 | // name and extract the qualified name from the demangled name. |
| 647 | |
| 648 | std::string |
| 649 | Gdb_index_info_reader::guess_full_class_name(Dwarf_die* die) |
| 650 | { |
| 651 | std::string full_name; |
| 652 | off_t next_offset = 0; |
| 653 | |
| 654 | // This routine scans ahead in the DIE structure, possibly advancing |
| 655 | // the relocation tracker beyond the current DIE. We need to checkpoint |
| 656 | // the tracker and reset it when we're done. |
| 657 | uint64_t checkpoint = this->get_reloc_checkpoint(); |
| 658 | |
| 659 | for (off_t child_offset = die->child_offset(); |
| 660 | child_offset != 0; |
| 661 | child_offset = next_offset) |
| 662 | { |
| 663 | Dwarf_die child(this, child_offset, die); |
| 664 | if (child.tag() == 0) |
| 665 | break; |
| 666 | if (child.tag() == elfcpp::DW_TAG_subprogram) |
| 667 | { |
| 668 | const char* linkage_name = child.linkage_name(); |
| 669 | if (linkage_name != NULL) |
| 670 | { |
| 671 | char* guess = class_name_from_linkage_name(linkage_name); |
| 672 | if (guess != NULL) |
| 673 | { |
| 674 | full_name.assign(guess); |
| 675 | free(guess); |
| 676 | break; |
| 677 | } |
| 678 | } |
| 679 | } |
| 680 | next_offset = child.sibling_offset(); |
| 681 | } |
| 682 | |
| 683 | this->reset_relocs(checkpoint); |
| 684 | return full_name; |
| 685 | } |
| 686 | |
| 687 | // Add a declaration DIE to the table of declarations. |
| 688 | |
| 689 | void |
| 690 | Gdb_index_info_reader::add_declaration(Dwarf_die* die, Dwarf_die* context) |
| 691 | { |
| 692 | const char* name = die->name(); |
| 693 | |
| 694 | off_t parent_offset = context != NULL ? context->offset() : 0; |
| 695 | |
| 696 | // If this DIE has a DW_AT_specification or DW_AT_abstract_origin |
| 697 | // attribute, use the parent and name from the earlier declaration. |
| 698 | off_t spec = die->specification(); |
| 699 | if (spec == 0) |
| 700 | spec = die->abstract_origin(); |
| 701 | if (spec > 0) |
| 702 | { |
| 703 | Declaration_map::iterator it = this->declarations_.find(spec); |
| 704 | if (it != this->declarations_.end()) |
| 705 | { |
| 706 | parent_offset = it->second.parent_offset_; |
| 707 | name = it->second.name_; |
| 708 | } |
| 709 | } |
| 710 | |
| 711 | if (name == NULL) |
| 712 | { |
| 713 | if (die->tag() == elfcpp::DW_TAG_namespace) |
| 714 | name = "(anonymous namespace)"; |
| 715 | else if (die->tag() == elfcpp::DW_TAG_union_type) |
| 716 | name = "(anonymous union)"; |
| 717 | else |
| 718 | name = "(unknown)"; |
| 719 | } |
| 720 | |
| 721 | Declaration_pair decl(parent_offset, name); |
| 722 | this->declarations_.insert(std::make_pair(die->offset(), decl)); |
| 723 | } |
| 724 | |
| 725 | // Add a declaration whose fully-qualified name is already known. |
| 726 | // In the case where we had to get the canonical name by demangling |
| 727 | // a linkage name, this ensures we use that name instead of the one |
| 728 | // provided in DW_AT_name. |
| 729 | |
| 730 | void |
| 731 | Gdb_index_info_reader::add_declaration_with_full_name( |
| 732 | Dwarf_die* die, |
| 733 | const char* full_name) |
| 734 | { |
| 735 | // We need to copy the name. |
| 736 | int len = strlen(full_name); |
| 737 | char* copy = new char[len + 1]; |
| 738 | memcpy(copy, full_name, len + 1); |
| 739 | |
| 740 | // Flag that we now manage the memory this points to. |
| 741 | Declaration_pair decl(-1, copy); |
| 742 | this->declarations_.insert(std::make_pair(die->offset(), decl)); |
| 743 | } |
| 744 | |
| 745 | // Return the context for a DIE whose parent is at DIE_OFFSET. |
| 746 | |
| 747 | std::string |
| 748 | Gdb_index_info_reader::get_context(off_t die_offset) |
| 749 | { |
| 750 | std::string context; |
| 751 | Declaration_map::iterator it = this->declarations_.find(die_offset); |
| 752 | if (it != this->declarations_.end()) |
| 753 | { |
| 754 | off_t parent_offset = it->second.parent_offset_; |
| 755 | if (parent_offset > 0) |
| 756 | { |
| 757 | context = get_context(parent_offset); |
| 758 | context.append("::"); |
| 759 | } |
| 760 | if (it->second.name_ != NULL) |
| 761 | context.append(it->second.name_); |
| 762 | } |
| 763 | return context; |
| 764 | } |
| 765 | |
| 766 | // Construct the fully-qualified name for DIE. |
| 767 | |
| 768 | std::string |
| 769 | Gdb_index_info_reader::get_qualified_name(Dwarf_die* die, Dwarf_die* context) |
| 770 | { |
| 771 | std::string full_name; |
| 772 | const char* name = die->name(); |
| 773 | |
| 774 | off_t parent_offset = context != NULL ? context->offset() : 0; |
| 775 | |
| 776 | // If this DIE has a DW_AT_specification or DW_AT_abstract_origin |
| 777 | // attribute, use the parent and name from the earlier declaration. |
| 778 | off_t spec = die->specification(); |
| 779 | if (spec == 0) |
| 780 | spec = die->abstract_origin(); |
| 781 | if (spec > 0) |
| 782 | { |
| 783 | Declaration_map::iterator it = this->declarations_.find(spec); |
| 784 | if (it != this->declarations_.end()) |
| 785 | { |
| 786 | parent_offset = it->second.parent_offset_; |
| 787 | name = it->second.name_; |
| 788 | } |
| 789 | } |
| 790 | |
| 791 | if (name == NULL && die->tag() == elfcpp::DW_TAG_namespace) |
| 792 | name = "(anonymous namespace)"; |
| 793 | else if (name == NULL) |
| 794 | return full_name; |
| 795 | |
| 796 | // If this is an enumerator constant, skip the immediate parent, |
| 797 | // which is the enumeration tag. |
| 798 | if (die->tag() == elfcpp::DW_TAG_enumerator) |
| 799 | { |
| 800 | Declaration_map::iterator it = this->declarations_.find(parent_offset); |
| 801 | if (it != this->declarations_.end()) |
| 802 | parent_offset = it->second.parent_offset_; |
| 803 | } |
| 804 | |
| 805 | if (parent_offset > 0) |
| 806 | { |
| 807 | full_name.assign(this->get_context(parent_offset)); |
| 808 | full_name.append("::"); |
| 809 | } |
| 810 | full_name.append(name); |
| 811 | |
| 812 | return full_name; |
| 813 | } |
| 814 | |
| 815 | // Record the address ranges for a compilation unit. |
| 816 | |
| 817 | void |
| 818 | Gdb_index_info_reader::record_cu_ranges(Dwarf_die* die) |
| 819 | { |
| 820 | unsigned int shndx; |
| 821 | unsigned int shndx2; |
| 822 | |
| 823 | off_t ranges_offset = die->ref_attribute(elfcpp::DW_AT_ranges, &shndx); |
| 824 | if (ranges_offset != -1) |
| 825 | { |
| 826 | Dwarf_range_list* ranges = this->read_range_list(shndx, ranges_offset); |
| 827 | if (ranges != NULL) |
| 828 | this->gdb_index_->add_address_range_list(this->object(), |
| 829 | this->cu_index_, ranges); |
| 830 | return; |
| 831 | } |
| 832 | |
| 833 | off_t low_pc = die->address_attribute(elfcpp::DW_AT_low_pc, &shndx); |
| 834 | off_t high_pc = die->address_attribute(elfcpp::DW_AT_high_pc, &shndx2); |
| 835 | if (high_pc == -1) |
| 836 | { |
| 837 | high_pc = die->uint_attribute(elfcpp::DW_AT_high_pc); |
| 838 | high_pc += low_pc; |
| 839 | shndx2 = shndx; |
| 840 | } |
| 841 | if ((low_pc != 0 || high_pc != 0) && low_pc != -1) |
| 842 | { |
| 843 | if (shndx != shndx2) |
| 844 | { |
| 845 | gold_warning(_("%s: DWARF info may be corrupt; low_pc and high_pc " |
| 846 | "are in different sections"), |
| 847 | this->object()->name().c_str()); |
| 848 | return; |
| 849 | } |
| 850 | if (shndx == 0 || this->object()->is_section_included(shndx)) |
| 851 | { |
| 852 | Dwarf_range_list* ranges = new Dwarf_range_list(); |
| 853 | ranges->add(shndx, low_pc, high_pc); |
| 854 | this->gdb_index_->add_address_range_list(this->object(), |
| 855 | this->cu_index_, ranges); |
| 856 | } |
| 857 | } |
| 858 | } |
| 859 | |
| 860 | // Read table and add the relevant names to the index. Returns true |
| 861 | // if any names were added. |
| 862 | |
| 863 | bool |
| 864 | Gdb_index_info_reader::read_pubtable(Dwarf_pubnames_table* table, off_t offset) |
| 865 | { |
| 866 | // If we couldn't read the section when building the cu_pubname_map, |
| 867 | // then we won't find any pubnames now. |
| 868 | if (table == NULL) |
| 869 | return false; |
| 870 | |
| 871 | if (!table->read_header(offset)) |
| 872 | return false; |
| 873 | while (true) |
| 874 | { |
| 875 | uint8_t flag_byte; |
| 876 | const char* name = table->next_name(&flag_byte); |
| 877 | if (name == NULL) |
| 878 | break; |
| 879 | |
| 880 | this->gdb_index_->add_symbol(this->cu_index_, name, flag_byte); |
| 881 | } |
| 882 | return true; |
| 883 | } |
| 884 | |
| 885 | // Read the .debug_pubnames and .debug_pubtypes tables for the CU or TU. |
| 886 | // Returns TRUE if either a pubnames or pubtypes section was found. |
| 887 | |
| 888 | bool |
| 889 | Gdb_index_info_reader::read_pubnames_and_pubtypes(Dwarf_die* die) |
| 890 | { |
| 891 | // If this is a skeleton debug-type die (generated via |
| 892 | // -gsplit-dwarf), then the associated pubnames should have been |
| 893 | // read along with the corresponding CU. In any case, there isn't |
| 894 | // enough info inside to build a gdb index entry. |
| 895 | if (die->tag() == elfcpp::DW_TAG_type_unit |
| 896 | && die->string_attribute(elfcpp::DW_AT_GNU_dwo_name)) |
| 897 | return true; |
| 898 | |
| 899 | // We use stmt_list_off as a unique identifier for the |
| 900 | // compilation unit and its associated type units. |
| 901 | unsigned int shndx; |
| 902 | off_t stmt_list_off = die->ref_attribute (elfcpp::DW_AT_stmt_list, |
| 903 | &shndx); |
| 904 | // Look for the attr as either a flag or a ref. |
| 905 | off_t offset = die->ref_attribute(elfcpp::DW_AT_GNU_pubnames, &shndx); |
| 906 | |
| 907 | // Newer versions of GCC generate CUs, but not TUs, with |
| 908 | // DW_AT_FORM_flag_present. |
| 909 | unsigned int flag = die->uint_attribute(elfcpp::DW_AT_GNU_pubnames); |
| 910 | if (offset == -1 && flag == 0) |
| 911 | { |
| 912 | // Didn't find the attribute. |
| 913 | if (die->tag() == elfcpp::DW_TAG_type_unit) |
| 914 | { |
| 915 | // If die is a TU, then it might correspond to a CU which we |
| 916 | // have read. If it does, then no need to read the pubnames. |
| 917 | // If it doesn't, then the caller will have to parse the |
| 918 | // dies manually to find the names. |
| 919 | return this->gdb_index_->pubnames_read(this->object(), |
| 920 | stmt_list_off); |
| 921 | } |
| 922 | else |
| 923 | { |
| 924 | // No attribute on the CU means that no pubnames were read. |
| 925 | return false; |
| 926 | } |
| 927 | } |
| 928 | |
| 929 | // We found the attribute, so we can check if the corresponding |
| 930 | // pubnames have been read. |
| 931 | if (this->gdb_index_->pubnames_read(this->object(), stmt_list_off)) |
| 932 | return true; |
| 933 | |
| 934 | this->gdb_index_->set_pubnames_read(this->object(), stmt_list_off); |
| 935 | |
| 936 | // We have an attribute, and the pubnames haven't been read, so read |
| 937 | // them. |
| 938 | bool names = false; |
| 939 | // In some of the cases, we could rely on the previous value of |
| 940 | // offset here, but sorting out which cases complicates the logic |
| 941 | // enough that it isn't worth it. So just look up the offset again. |
| 942 | offset = this->gdb_index_->find_pubname_offset(this->cu_offset()); |
| 943 | names = this->read_pubtable(this->gdb_index_->pubnames_table(), offset); |
| 944 | |
| 945 | bool types = false; |
| 946 | offset = this->gdb_index_->find_pubtype_offset(this->cu_offset()); |
| 947 | types = this->read_pubtable(this->gdb_index_->pubtypes_table(), offset); |
| 948 | return names || types; |
| 949 | } |
| 950 | |
| 951 | // Clear the declarations map. |
| 952 | void |
| 953 | Gdb_index_info_reader::clear_declarations() |
| 954 | { |
| 955 | // Free strings in memory we manage. |
| 956 | for (Declaration_map::iterator it = this->declarations_.begin(); |
| 957 | it != this->declarations_.end(); |
| 958 | ++it) |
| 959 | { |
| 960 | if (it->second.parent_offset_ == -1) |
| 961 | delete[] it->second.name_; |
| 962 | } |
| 963 | |
| 964 | this->declarations_.clear(); |
| 965 | } |
| 966 | |
| 967 | // Print usage statistics. |
| 968 | void |
| 969 | Gdb_index_info_reader::print_stats() |
| 970 | { |
| 971 | fprintf(stderr, _("%s: DWARF CUs: %u\n"), |
| 972 | program_name, Gdb_index_info_reader::dwarf_cu_count); |
| 973 | fprintf(stderr, _("%s: DWARF CUs without pubnames/pubtypes: %u\n"), |
| 974 | program_name, Gdb_index_info_reader::dwarf_cu_nopubnames_count); |
| 975 | fprintf(stderr, _("%s: DWARF TUs: %u\n"), |
| 976 | program_name, Gdb_index_info_reader::dwarf_tu_count); |
| 977 | fprintf(stderr, _("%s: DWARF TUs without pubnames/pubtypes: %u\n"), |
| 978 | program_name, Gdb_index_info_reader::dwarf_tu_nopubnames_count); |
| 979 | } |
| 980 | |
| 981 | // Class Gdb_index. |
| 982 | |
| 983 | // Construct the .gdb_index section. |
| 984 | |
| 985 | Gdb_index::Gdb_index(Output_section* gdb_index_section) |
| 986 | : Output_section_data(4), |
| 987 | pubnames_table_(NULL), |
| 988 | pubtypes_table_(NULL), |
| 989 | gdb_index_section_(gdb_index_section), |
| 990 | comp_units_(), |
| 991 | type_units_(), |
| 992 | ranges_(), |
| 993 | cu_vector_list_(), |
| 994 | cu_vector_offsets_(NULL), |
| 995 | stringpool_(), |
| 996 | tu_offset_(0), |
| 997 | addr_offset_(0), |
| 998 | symtab_offset_(0), |
| 999 | cu_pool_offset_(0), |
| 1000 | stringpool_offset_(0), |
| 1001 | pubnames_object_(NULL), |
| 1002 | stmt_list_offset_(-1) |
| 1003 | { |
| 1004 | this->gdb_symtab_ = new Gdb_hashtab<Gdb_symbol>(); |
| 1005 | } |
| 1006 | |
| 1007 | Gdb_index::~Gdb_index() |
| 1008 | { |
| 1009 | // Free the memory used by the symbol table. |
| 1010 | delete this->gdb_symtab_; |
| 1011 | // Free the memory used by the CU vectors. |
| 1012 | for (unsigned int i = 0; i < this->cu_vector_list_.size(); ++i) |
| 1013 | delete this->cu_vector_list_[i]; |
| 1014 | } |
| 1015 | |
| 1016 | |
| 1017 | // Scan the pubnames and pubtypes sections and build a map of the |
| 1018 | // various cus and tus they refer to, so we can process the entries |
| 1019 | // when we encounter the die for that cu or tu. |
| 1020 | // Return the just-read table so it can be cached. |
| 1021 | |
| 1022 | Dwarf_pubnames_table* |
| 1023 | Gdb_index::map_pubtable_to_dies(unsigned int attr, |
| 1024 | Gdb_index_info_reader* dwinfo, |
| 1025 | Relobj* object, |
| 1026 | const unsigned char* symbols, |
| 1027 | off_t symbols_size) |
| 1028 | { |
| 1029 | uint64_t section_offset = 0; |
| 1030 | Dwarf_pubnames_table* table; |
| 1031 | Pubname_offset_map* map; |
| 1032 | |
| 1033 | if (attr == elfcpp::DW_AT_GNU_pubnames) |
| 1034 | { |
| 1035 | table = new Dwarf_pubnames_table(dwinfo, false); |
| 1036 | map = &this->cu_pubname_map_; |
| 1037 | } |
| 1038 | else |
| 1039 | { |
| 1040 | table = new Dwarf_pubnames_table(dwinfo, true); |
| 1041 | map = &this->cu_pubtype_map_; |
| 1042 | } |
| 1043 | |
| 1044 | map->clear(); |
| 1045 | if (!table->read_section(object, symbols, symbols_size)) |
| 1046 | return NULL; |
| 1047 | |
| 1048 | while (table->read_header(section_offset)) |
| 1049 | { |
| 1050 | map->insert(std::make_pair(table->cu_offset(), section_offset)); |
| 1051 | section_offset += table->subsection_size(); |
| 1052 | } |
| 1053 | |
| 1054 | return table; |
| 1055 | } |
| 1056 | |
| 1057 | // Wrapper for map_pubtable_to_dies |
| 1058 | |
| 1059 | void |
| 1060 | Gdb_index::map_pubnames_and_types_to_dies(Gdb_index_info_reader* dwinfo, |
| 1061 | Relobj* object, |
| 1062 | const unsigned char* symbols, |
| 1063 | off_t symbols_size) |
| 1064 | { |
| 1065 | // This is a new object, so reset the relevant variables. |
| 1066 | this->pubnames_object_ = object; |
| 1067 | this->stmt_list_offset_ = -1; |
| 1068 | |
| 1069 | delete this->pubnames_table_; |
| 1070 | this->pubnames_table_ |
| 1071 | = this->map_pubtable_to_dies(elfcpp::DW_AT_GNU_pubnames, dwinfo, |
| 1072 | object, symbols, symbols_size); |
| 1073 | delete this->pubtypes_table_; |
| 1074 | this->pubtypes_table_ |
| 1075 | = this->map_pubtable_to_dies(elfcpp::DW_AT_GNU_pubtypes, dwinfo, |
| 1076 | object, symbols, symbols_size); |
| 1077 | } |
| 1078 | |
| 1079 | // Given a cu_offset, find the associated section of the pubnames |
| 1080 | // table. |
| 1081 | |
| 1082 | off_t |
| 1083 | Gdb_index::find_pubname_offset(off_t cu_offset) |
| 1084 | { |
| 1085 | Pubname_offset_map::iterator it = this->cu_pubname_map_.find(cu_offset); |
| 1086 | if (it != this->cu_pubname_map_.end()) |
| 1087 | return it->second; |
| 1088 | return -1; |
| 1089 | } |
| 1090 | |
| 1091 | // Given a cu_offset, find the associated section of the pubnames |
| 1092 | // table. |
| 1093 | |
| 1094 | off_t |
| 1095 | Gdb_index::find_pubtype_offset(off_t cu_offset) |
| 1096 | { |
| 1097 | Pubname_offset_map::iterator it = this->cu_pubtype_map_.find(cu_offset); |
| 1098 | if (it != this->cu_pubtype_map_.end()) |
| 1099 | return it->second; |
| 1100 | return -1; |
| 1101 | } |
| 1102 | |
| 1103 | // Scan a .debug_info or .debug_types input section. |
| 1104 | |
| 1105 | void |
| 1106 | Gdb_index::scan_debug_info(bool is_type_unit, |
| 1107 | Relobj* object, |
| 1108 | const unsigned char* symbols, |
| 1109 | off_t symbols_size, |
| 1110 | unsigned int shndx, |
| 1111 | unsigned int reloc_shndx, |
| 1112 | unsigned int reloc_type) |
| 1113 | { |
| 1114 | Gdb_index_info_reader dwinfo(is_type_unit, object, |
| 1115 | symbols, symbols_size, |
| 1116 | shndx, reloc_shndx, |
| 1117 | reloc_type, this); |
| 1118 | if (object != this->pubnames_object_) |
| 1119 | map_pubnames_and_types_to_dies(&dwinfo, object, symbols, symbols_size); |
| 1120 | dwinfo.parse(); |
| 1121 | } |
| 1122 | |
| 1123 | // Add a symbol. |
| 1124 | |
| 1125 | void |
| 1126 | Gdb_index::add_symbol(int cu_index, const char* sym_name, uint8_t flags) |
| 1127 | { |
| 1128 | unsigned int hash = mapped_index_string_hash( |
| 1129 | reinterpret_cast<const unsigned char*>(sym_name)); |
| 1130 | Gdb_symbol* sym = new Gdb_symbol(); |
| 1131 | this->stringpool_.add(sym_name, true, &sym->name_key); |
| 1132 | sym->hashval = hash; |
| 1133 | sym->cu_vector_index = 0; |
| 1134 | |
| 1135 | Gdb_symbol* found = this->gdb_symtab_->add(sym); |
| 1136 | if (found == sym) |
| 1137 | { |
| 1138 | // New symbol -- allocate a new CU index vector. |
| 1139 | found->cu_vector_index = this->cu_vector_list_.size(); |
| 1140 | this->cu_vector_list_.push_back(new Cu_vector()); |
| 1141 | } |
| 1142 | else |
| 1143 | { |
| 1144 | // Found an existing symbol -- append to the existing |
| 1145 | // CU index vector. |
| 1146 | delete sym; |
| 1147 | } |
| 1148 | |
| 1149 | // Add the CU index to the vector list for this symbol, |
| 1150 | // if it's not already on the list. We only need to |
| 1151 | // check the last added entry. |
| 1152 | Cu_vector* cu_vec = this->cu_vector_list_[found->cu_vector_index]; |
| 1153 | if (cu_vec->size() == 0 |
| 1154 | || cu_vec->back().first != cu_index |
| 1155 | || cu_vec->back().second != flags) |
| 1156 | cu_vec->push_back(std::make_pair(cu_index, flags)); |
| 1157 | } |
| 1158 | |
| 1159 | // Return TRUE if we have already processed the pubnames associated |
| 1160 | // with the statement list at the given OFFSET. |
| 1161 | |
| 1162 | bool |
| 1163 | Gdb_index::pubnames_read(const Relobj* object, off_t offset) |
| 1164 | { |
| 1165 | bool ret = (this->pubnames_object_ == object |
| 1166 | && this->stmt_list_offset_ == offset); |
| 1167 | return ret; |
| 1168 | } |
| 1169 | |
| 1170 | // Record that we have processed the pubnames associated with the |
| 1171 | // statement list for OBJECT at the given OFFSET. |
| 1172 | |
| 1173 | void |
| 1174 | Gdb_index::set_pubnames_read(const Relobj* object, off_t offset) |
| 1175 | { |
| 1176 | this->pubnames_object_ = object; |
| 1177 | this->stmt_list_offset_ = offset; |
| 1178 | } |
| 1179 | |
| 1180 | // Set the size of the .gdb_index section. |
| 1181 | |
| 1182 | void |
| 1183 | Gdb_index::set_final_data_size() |
| 1184 | { |
| 1185 | // Finalize the string pool. |
| 1186 | this->stringpool_.set_string_offsets(); |
| 1187 | |
| 1188 | // Compute the total size of the CU vectors. |
| 1189 | // For each CU vector, include one entry for the count at the |
| 1190 | // beginning of the vector. |
| 1191 | unsigned int cu_vector_count = this->cu_vector_list_.size(); |
| 1192 | unsigned int cu_vector_size = 0; |
| 1193 | this->cu_vector_offsets_ = new off_t[cu_vector_count]; |
| 1194 | for (unsigned int i = 0; i < cu_vector_count; ++i) |
| 1195 | { |
| 1196 | Cu_vector* cu_vec = this->cu_vector_list_[i]; |
| 1197 | cu_vector_offsets_[i] = cu_vector_size; |
| 1198 | cu_vector_size += gdb_index_offset_size * (cu_vec->size() + 1); |
| 1199 | } |
| 1200 | |
| 1201 | // Assign relative offsets to each portion of the index, |
| 1202 | // and find the total size of the section. |
| 1203 | section_size_type data_size = gdb_index_hdr_size; |
| 1204 | data_size += this->comp_units_.size() * gdb_index_cu_size; |
| 1205 | this->tu_offset_ = data_size; |
| 1206 | data_size += this->type_units_.size() * gdb_index_tu_size; |
| 1207 | this->addr_offset_ = data_size; |
| 1208 | for (unsigned int i = 0; i < this->ranges_.size(); ++i) |
| 1209 | data_size += this->ranges_[i].ranges->size() * gdb_index_addr_size; |
| 1210 | this->symtab_offset_ = data_size; |
| 1211 | data_size += this->gdb_symtab_->capacity() * gdb_index_sym_size; |
| 1212 | this->cu_pool_offset_ = data_size; |
| 1213 | data_size += cu_vector_size; |
| 1214 | this->stringpool_offset_ = data_size; |
| 1215 | data_size += this->stringpool_.get_strtab_size(); |
| 1216 | |
| 1217 | this->set_data_size(data_size); |
| 1218 | } |
| 1219 | |
| 1220 | // Write the data to the file. |
| 1221 | |
| 1222 | void |
| 1223 | Gdb_index::do_write(Output_file* of) |
| 1224 | { |
| 1225 | const off_t off = this->offset(); |
| 1226 | const off_t oview_size = this->data_size(); |
| 1227 | unsigned char* const oview = of->get_output_view(off, oview_size); |
| 1228 | unsigned char* pov = oview; |
| 1229 | |
| 1230 | // Write the file header. |
| 1231 | // (1) Version number. |
| 1232 | elfcpp::Swap<32, false>::writeval(pov, gdb_index_version); |
| 1233 | pov += 4; |
| 1234 | // (2) Offset of the CU list. |
| 1235 | elfcpp::Swap<32, false>::writeval(pov, gdb_index_hdr_size); |
| 1236 | pov += 4; |
| 1237 | // (3) Offset of the types CU list. |
| 1238 | elfcpp::Swap<32, false>::writeval(pov, this->tu_offset_); |
| 1239 | pov += 4; |
| 1240 | // (4) Offset of the address area. |
| 1241 | elfcpp::Swap<32, false>::writeval(pov, this->addr_offset_); |
| 1242 | pov += 4; |
| 1243 | // (5) Offset of the symbol table. |
| 1244 | elfcpp::Swap<32, false>::writeval(pov, this->symtab_offset_); |
| 1245 | pov += 4; |
| 1246 | // (6) Offset of the constant pool. |
| 1247 | elfcpp::Swap<32, false>::writeval(pov, this->cu_pool_offset_); |
| 1248 | pov += 4; |
| 1249 | |
| 1250 | gold_assert(pov - oview == gdb_index_hdr_size); |
| 1251 | |
| 1252 | // Write the CU list. |
| 1253 | unsigned int comp_units_count = this->comp_units_.size(); |
| 1254 | for (unsigned int i = 0; i < comp_units_count; ++i) |
| 1255 | { |
| 1256 | const Comp_unit& cu = this->comp_units_[i]; |
| 1257 | elfcpp::Swap<64, false>::writeval(pov, cu.cu_offset); |
| 1258 | elfcpp::Swap<64, false>::writeval(pov + 8, cu.cu_length); |
| 1259 | pov += 16; |
| 1260 | } |
| 1261 | |
| 1262 | gold_assert(pov - oview == this->tu_offset_); |
| 1263 | |
| 1264 | // Write the types CU list. |
| 1265 | for (unsigned int i = 0; i < this->type_units_.size(); ++i) |
| 1266 | { |
| 1267 | const Type_unit& tu = this->type_units_[i]; |
| 1268 | elfcpp::Swap<64, false>::writeval(pov, tu.tu_offset); |
| 1269 | elfcpp::Swap<64, false>::writeval(pov + 8, tu.type_offset); |
| 1270 | elfcpp::Swap<64, false>::writeval(pov + 16, tu.type_signature); |
| 1271 | pov += 24; |
| 1272 | } |
| 1273 | |
| 1274 | gold_assert(pov - oview == this->addr_offset_); |
| 1275 | |
| 1276 | // Write the address area. |
| 1277 | for (unsigned int i = 0; i < this->ranges_.size(); ++i) |
| 1278 | { |
| 1279 | int cu_index = this->ranges_[i].cu_index; |
| 1280 | // Translate negative indexes, which refer to a TU, to a |
| 1281 | // logical index into a concatenated CU/TU list. |
| 1282 | if (cu_index < 0) |
| 1283 | cu_index = comp_units_count + (-1 - cu_index); |
| 1284 | Relobj* object = this->ranges_[i].object; |
| 1285 | const Dwarf_range_list& ranges = *this->ranges_[i].ranges; |
| 1286 | for (unsigned int j = 0; j < ranges.size(); ++j) |
| 1287 | { |
| 1288 | const Dwarf_range_list::Range& range = ranges[j]; |
| 1289 | uint64_t base = 0; |
| 1290 | if (range.shndx > 0) |
| 1291 | { |
| 1292 | const Output_section* os = object->output_section(range.shndx); |
| 1293 | base = (os->address() |
| 1294 | + object->output_section_offset(range.shndx)); |
| 1295 | } |
| 1296 | elfcpp::Swap_aligned32<64, false>::writeval(pov, base + range.start); |
| 1297 | elfcpp::Swap_aligned32<64, false>::writeval(pov + 8, |
| 1298 | base + range.end); |
| 1299 | elfcpp::Swap<32, false>::writeval(pov + 16, cu_index); |
| 1300 | pov += 20; |
| 1301 | } |
| 1302 | } |
| 1303 | |
| 1304 | gold_assert(pov - oview == this->symtab_offset_); |
| 1305 | |
| 1306 | // Write the symbol table. |
| 1307 | for (unsigned int i = 0; i < this->gdb_symtab_->capacity(); ++i) |
| 1308 | { |
| 1309 | const Gdb_symbol* sym = (*this->gdb_symtab_)[i]; |
| 1310 | section_offset_type name_offset = 0; |
| 1311 | unsigned int cu_vector_offset = 0; |
| 1312 | if (sym != NULL) |
| 1313 | { |
| 1314 | name_offset = (this->stringpool_.get_offset_from_key(sym->name_key) |
| 1315 | + this->stringpool_offset_ - this->cu_pool_offset_); |
| 1316 | cu_vector_offset = this->cu_vector_offsets_[sym->cu_vector_index]; |
| 1317 | } |
| 1318 | elfcpp::Swap<32, false>::writeval(pov, name_offset); |
| 1319 | elfcpp::Swap<32, false>::writeval(pov + 4, cu_vector_offset); |
| 1320 | pov += 8; |
| 1321 | } |
| 1322 | |
| 1323 | gold_assert(pov - oview == this->cu_pool_offset_); |
| 1324 | |
| 1325 | // Write the CU vectors into the constant pool. |
| 1326 | for (unsigned int i = 0; i < this->cu_vector_list_.size(); ++i) |
| 1327 | { |
| 1328 | Cu_vector* cu_vec = this->cu_vector_list_[i]; |
| 1329 | elfcpp::Swap<32, false>::writeval(pov, cu_vec->size()); |
| 1330 | pov += 4; |
| 1331 | for (unsigned int j = 0; j < cu_vec->size(); ++j) |
| 1332 | { |
| 1333 | int cu_index = (*cu_vec)[j].first; |
| 1334 | uint8_t flags = (*cu_vec)[j].second; |
| 1335 | if (cu_index < 0) |
| 1336 | cu_index = comp_units_count + (-1 - cu_index); |
| 1337 | cu_index |= flags << 24; |
| 1338 | elfcpp::Swap<32, false>::writeval(pov, cu_index); |
| 1339 | pov += 4; |
| 1340 | } |
| 1341 | } |
| 1342 | |
| 1343 | gold_assert(pov - oview == this->stringpool_offset_); |
| 1344 | |
| 1345 | // Write the strings into the constant pool. |
| 1346 | this->stringpool_.write_to_buffer(pov, oview_size - this->stringpool_offset_); |
| 1347 | |
| 1348 | of->write_output_view(off, oview_size, oview); |
| 1349 | } |
| 1350 | |
| 1351 | // Print usage statistics. |
| 1352 | void |
| 1353 | Gdb_index::print_stats() |
| 1354 | { |
| 1355 | if (parameters->options().gdb_index()) |
| 1356 | Gdb_index_info_reader::print_stats(); |
| 1357 | } |
| 1358 | |
| 1359 | } // End namespace gold. |