1 // mapfile.cc -- map file generation for gold 2 3 // Copyright (C) 2008-2014 Free Software Foundation, Inc. 4 // Written by Ian Lance Taylor <iant (at) 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 <cerrno> 26 #include <cstdio> 27 #include <cstring> 28 29 #include "archive.h" 30 #include "symtab.h" 31 #include "output.h" 32 #include "mapfile.h" 33 34 // This file holds the code for printing information to the map file. 35 // In general we try to produce pretty much the same format as GNU ld. 36 37 namespace gold 38 { 39 40 // Mapfile constructor. 41 42 Mapfile::Mapfile() 43 : map_file_(NULL), 44 printed_archive_header_(false), 45 printed_common_header_(false), 46 printed_memory_map_header_(false) 47 { 48 } 49 50 // Mapfile destructor. 51 52 Mapfile::~Mapfile() 53 { 54 if (this->map_file_ != NULL) 55 this->close(); 56 } 57 58 // Open the map file. 59 60 bool 61 Mapfile::open(const char* map_filename) 62 { 63 if (strcmp(map_filename, "-") == 0) 64 this->map_file_ = stdout; 65 else 66 { 67 this->map_file_ = ::fopen(map_filename, "w"); 68 if (this->map_file_ == NULL) 69 { 70 gold_error(_("cannot open map file %s: %s"), map_filename, 71 strerror(errno)); 72 return false; 73 } 74 } 75 return true; 76 } 77 78 // Close the map file. 79 80 void 81 Mapfile::close() 82 { 83 if (fclose(this->map_file_) != 0) 84 gold_error(_("cannot close map file: %s"), strerror(errno)); 85 this->map_file_ = NULL; 86 } 87 88 // Advance to a column. 89 90 void 91 Mapfile::advance_to_column(size_t from, size_t to) 92 { 93 if (from >= to - 1) 94 { 95 putc('\n', this->map_file_); 96 from = 0; 97 } 98 while (from < to) 99 { 100 putc(' ', this->map_file_); 101 ++from; 102 } 103 } 104 105 // Report about including a member from an archive. 106 107 void 108 Mapfile::report_include_archive_member(const std::string& member_name, 109 const Symbol* sym, const char* why) 110 { 111 // We print a header before the list of archive members, mainly for 112 // GNU ld compatibility. 113 if (!this->printed_archive_header_) 114 { 115 fprintf(this->map_file_, 116 _("Archive member included because of file (symbol)\n\n")); 117 this->printed_archive_header_ = true; 118 } 119 120 fprintf(this->map_file_, "%s", member_name.c_str()); 121 122 this->advance_to_column(member_name.length(), 30); 123 124 if (sym == NULL) 125 fprintf(this->map_file_, "%s", why); 126 else 127 { 128 switch (sym->source()) 129 { 130 case Symbol::FROM_OBJECT: 131 fprintf(this->map_file_, "%s", sym->object()->name().c_str()); 132 break; 133 134 case Symbol::IS_UNDEFINED: 135 fprintf(this->map_file_, "-u"); 136 break; 137 138 default: 139 case Symbol::IN_OUTPUT_DATA: 140 case Symbol::IN_OUTPUT_SEGMENT: 141 case Symbol::IS_CONSTANT: 142 // We should only see an undefined symbol here. 143 gold_unreachable(); 144 } 145 146 fprintf(this->map_file_, " (%s)", sym->name()); 147 } 148 149 putc('\n', this->map_file_); 150 } 151 152 // Report allocating a common symbol. 153 154 void 155 Mapfile::report_allocate_common(const Symbol* sym, uint64_t symsize) 156 { 157 if (!this->printed_common_header_) 158 { 159 fprintf(this->map_file_, _("\nAllocating common symbols\n")); 160 fprintf(this->map_file_, 161 _("Common symbol size file\n\n")); 162 this->printed_common_header_ = true; 163 } 164 165 std::string demangled_name = sym->demangled_name(); 166 fprintf(this->map_file_, "%s", demangled_name.c_str()); 167 168 this->advance_to_column(demangled_name.length(), 20); 169 170 char buf[50]; 171 snprintf(buf, sizeof buf, "0x%llx", static_cast<unsigned long long>(symsize)); 172 fprintf(this->map_file_, "%s", buf); 173 174 size_t len = strlen(buf); 175 while (len < 18) 176 { 177 putc(' ', this->map_file_); 178 ++len; 179 } 180 181 fprintf(this->map_file_, "%s\n", sym->object()->name().c_str()); 182 } 183 184 // The space we make for a section name. 185 186 const size_t Mapfile::section_name_map_length = 16; 187 188 // Print the memory map header if necessary. 189 190 void 191 Mapfile::print_memory_map_header() 192 { 193 if (!this->printed_memory_map_header_) 194 { 195 fprintf(this->map_file_, _("\nMemory map\n\n")); 196 this->printed_memory_map_header_ = true; 197 } 198 } 199 200 // Print the symbols associated with an input section. 201 202 template<int size, bool big_endian> 203 void 204 Mapfile::print_input_section_symbols( 205 const Sized_relobj_file<size, big_endian>* relobj, 206 unsigned int shndx) 207 { 208 unsigned int symcount = relobj->symbol_count(); 209 for (unsigned int i = relobj->local_symbol_count(); i < symcount; ++i) 210 { 211 const Symbol* sym = relobj->global_symbol(i); 212 bool is_ordinary; 213 if (sym != NULL 214 && sym->source() == Symbol::FROM_OBJECT 215 && sym->object() == relobj 216 && sym->shndx(&is_ordinary) == shndx 217 && is_ordinary 218 && sym->is_defined()) 219 { 220 for (size_t i = 0; i < Mapfile::section_name_map_length; ++i) 221 putc(' ', this->map_file_); 222 const Sized_symbol<size>* ssym = 223 static_cast<const Sized_symbol<size>*>(sym); 224 fprintf(this->map_file_, 225 "0x%0*llx %s\n", 226 size / 4, 227 static_cast<unsigned long long>(ssym->value()), 228 sym->demangled_name().c_str()); 229 } 230 } 231 } 232 233 // Print an input section. 234 235 void 236 Mapfile::print_input_section(Relobj* relobj, unsigned int shndx) 237 { 238 putc(' ', this->map_file_); 239 240 std::string name = relobj->section_name(shndx); 241 fprintf(this->map_file_, "%s", name.c_str()); 242 243 this->advance_to_column(name.length() + 1, Mapfile::section_name_map_length); 244 245 Output_section* os; 246 uint64_t addr; 247 if (!relobj->is_section_included(shndx)) 248 { 249 os = NULL; 250 addr = 0; 251 } 252 else 253 { 254 os = relobj->output_section(shndx); 255 addr = relobj->output_section_offset(shndx); 256 if (addr != -1ULL) 257 addr += os->address(); 258 } 259 260 char sizebuf[50]; 261 section_size_type size; 262 if (!relobj->section_is_compressed(shndx, &size)) 263 size = relobj->section_size(shndx); 264 snprintf(sizebuf, sizeof sizebuf, "0x%llx", 265 static_cast<unsigned long long>(size)); 266 267 fprintf(this->map_file_, "0x%0*llx %10s %s\n", 268 parameters->target().get_size() / 4, 269 static_cast<unsigned long long>(addr), sizebuf, 270 relobj->name().c_str()); 271 272 if (os != NULL) 273 { 274 switch (parameters->size_and_endianness()) 275 { 276 #ifdef HAVE_TARGET_32_LITTLE 277 case Parameters::TARGET_32_LITTLE: 278 { 279 const Sized_relobj_file<32, false>* sized_relobj = 280 static_cast<Sized_relobj_file<32, false>*>(relobj); 281 this->print_input_section_symbols(sized_relobj, shndx); 282 } 283 break; 284 #endif 285 #ifdef HAVE_TARGET_32_BIG 286 case Parameters::TARGET_32_BIG: 287 { 288 const Sized_relobj_file<32, true>* sized_relobj = 289 static_cast<Sized_relobj_file<32, true>*>(relobj); 290 this->print_input_section_symbols(sized_relobj, shndx); 291 } 292 break; 293 #endif 294 #ifdef HAVE_TARGET_64_LITTLE 295 case Parameters::TARGET_64_LITTLE: 296 { 297 const Sized_relobj_file<64, false>* sized_relobj = 298 static_cast<Sized_relobj_file<64, false>*>(relobj); 299 this->print_input_section_symbols(sized_relobj, shndx); 300 } 301 break; 302 #endif 303 #ifdef HAVE_TARGET_64_BIG 304 case Parameters::TARGET_64_BIG: 305 { 306 const Sized_relobj_file<64, true>* sized_relobj = 307 static_cast<Sized_relobj_file<64, true>*>(relobj); 308 this->print_input_section_symbols(sized_relobj, shndx); 309 } 310 break; 311 #endif 312 default: 313 gold_unreachable(); 314 } 315 } 316 } 317 318 // Print an Output_section_data. This is printed to look like an 319 // input section. 320 321 void 322 Mapfile::print_output_data(const Output_data* od, const char* name) 323 { 324 this->print_memory_map_header(); 325 326 putc(' ', this->map_file_); 327 328 fprintf(this->map_file_, "%s", name); 329 330 this->advance_to_column(strlen(name) + 1, Mapfile::section_name_map_length); 331 332 char sizebuf[50]; 333 snprintf(sizebuf, sizeof sizebuf, "0x%llx", 334 static_cast<unsigned long long>(od->current_data_size())); 335 336 fprintf(this->map_file_, "0x%0*llx %10s\n", 337 parameters->target().get_size() / 4, 338 (od->is_address_valid() 339 ? static_cast<unsigned long long>(od->address()) 340 : 0), 341 sizebuf); 342 } 343 344 // Print the discarded input sections. 345 346 void 347 Mapfile::print_discarded_sections(const Input_objects* input_objects) 348 { 349 bool printed_header = false; 350 for (Input_objects::Relobj_iterator p = input_objects->relobj_begin(); 351 p != input_objects->relobj_end(); 352 ++p) 353 { 354 Relobj* relobj = *p; 355 // Lock the object so we can read from it. This is only called 356 // single-threaded from Layout_task_runner, so it is OK to lock. 357 // Unfortunately we have no way to pass in a Task token. 358 const Task* dummy_task = reinterpret_cast<const Task*>(-1); 359 Task_lock_obj<Object> tl(dummy_task, relobj); 360 361 unsigned int shnum = relobj->shnum(); 362 for (unsigned int i = 0; i < shnum; ++i) 363 { 364 unsigned int sh_type = relobj->section_type(i); 365 if ((sh_type == elfcpp::SHT_PROGBITS 366 || sh_type == elfcpp::SHT_NOBITS 367 || sh_type == elfcpp::SHT_GROUP) 368 && !relobj->is_section_included(i)) 369 { 370 if (!printed_header) 371 { 372 fprintf(this->map_file_, _("\nDiscarded input sections\n\n")); 373 printed_header = true; 374 } 375 376 this->print_input_section(relobj, i); 377 } 378 } 379 } 380 } 381 382 // Print an output section. 383 384 void 385 Mapfile::print_output_section(const Output_section* os) 386 { 387 this->print_memory_map_header(); 388 389 fprintf(this->map_file_, "\n%s", os->name()); 390 391 this->advance_to_column(strlen(os->name()), Mapfile::section_name_map_length); 392 393 char sizebuf[50]; 394 snprintf(sizebuf, sizeof sizebuf, "0x%llx", 395 static_cast<unsigned long long>(os->current_data_size())); 396 397 fprintf(this->map_file_, "0x%0*llx %10s", 398 parameters->target().get_size() / 4, 399 static_cast<unsigned long long>(os->address()), sizebuf); 400 401 if (os->has_load_address()) 402 fprintf(this->map_file_, " load address 0x%-*llx", 403 parameters->target().get_size() / 4, 404 static_cast<unsigned long long>(os->load_address())); 405 406 if (os->requires_postprocessing()) 407 fprintf(this->map_file_, " (before compression)"); 408 409 putc('\n', this->map_file_); 410 } 411 412 } // End namespace gold. 413
