7d9e3d9854
* mapfile.h: New file. * options.h (class General_options): Add -M/--print-map and -Map. * options.cc (General_options::finalize): Make -M equivalent to -Map -. * main.cc: Include <cstdio> and "mapfile.h". (main): Open mapfile if requested. * gold.cc (class Middle_runner): Add mapfile_ field. Update constructor. Change caller. (queue_initial_tasks): Add mapfile parameter. Change caller. (queue_middle_tasks): Likewise. * gold.h (queue_initial_tasks, queue_middle_tasks): Update declarations. * archive.cc: Include "mapfile.h". (Archive::add_symbols): Add mapfile parameter. Change all callers. Pass mapfile, symbol, and reason to include_member. (Archive::include_all_members): Add mapfile parameter. Change all callers. (Archive::include_member): Add mapfile, sym, and why parameters. Change all callers. Report inclusion to map file. * archive.h: Include "fileread.h". (class Archive): Update declarations. (Archive::file): New const method. (class Add_archive_symbols): Add mapfile_ field. Update constructor. Change all callers. * readsyms.h (class Read_symbols): Likewise. (class Finish_group): Likewise. (class Read_script): Likewise. * common.cc: Include "mapfile.h". (Symbol_table::allocate_commons): Add mapfile parameter. Change all callers. (Symbol_table::do_allocate_commons): Likewise. (Symbol_table::do_allocate_commons_list): Likewise. Report common symbol allocation to mapfile. * common.h (class Allocate_commons_task): Add mapfile_ field. Update constructor. Change all callers. * symtab.h (class Symbol_table): Update declarations. * layout.cc: Include "mapfile.h". (Layout_task_runner::run): Print information to mapfile. (Layout::create_gold_note): Change Output_data_fixed_space to Output_data_zero_fill. (Layout::create_build_id): Likewise. (Layout::print_to_mapfile): New function. * layout.h (class Layout_task_runner): Add mapfile_ field. Update constructor. Change caller. (class Layout): Declare print_to_mapfile. * output.cc (Output_section::Input_section::print_to_mapfile): New function. (Output_section::add_input_section): If producing a map, always add to input_sections_ list. (Output_section::do_print_to_mapfile): New function. (Output_segment::print_sections_to_mapfile): New function. (Output_segment::print_section_list_to_mapfile): New function. * output.h: Include "mapfile.h". (Output_data::print_to_mapfile): New function. (Output_data::do_print_to_mapfile): New virtual function. (Output_segment_headers::do_print_to_mapfile): New function. (Output_file_header::do_print_to_mapfile): New function. (Output_data_const::do_print_to_mapfile): New function. (class Output_data_const_buffer): Add map_name_ field. Update constructor. Change all callers. Add do_print_to_mapfile function. (class Output_data_fixed_space): Likewise. (class Output_data_space): Likewise. (class Output_data_zero_fill): New class. (Output_data_strtab::do_print_to_mapfile): New function. (Output_data_reloc_base::do_print_to_mapfile): New function. (Output_relocatable_relocs::do_print_to_mapfile): New function. (Output_data_group::do_print_to_mapfile): New function. (Output_data_got::do_print_to_mapfile): New function. (Output_data_dynamic::do_print_to_mapfile): New function. (Output_symtab_xindex::do_print_to_mapfile): New function. (class Output_section): Declare do_print_to_mapflie. Declare print_to_mapfile in Input_section. (class Output_segment): Declare new functions. * object.h (Sized_relobj::symbol_count): New function. * script-sections.cc (Output_section_element_dot_assignment::set_section_addresses): Change Output_data_fixed_space to Output_data_zero_fill. (Output_data_expression::do_print_to_mapfile): New function. * script.cc (read_input_script): Add mapfile parameter. Change all callers. * script.h (read_input_script): Update declaration. * ehframe.h (Eh_frame_hdr::do_print_to_mapfile): New function. (Eh_frame::do_print_to_mapfile): New function. * merge.h (Output_merge_data::do_print_to_mapfile): New function. (Output_merge_string::do_print_to_mapfile): New function. * i386.cc (Output_data_plt_i386::do_print_to_mapfile): New function. * sparc.cc (Output_data_plt_sparc::do_print_to_mapfile): New function. * x86_64.cc (Output_data_plt_x86_64::do_print_to_mapfile): New function. * Makefile.am (CCFILES): Add mapfile.cc. (HFILES): Add mapfile.h. * Makefile.in: Rebuild.
405 lines
9.8 KiB
C++
405 lines
9.8 KiB
C++
// mapfile.cc -- map file generation for gold
|
|
|
|
// Copyright 2008 Free Software Foundation, Inc.
|
|
// Written by Ian Lance Taylor <iant@google.com>.
|
|
|
|
// This file is part of gold.
|
|
|
|
// This program is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation; either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
|
// MA 02110-1301, USA.
|
|
|
|
#include "gold.h"
|
|
|
|
#include <cerrno>
|
|
#include <cstdio>
|
|
#include <cstring>
|
|
|
|
#include "archive.h"
|
|
#include "symtab.h"
|
|
#include "output.h"
|
|
#include "mapfile.h"
|
|
|
|
// This file holds the code for printing information to the map file.
|
|
// In general we try to produce pretty much the same format as GNU ld.
|
|
|
|
namespace gold
|
|
{
|
|
|
|
// Mapfile constructor.
|
|
|
|
Mapfile::Mapfile()
|
|
: map_file_(NULL),
|
|
printed_archive_header_(false),
|
|
printed_common_header_(false),
|
|
printed_memory_map_header_(false)
|
|
{
|
|
}
|
|
|
|
// Mapfile destructor.
|
|
|
|
Mapfile::~Mapfile()
|
|
{
|
|
if (this->map_file_ != NULL)
|
|
this->close();
|
|
}
|
|
|
|
// Open the map file.
|
|
|
|
bool
|
|
Mapfile::open(const char* map_filename)
|
|
{
|
|
if (strcmp(map_filename, "-") == 0)
|
|
this->map_file_ = stdout;
|
|
else
|
|
{
|
|
this->map_file_ = ::fopen(map_filename, "w");
|
|
if (this->map_file_ == NULL)
|
|
{
|
|
gold_error(_("cannot open map file %s: %s"), map_filename,
|
|
strerror(errno));
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Close the map file.
|
|
|
|
void
|
|
Mapfile::close()
|
|
{
|
|
if (fclose(this->map_file_) != 0)
|
|
gold_error(_("cannot close map file: %s"), strerror(errno));
|
|
this->map_file_ = NULL;
|
|
}
|
|
|
|
// Advance to a column.
|
|
|
|
void
|
|
Mapfile::advance_to_column(size_t from, size_t to)
|
|
{
|
|
if (from >= to - 1)
|
|
{
|
|
putc('\n', this->map_file_);
|
|
from = 0;
|
|
}
|
|
while (from < to)
|
|
{
|
|
putc(' ', this->map_file_);
|
|
++from;
|
|
}
|
|
}
|
|
|
|
// Report about including a member from an archive.
|
|
|
|
void
|
|
Mapfile::report_include_archive_member(const Archive* archive,
|
|
const std::string& member_name,
|
|
const Symbol* sym, const char* why)
|
|
{
|
|
// We print a header before the list of archive members, mainly for
|
|
// GNU ld compatibility.
|
|
if (!this->printed_archive_header_)
|
|
{
|
|
fprintf(this->map_file_,
|
|
_("Archive member included because of file (symbol)\n\n"));
|
|
this->printed_archive_header_ = true;
|
|
}
|
|
|
|
fprintf(this->map_file_, "%s(%s)", archive->file().filename().c_str(),
|
|
member_name.c_str());
|
|
|
|
size_t len = (archive->file().filename().length()
|
|
+ member_name.length()
|
|
+ 2);
|
|
this->advance_to_column(len, 30);
|
|
|
|
if (sym == NULL)
|
|
fprintf(this->map_file_, "%s", why);
|
|
else
|
|
{
|
|
switch (sym->source())
|
|
{
|
|
case Symbol::FROM_OBJECT:
|
|
fprintf(this->map_file_, "%s", sym->object()->name().c_str());
|
|
break;
|
|
|
|
case Symbol::IS_UNDEFINED:
|
|
fprintf(this->map_file_, "-u");
|
|
break;
|
|
|
|
default:
|
|
case Symbol::IN_OUTPUT_DATA:
|
|
case Symbol::IN_OUTPUT_SEGMENT:
|
|
case Symbol::IS_CONSTANT:
|
|
// We should only see an undefined symbol here.
|
|
gold_unreachable();
|
|
}
|
|
|
|
fprintf(this->map_file_, " (%s)", sym->name());
|
|
}
|
|
|
|
putc('\n', this->map_file_);
|
|
}
|
|
|
|
// Report allocating a common symbol.
|
|
|
|
void
|
|
Mapfile::report_allocate_common(const Symbol* sym, uint64_t symsize)
|
|
{
|
|
if (!this->printed_common_header_)
|
|
{
|
|
fprintf(this->map_file_, _("\nAllocating common symbols\n"));
|
|
fprintf(this->map_file_,
|
|
_("Common symbol size file\n\n"));
|
|
this->printed_common_header_ = true;
|
|
}
|
|
|
|
std::string demangled_name = sym->demangled_name();
|
|
fprintf(this->map_file_, "%s", demangled_name.c_str());
|
|
|
|
this->advance_to_column(demangled_name.length(), 20);
|
|
|
|
char buf[50];
|
|
snprintf(buf, sizeof buf, "0x%llx", static_cast<unsigned long long>(symsize));
|
|
fprintf(this->map_file_, "%s", buf);
|
|
|
|
size_t len = strlen(buf);
|
|
while (len < 18)
|
|
{
|
|
putc(' ', this->map_file_);
|
|
++len;
|
|
}
|
|
|
|
fprintf(this->map_file_, "%s\n", sym->object()->name().c_str());
|
|
}
|
|
|
|
// The space we make for a section name.
|
|
|
|
const size_t Mapfile::section_name_map_length = 16;
|
|
|
|
// Print the memory map header if necessary.
|
|
|
|
void
|
|
Mapfile::print_memory_map_header()
|
|
{
|
|
if (!this->printed_memory_map_header_)
|
|
{
|
|
fprintf(this->map_file_, _("\nMemory map\n\n"));
|
|
this->printed_memory_map_header_ = true;
|
|
}
|
|
}
|
|
|
|
// Print the symbols associated with an input section.
|
|
|
|
template<int size, bool big_endian>
|
|
void
|
|
Mapfile::print_input_section_symbols(
|
|
const Sized_relobj<size, big_endian>* relobj,
|
|
unsigned int shndx)
|
|
{
|
|
unsigned int symcount = relobj->symbol_count();
|
|
for (unsigned int i = relobj->local_symbol_count(); i < symcount; ++i)
|
|
{
|
|
const Symbol* sym = relobj->global_symbol(i);
|
|
bool is_ordinary;
|
|
if (sym != NULL
|
|
&& sym->source() == Symbol::FROM_OBJECT
|
|
&& sym->object() == relobj
|
|
&& sym->shndx(&is_ordinary) == shndx
|
|
&& is_ordinary
|
|
&& sym->is_defined())
|
|
{
|
|
for (size_t i = 0; i < Mapfile::section_name_map_length; ++i)
|
|
putc(' ', this->map_file_);
|
|
const Sized_symbol<size>* ssym =
|
|
static_cast<const Sized_symbol<size>*>(sym);
|
|
fprintf(this->map_file_,
|
|
"0x%0*llx %s\n",
|
|
size / 4,
|
|
static_cast<unsigned long long>(ssym->value()),
|
|
sym->demangled_name().c_str());
|
|
}
|
|
}
|
|
}
|
|
|
|
// Print an input section.
|
|
|
|
void
|
|
Mapfile::print_input_section(Relobj* relobj, unsigned int shndx)
|
|
{
|
|
putc(' ', this->map_file_);
|
|
|
|
std::string name = relobj->section_name(shndx);
|
|
fprintf(this->map_file_, "%s", name.c_str());
|
|
|
|
this->advance_to_column(name.length() + 1, Mapfile::section_name_map_length);
|
|
|
|
Output_section* os;
|
|
uint64_t addr;
|
|
if (!relobj->is_section_included(shndx))
|
|
{
|
|
os = NULL;
|
|
addr = 0;
|
|
}
|
|
else
|
|
{
|
|
section_offset_type offset;
|
|
os = relobj->output_section(shndx, &offset);
|
|
if (offset == -1)
|
|
addr = ~0ULL;
|
|
else
|
|
addr = os->address() + offset;
|
|
}
|
|
|
|
char sizebuf[50];
|
|
snprintf(sizebuf, sizeof sizebuf, "0x%llx",
|
|
static_cast<unsigned long long>(relobj->section_size(shndx)));
|
|
|
|
fprintf(this->map_file_, "0x%0*llx %10s %s\n",
|
|
parameters->target().get_size() / 4,
|
|
static_cast<unsigned long long>(addr), sizebuf,
|
|
relobj->name().c_str());
|
|
|
|
if (os != NULL)
|
|
{
|
|
switch (parameters->size_and_endianness())
|
|
{
|
|
#ifdef HAVE_TARGET_32_LITTLE
|
|
case Parameters::TARGET_32_LITTLE:
|
|
{
|
|
const Sized_relobj<32, false>* sized_relobj =
|
|
static_cast<Sized_relobj<32, false>*>(relobj);
|
|
this->print_input_section_symbols(sized_relobj, shndx);
|
|
}
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_TARGET_32_BIG
|
|
case Parameters::TARGET_32_BIG:
|
|
{
|
|
const Sized_relobj<32, true>* sized_relobj =
|
|
static_cast<Sized_relobj<32, true>*>(relobj);
|
|
this->print_input_section_symbols(sized_relobj, shndx);
|
|
}
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_TARGET_64_LITTLE
|
|
case Parameters::TARGET_64_LITTLE:
|
|
{
|
|
const Sized_relobj<64, false>* sized_relobj =
|
|
static_cast<Sized_relobj<64, false>*>(relobj);
|
|
this->print_input_section_symbols(sized_relobj, shndx);
|
|
}
|
|
break;
|
|
#endif
|
|
#ifdef HAVE_TARGET_64_BIG
|
|
case Parameters::TARGET_64_BIG:
|
|
{
|
|
const Sized_relobj<64, true>* sized_relobj =
|
|
static_cast<Sized_relobj<64, true>*>(relobj);
|
|
this->print_input_section_symbols(sized_relobj, shndx);
|
|
}
|
|
break;
|
|
#endif
|
|
default:
|
|
gold_unreachable();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Print an Output_section_data. This is printed to look like an
|
|
// input section.
|
|
|
|
void
|
|
Mapfile::print_output_data(const Output_data* od, const char* name)
|
|
{
|
|
this->print_memory_map_header();
|
|
|
|
putc(' ', this->map_file_);
|
|
|
|
fprintf(this->map_file_, "%s", name);
|
|
|
|
this->advance_to_column(strlen(name) + 1, Mapfile::section_name_map_length);
|
|
|
|
char sizebuf[50];
|
|
snprintf(sizebuf, sizeof sizebuf, "0x%llx",
|
|
static_cast<unsigned long long>(od->data_size()));
|
|
|
|
fprintf(this->map_file_, "0x%0*llx %10s\n",
|
|
parameters->target().get_size() / 4,
|
|
static_cast<unsigned long long>(od->address()),
|
|
sizebuf);
|
|
}
|
|
|
|
// Print the discarded input sections.
|
|
|
|
void
|
|
Mapfile::print_discarded_sections(const Input_objects* input_objects)
|
|
{
|
|
bool printed_header = false;
|
|
for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
|
|
p != input_objects->relobj_end();
|
|
++p)
|
|
{
|
|
Relobj* relobj = *p;
|
|
unsigned int shnum = relobj->shnum();
|
|
for (unsigned int i = 0; i < shnum; ++i)
|
|
{
|
|
unsigned int sh_type = relobj->section_type(i);
|
|
if ((sh_type == elfcpp::SHT_PROGBITS
|
|
|| sh_type == elfcpp::SHT_NOBITS
|
|
|| sh_type == elfcpp::SHT_GROUP)
|
|
&& !relobj->is_section_included(i))
|
|
{
|
|
if (!printed_header)
|
|
{
|
|
fprintf(this->map_file_, _("\nDiscarded input sections\n\n"));
|
|
printed_header = true;
|
|
}
|
|
|
|
this->print_input_section(relobj, i);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Print an output section.
|
|
|
|
void
|
|
Mapfile::print_output_section(const Output_section* os)
|
|
{
|
|
this->print_memory_map_header();
|
|
|
|
fprintf(this->map_file_, "\n%s", os->name());
|
|
|
|
this->advance_to_column(strlen(os->name()), Mapfile::section_name_map_length);
|
|
|
|
char sizebuf[50];
|
|
snprintf(sizebuf, sizeof sizebuf, "0x%llx",
|
|
static_cast<unsigned long long>(os->data_size()));
|
|
|
|
fprintf(this->map_file_, "0x%0*llx %10s",
|
|
parameters->target().get_size() / 4,
|
|
static_cast<unsigned long long>(os->address()), sizebuf);
|
|
|
|
if (os->has_load_address())
|
|
fprintf(this->map_file_, " load address 0x%-*llx",
|
|
parameters->target().get_size() / 4,
|
|
static_cast<unsigned long long>(os->load_address()));
|
|
|
|
putc('\n', this->map_file_);
|
|
}
|
|
|
|
} // End namespace gold.
|