// symtab.cc -- the gold symbol table
-// Copyright (C) 2006-2014 Free Software Foundation, Inc.
+// Copyright (C) 2006-2015 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
// Return true if this symbol should be added to the dynamic symbol
// table.
-inline bool
+bool
Symbol::should_add_dynsym_entry(Symbol_table* symtab) const
{
// If the symbol is only present on plugin files, the plugin decided we
}
// If exporting all symbols or building a shared library,
+ // or the symbol should be globally unique (GNU_UNIQUE),
// and the symbol is defined in a regular object and is
// externally visible, we need to add it.
- if ((parameters->options().export_dynamic() || parameters->options().shared())
+ if ((parameters->options().export_dynamic()
+ || parameters->options().shared()
+ || (parameters->options().gnu_unique()
+ && this->binding() == elfcpp::STB_GNU_UNIQUE))
&& !this->is_from_dynobj()
&& !this->is_undefined()
&& this->is_externally_visible())
Symbol::final_value_is_known() const
{
// If we are not generating an executable, then no final values are
- // known, since they will change at runtime.
- if (parameters->options().output_is_position_independent()
- || parameters->options().relocatable())
+ // known, since they will change at runtime, with the exception of
+ // TLS symbols in a position-independent executable.
+ if ((parameters->options().output_is_position_independent()
+ || parameters->options().relocatable())
+ && !(this->type() == elfcpp::STT_TLS
+ && parameters->options().pie()))
return false;
// If the symbol is not from an object file, and is not undefined,
}
}
+// Set the symbol's output segment. This is used for pre-defined
+// symbols whose segments aren't known until after layout is done
+// (e.g., __ehdr_start).
+
+void
+Symbol::set_output_segment(Output_segment* os, Segment_offset_base base)
+{
+ gold_assert(this->is_predefined_);
+ this->source_ = IN_OUTPUT_SEGMENT;
+ this->u_.in_output_segment.output_segment = os;
+ this->u_.in_output_segment.offset_base = base;
+}
+
+// Set the symbol to undefined. This is used for pre-defined
+// symbols whose segments aren't known until after layout is done
+// (e.g., __ehdr_start).
+
+void
+Symbol::set_undefined()
+{
+ this->source_ = IS_UNDEFINED;
+ this->is_predefined_ = false;
+}
+
// Class Symbol_table.
Symbol_table::Symbol_table(unsigned int count,
}
bool
-Symbol_table::is_section_folded(Object* obj, unsigned int shndx) const
+Symbol_table::is_section_folded(Relobj* obj, unsigned int shndx) const
{
return (parameters->options().icf_enabled()
&& this->icf_->is_section_folded(obj, shndx));
// Add the object and section to the work list.
bool is_ordinary;
unsigned int shndx = sym->shndx(&is_ordinary);
- if (is_ordinary && shndx != elfcpp::SHN_UNDEF)
+ if (is_ordinary && shndx != elfcpp::SHN_UNDEF && !sym->object()->is_dynamic())
{
gold_assert(this->gc_!= NULL);
- this->gc_->worklist().push(Section_id(sym->object(), shndx));
+ Relobj* relobj = static_cast<Relobj*>(sym->object());
+ this->gc_->worklist().push_back(Section_id(relobj, shndx));
}
parameters->target().gc_mark_symbol(this, sym);
}
gold_assert(ret != NULL);
was_undefined = ret->is_undefined();
- was_common = ret->is_common();
+ // Commons from plugins are just placeholders.
+ was_common = ret->is_common() && ret->object()->pluginobj() == NULL;
this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, object,
version);
ret = this->get_sized_symbol<size>(insdefault.first->second);
was_undefined = ret->is_undefined();
- was_common = ret->is_common();
+ // Commons from plugins are just placeholders.
+ was_common = ret->is_common() && ret->object()->pluginobj() == NULL;
this->resolve(ret, sym, st_shndx, is_ordinary, orig_st_shndx, object,
version);
}
// Keep track of common symbols, to speed up common symbol
- // allocation.
- if (!was_common && ret->is_common())
+ // allocation. Don't record commons from plugin objects;
+ // we need to wait until we see the real symbol in the
+ // replacement file.
+ if (!was_common && ret->is_common() && ret->object()->pluginobj() == NULL)
{
if (ret->type() == elfcpp::STT_TLS)
this->tls_commons_.push_back(ret);
const char* name = sym_names + st_name;
+ if (strcmp (name, "__gnu_lto_slim") == 0)
+ gold_info(_("%s: plugin needed to handle lto object"),
+ relobj->name().c_str());
+
bool is_ordinary;
unsigned int st_shndx = relobj->adjust_sym_shndx(i + symndx_offset,
sym.get_st_shndx(),
typename elfcpp::Elf_types<size>::Elf_Addr dynsym_value = sym_value;
elfcpp::STB binding = sym->binding();
+ // If --weak-unresolved-symbols is set, change binding of unresolved
+ // global symbols to STB_WEAK.
+ if (parameters->options().weak_unresolved_symbols()
+ && binding == elfcpp::STB_GLOBAL
+ && sym->is_undefined())
+ binding = elfcpp::STB_WEAK;
+
// If --no-gnu-unique is set, change STB_GNU_UNIQUE to STB_GLOBAL.
if (binding == elfcpp::STB_GNU_UNIQUE
&& !parameters->options().gnu_unique())
unsigned char* pd = dynamic_view + (dynsym_index * sym_size);
this->sized_write_symbol<size, big_endian>(sym, dynsym_value, shndx,
binding, dynpool, pd);
+ // Allow a target to adjust dynamic symbol value.
+ parameters->target().adjust_dyn_symbol(sym, pd);
}
}
first_object_name = locs->object->name();
first_object_linenos = this->linenos_from_loc(task, *locs);
}
+ if (first_object_linenos.empty())
+ continue;
// Sort by Odr_violation_compare to make std::set_intersection work.
+ std::string first_object_canonical_result = first_object_linenos.back();
std::sort(first_object_linenos.begin(), first_object_linenos.end(),
Odr_violation_compare());
if (linenos.empty())
continue;
// Sort by Odr_violation_compare to make std::set_intersection work.
+ gold_assert(!linenos.empty());
+ std::string second_object_canonical_result = linenos.back();
std::sort(linenos.begin(), linenos.end(), Odr_violation_compare());
Check_intersection intersection_result =
// which may not be the location we expect to intersect
// with another definition. We could print the whole
// set of locations, but that seems too verbose.
- gold_assert(!first_object_linenos.empty());
- gold_assert(!linenos.empty());
fprintf(stderr, _(" %s from %s\n"),
- first_object_linenos[0].c_str(),
+ first_object_canonical_result.c_str(),
first_object_name.c_str());
fprintf(stderr, _(" %s from %s\n"),
- linenos[0].c_str(),
+ second_object_canonical_result.c_str(),
locs->object->name().c_str());
// Only print one broken pair, to avoid needing to
// compare against a list of the disjoint definition
elfcpp::Elf_types<64>::Elf_Addr value);
#endif
+#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
+template
+void
+Sized_symbol<32>::init_output_data(const char* name, const char* version,
+ Output_data* od, Value_type value,
+ Size_type symsize, elfcpp::STT type,
+ elfcpp::STB binding,
+ elfcpp::STV visibility,
+ unsigned char nonvis,
+ bool offset_is_from_end,
+ bool is_predefined);
+#endif
+
+#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
+template
+void
+Sized_symbol<64>::init_output_data(const char* name, const char* version,
+ Output_data* od, Value_type value,
+ Size_type symsize, elfcpp::STT type,
+ elfcpp::STB binding,
+ elfcpp::STV visibility,
+ unsigned char nonvis,
+ bool offset_is_from_end,
+ bool is_predefined);
+#endif
+
#ifdef HAVE_TARGET_32_LITTLE
template
void
projects / deliverable / binutils-gdb.git / blobdiff