// symtab.cc -- the gold symbol table
-// Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
// Written by Ian Lance Taylor <iant@google.com>.
// This file is part of gold.
{
}
-// The hash function. The key values are Stringpool keys.
-
-inline size_t
-Symbol_table::Symbol_table_hash::operator()(const Symbol_table_key& key) const
-{
- return key.first ^ key.second;
-}
-
// The symbol table key equality function. This is called with
// Stringpool keys.
{
const char* name = p->c_str();
Symbol* sym = this->lookup(name);
- gold_assert (sym != NULL);
+ gold_assert(sym != NULL);
if (sym->source() == Symbol::FROM_OBJECT
&& !sym->object()->is_dynamic())
{
if (sym->in_dyn() && sym->source() == Symbol::FROM_OBJECT
&& !sym->object()->is_dynamic())
{
- Relobj *obj = static_cast<Relobj*>(sym->object());
+ Relobj* obj = static_cast<Relobj*>(sym->object());
bool is_ordinary;
unsigned int shndx = sym->shndx(&is_ordinary);
if (is_ordinary && shndx != elfcpp::SHN_UNDEF)
template<int size, bool big_endian>
Sized_symbol<size>*
Symbol_table::add_from_object(Object* object,
- const char *name,
+ const char* name,
Stringpool::Key name_key,
- const char *version,
+ const char* version,
Stringpool::Key version_key,
bool is_default_version,
const elfcpp::Sym<size, big_endian>& sym,
// Record every time we see a new undefined symbol, to speed up
// archive groups.
if (!was_undefined && ret->is_undefined())
- ++this->saw_undefined_;
+ {
+ ++this->saw_undefined_;
+ if (parameters->options().has_plugins())
+ parameters->options().plugins()->new_undefined_symbol(ret);
+ }
// Keep track of common symbols, to speed up common symbol
// allocation.
const char* sym_names,
size_t sym_name_size,
typename Sized_relobj<size, big_endian>::Symbols* sympointers,
- size_t *defined)
+ size_t* defined)
{
*defined = 0;
Symbol_table::define_special_symbol(const char** pname, const char** pversion,
bool only_if_ref,
Sized_symbol<size>** poldsym,
- bool *resolve_oldsym)
+ bool* resolve_oldsym)
{
*resolve_oldsym = false;
off_t
Symbol_table::finalize(off_t off, off_t dynoff, size_t dyn_global_index,
size_t dyncount, Stringpool* pool,
- unsigned int *plocal_symcount)
+ unsigned int* plocal_symcount)
{
off_t ret;
shndx = elfcpp::SHN_UNDEF;
if (sym->is_undef_binding_weak())
binding = elfcpp::STB_WEAK;
+ else
+ binding = elfcpp::STB_GLOBAL;
}
else if (symobj->pluginobj() != NULL)
shndx = elfcpp::SHN_UNDEF;
// Write out a section symbol. Return the update offset.
void
-Symbol_table::write_section_symbol(const Output_section *os,
+Symbol_table::write_section_symbol(const Output_section* os,
Output_symtab_xindex* symtab_xindex,
Output_file* of,
off_t offset) const
// We check for ODR violations by looking for symbols with the same
// name for which the debugging information reports that they were
// defined in different source locations. When comparing the source
-// location, we consider instances with the same base filename and
-// line number to be the same. This is because different object
-// files/shared libraries can include the same header file using
-// different paths, and we don't want to report an ODR violation in
-// that case.
+// location, we consider instances with the same base filename to be
+// the same. This is because different object files/shared libraries
+// can include the same header file using different paths, and
+// different optimization settings can make the line number appear to
+// be a couple lines off, and we don't want to report an ODR violation
+// in those cases.
// This struct is used to compare line information, as returned by
// Dwarf_line_info::one_addr2line. It implements a < comparison
bool
operator()(const std::string& s1, const std::string& s2) const
{
- std::string::size_type pos1 = s1.rfind('/');
- std::string::size_type pos2 = s2.rfind('/');
- if (pos1 == std::string::npos
- || pos2 == std::string::npos)
- return s1 < s2;
- return s1.compare(pos1, std::string::npos,
- s2, pos2, std::string::npos) < 0;
+ // Inputs should be of the form "dirname/filename:linenum" where
+ // "dirname/" is optional. We want to compare just the filename.
+
+ // Find the last '/' and ':' in each string.
+ std::string::size_type s1begin = s1.rfind('/');
+ std::string::size_type s2begin = s2.rfind('/');
+ std::string::size_type s1end = s1.rfind(':');
+ std::string::size_type s2end = s2.rfind(':');
+ // If there was no '/' in a string, start at the beginning.
+ if (s1begin == std::string::npos)
+ s1begin = 0;
+ if (s2begin == std::string::npos)
+ s2begin = 0;
+ // If the ':' appeared in the directory name, compare to the end
+ // of the string.
+ if (s1end < s1begin)
+ s1end = s1.size();
+ if (s2end < s2begin)
+ s2end = s2.size();
+ // Compare takes lengths, not end indices.
+ return s1.compare(s1begin, s1end - s1begin,
+ s2, s2begin, s2end - s2begin) < 0;
}
};