// object.cc -- support for an object file for linking in gold
-// Copyright (C) 2006-2018 Free Software Foundation, Inc.
+// Copyright (C) 2006-2022 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
unsigned int nsyms = this->local_symbol_count();
for (unsigned int i = 0; i < nsyms; i++)
{
- Local_got_entry_key key(i, 0);
+ Local_got_entry_key key(i);
Local_got_offsets::const_iterator p = this->local_got_offsets_.find(key);
if (p != this->local_got_offsets_.end())
{
const elfcpp::Ehdr<size, big_endian>& ehdr)
: Sized_relobj<size, big_endian>(name, input_file, offset),
elf_file_(this, ehdr),
+ osabi_(ehdr.get_ei_osabi()),
+ e_type_(ehdr.get_e_type()),
symtab_shndx_(-1U),
local_symbol_count_(0),
output_local_symbol_count_(0),
deferred_layout_relocs_(),
output_views_(NULL)
{
- this->e_type_ = ehdr.get_e_type();
}
template<int size, bool big_endian>
const unsigned char* contents =
obj->section_contents(i, &len, false);
uint64_t uncompressed_size;
+ Compressed_section_info info;
if (is_zcompressed)
{
// Skip over the ".zdebug" prefix.
name += 7;
uncompressed_size = get_uncompressed_size(contents, len);
+ info.addralign = shdr.get_sh_addralign();
}
else
{
name += 6;
elfcpp::Chdr<size, big_endian> chdr(contents);
uncompressed_size = chdr.get_ch_size();
+ info.addralign = chdr.get_ch_addralign();
}
- Compressed_section_info info;
info.size = convert_to_section_size_type(uncompressed_size);
info.flag = shdr.get_sh_flags();
info.contents = NULL;
Layout* layout,
unsigned int shndx)
{
+ // We ignore Gnu property sections on incremental links.
+ if (parameters->incremental())
+ return;
+
section_size_type contents_len;
const unsigned char* pcontents = this->section_contents(shndx,
&contents_len,
}
}
+// This a copy of lto_section defined in GCC (lto-streamer.h)
+
+struct lto_section
+{
+ int16_t major_version;
+ int16_t minor_version;
+ unsigned char slim_object;
+
+ /* Flags is a private field that is not defined publicly. */
+ uint16_t flags;
+};
+
// Lay out the input sections. We walk through the sections and check
// whether they should be included in the link. If they should, we
// pass them to the Layout object, which will return an output section
if (this->is_section_name_included(name)
|| layout->keep_input_section (this, name)
|| sh_type == elfcpp::SHT_INIT_ARRAY
- || sh_type == elfcpp::SHT_FINI_ARRAY)
+ || sh_type == elfcpp::SHT_FINI_ARRAY
+ || this->osabi().has_shf_retain(shdr.get_sh_flags()))
{
symtab->gc()->worklist().push_back(Section_id(this, i));
}
out_section_offsets[i] = invalid_address;
}
else if (this->is_deferred_layout())
- this->deferred_layout_.push_back(
- Deferred_layout(i, name, sh_type, pshdrs,
- reloc_shndx[i], reloc_type[i]));
+ {
+ out_sections[i] = reinterpret_cast<Output_section*>(2);
+ out_section_offsets[i] = invalid_address;
+ this->deferred_layout_.push_back(
+ Deferred_layout(i, name, sh_type, pshdrs,
+ reloc_shndx[i], reloc_type[i]));
+ }
else
eh_frame_sections.push_back(i);
continue;
debug_types_sections.push_back(i);
}
}
+
+ /* GCC uses .gnu.lto_.lto.<some_hash> as a LTO bytecode information
+ section. */
+ const char *lto_section_name = ".gnu.lto_.lto.";
+ if (strncmp (name, lto_section_name, strlen (lto_section_name)) == 0)
+ {
+ section_size_type contents_len;
+ const unsigned char* pcontents
+ = this->section_contents(i, &contents_len, false);
+ if (contents_len >= sizeof(lto_section))
+ {
+ const lto_section* lsection
+ = reinterpret_cast<const lto_section*>(pcontents);
+ if (lsection->slim_object)
+ layout->set_lto_slim_object();
+ }
+ }
}
if (!is_pass_two)
- layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags, this);
+ {
+ layout->merge_gnu_properties(this);
+ layout->layout_gnu_stack(seen_gnu_stack, gnu_stack_flags, this);
+ }
// Handle the .eh_frame sections after the other sections.
gold_assert(!is_pass_one || eh_frame_sections.empty());
void
Sized_relobj_file<size, big_endian>::do_add_symbols(Symbol_table* symtab,
Read_symbols_data* sd,
- Layout*)
+ Layout* layout)
{
if (sd->symbols == NULL)
{
this->symbols_.resize(symcount);
+ if (!parameters->options().relocatable()
+ && layout->is_lto_slim_object ())
+ gold_info(_("%s: plugin needed to handle lto object"),
+ this->name().c_str());
+
const char* sym_names =
reinterpret_cast<const char*>(sd->symbol_names->data());
symtab->add_from_relobj(this,
lv->set_output_symtab_index(index);
++index;
}
+ if (lv->is_ifunc_symbol()
+ && (lv->has_output_symtab_entry()
+ || lv->needs_output_dynsym_entry()))
+ symtab->set_has_gnu_output();
break;
case CFLV_DISCARDED:
case CFLV_ERROR:
{
// The kept section is a linkonce section.
if (sh_size == kept_section->linkonce_size())
- found = true;
+ {
+ kept_shndx = kept_section->shndx();
+ found = true;
+ }
}
else
{
+ uint64_t kept_size = 0;
if (is_comdat)
{
// Find the corresponding kept section.
// Since we're using this mapping for relocation processing,
// we don't want to match sections unless they have the same
// size.
- uint64_t kept_size;
if (kept_section->find_comdat_section(section_name, &kept_shndx,
&kept_size))
{
found = true;
}
}
- else
+ if (!found)
{
- uint64_t kept_size;
if (kept_section->find_single_comdat_section(&kept_shndx,
&kept_size)
&& sh_size == kept_size)
Object::decompressed_section_contents(
unsigned int shndx,
section_size_type* plen,
- bool* is_new)
+ bool* is_new,
+ uint64_t* palign)
{
section_size_type buffer_size;
const unsigned char* buffer = this->do_section_contents(shndx, &buffer_size,
{
*plen = uncompressed_size;
*is_new = false;
+ if (palign != NULL)
+ *palign = p->second.addralign;
return p->second.contents;
}
// once in this pass.
*plen = uncompressed_size;
*is_new = true;
+ if (palign != NULL)
+ *palign = p->second.addralign;
return uncompressed_data;
}
{
// Print the filename if the -t/--trace option is selected.
if (parameters->options().trace())
- gold_info("%s", obj->name().c_str());
+ gold_trace("%s", obj->name().c_str());
if (!obj->is_dynamic())
this->relobj_list_.push_back(static_cast<Relobj*>(obj));
{
Target* target = select_target(input_file, offset,
ehdr.get_e_machine(), size, big_endian,
- ehdr.get_e_ident()[elfcpp::EI_OSABI],
- ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
+ ehdr.get_ei_osabi(),
+ ehdr.get_ei_abiversion());
if (target == NULL)
gold_fatal(_("%s: unsupported ELF machine number %d"),
name.c_str(), ehdr.get_e_machine());
projects / binutils-gdb.git / blobdiff