weak when resolving to a dynamic def.
(Symbol_table::should_override): Add adjust_dyndef flag; set it
for weak undef/dynamic def cases. Adjust callers.
* symtab.cc (Symbol::init_fields): Initialize undef_binding_set_ and
undef_binding_weak_.
(Symbol_table::sized_write_globals): Adjust symbol binding.
(Symbol_table::sized_write_symbol): Add binding parameter.
* symtab.h (Symbol::set_undef_binding): New method.
(Symbol::is_undef_binding_weak): New method.
(Symbol::undef_binding_set_, Symbol::undef_binding_weak_): New members.
(Symbol_table::should_override): Add new parameter.
(Symbol_table::sized_write_symbol): Add new parameter.
* testsuite/weak_undef_file1.cc: Add new test case.
* testsuite/weak_undef_file2.cc: Fix header comment.
* testsuite/weak_undef_test.cc: Add new test case.
+2010-07-08 Cary Coutant <ccoutant@google.com>
+
+ * resolve.cc (Symbol_table::resolve): Remember whether undef was
+ weak when resolving to a dynamic def.
+ (Symbol_table::should_override): Add adjust_dyndef flag; set it
+ for weak undef/dynamic def cases. Adjust callers.
+ * symtab.cc (Symbol::init_fields): Initialize undef_binding_set_ and
+ undef_binding_weak_.
+ (Symbol_table::sized_write_globals): Adjust symbol binding.
+ (Symbol_table::sized_write_symbol): Add binding parameter.
+ * symtab.h (Symbol::set_undef_binding): New method.
+ (Symbol::is_undef_binding_weak): New method.
+ (Symbol::undef_binding_set_, Symbol::undef_binding_weak_): New members.
+ (Symbol_table::should_override): Add new parameter.
+ (Symbol_table::sized_write_symbol): Add new parameter.
+
+ * testsuite/weak_undef_file1.cc: Add new test case.
+ * testsuite/weak_undef_file2.cc: Fix header comment.
+ * testsuite/weak_undef_test.cc: Add new test case.
+
2010-06-29 Doug Kwan <dougkwan@google.com>
* arm-reloc-property.cc (Arm_reloc_property::Arm_reloc_property):
sym.get_st_type());
bool adjust_common_sizes;
+ bool adjust_dyndef;
typename Sized_symbol<size>::Size_type tosize = to->symsize();
if (Symbol_table::should_override(to, frombits, OBJECT, object,
- &adjust_common_sizes))
+ &adjust_common_sizes,
+ &adjust_dyndef))
{
+ elfcpp::STB tobinding = to->binding();
this->override(to, sym, st_shndx, is_ordinary, object, version);
if (adjust_common_sizes && tosize > to->symsize())
to->set_symsize(tosize);
+ if (adjust_dyndef)
+ {
+ // We are overriding an UNDEF or WEAK UNDEF with a DYN DEF.
+ // Remember which kind of UNDEF it was for future reference.
+ to->set_undef_binding(tobinding);
+ }
}
else
{
if (adjust_common_sizes && sym.get_st_size() > tosize)
to->set_symsize(sym.get_st_size());
+ if (adjust_dyndef)
+ {
+ // We are keeping a DYN DEF after seeing an UNDEF or WEAK UNDEF.
+ // Remember which kind of UNDEF it was.
+ to->set_undef_binding(sym.get_st_bind());
+ }
// The ELF ABI says that even for a reference to a symbol we
// merge the visibility.
to->override_visibility(sym.get_st_visibility());
bool
Symbol_table::should_override(const Symbol* to, unsigned int frombits,
Defined defined, Object* object,
- bool* adjust_common_sizes)
+ bool* adjust_common_sizes,
+ bool* adjust_dyndef)
{
*adjust_common_sizes = false;
+ *adjust_dyndef = false;
unsigned int tobits;
if (to->source() == Symbol::IS_UNDEFINED)
return false;
case UNDEF * 16 + DYN_DEF:
- case WEAK_UNDEF * 16 + DYN_DEF:
case DYN_UNDEF * 16 + DYN_DEF:
case DYN_WEAK_UNDEF * 16 + DYN_DEF:
// Use a dynamic definition if we have a reference.
return true;
+ case WEAK_UNDEF * 16 + DYN_DEF:
+ // When overriding a weak undef by a dynamic definition,
+ // we need to remember that the original undef was weak.
+ *adjust_dyndef = true;
+ return true;
+
case COMMON * 16 + DYN_DEF:
case WEAK_COMMON * 16 + DYN_DEF:
case DYN_COMMON * 16 + DYN_DEF:
return false;
case UNDEF * 16 + DYN_WEAK_DEF:
- case WEAK_UNDEF * 16 + DYN_WEAK_DEF:
case DYN_UNDEF * 16 + DYN_WEAK_DEF:
case DYN_WEAK_UNDEF * 16 + DYN_WEAK_DEF:
// Use a weak dynamic definition if we have a reference.
return true;
+ case WEAK_UNDEF * 16 + DYN_WEAK_DEF:
+ // When overriding a weak undef by a dynamic definition,
+ // we need to remember that the original undef was weak.
+ *adjust_dyndef = true;
+ return true;
+
case COMMON * 16 + DYN_WEAK_DEF:
case WEAK_COMMON * 16 + DYN_WEAK_DEF:
case DYN_COMMON * 16 + DYN_WEAK_DEF:
case DEF * 16 + UNDEF:
case WEAK_DEF * 16 + UNDEF:
- case DYN_DEF * 16 + UNDEF:
- case DYN_WEAK_DEF * 16 + UNDEF:
case UNDEF * 16 + UNDEF:
// A new undefined reference tells us nothing.
return false;
+ case DYN_DEF * 16 + UNDEF:
+ case DYN_WEAK_DEF * 16 + UNDEF:
+ // For a dynamic def, we need to remember which kind of undef we see.
+ *adjust_dyndef = true;
+ return false;
+
case WEAK_UNDEF * 16 + UNDEF:
case DYN_UNDEF * 16 + UNDEF:
case DYN_WEAK_UNDEF * 16 + UNDEF:
case DEF * 16 + WEAK_UNDEF:
case WEAK_DEF * 16 + WEAK_UNDEF:
- case DYN_DEF * 16 + WEAK_UNDEF:
- case DYN_WEAK_DEF * 16 + WEAK_UNDEF:
case UNDEF * 16 + WEAK_UNDEF:
case WEAK_UNDEF * 16 + WEAK_UNDEF:
case DYN_UNDEF * 16 + WEAK_UNDEF:
// A new weak undefined reference tells us nothing.
return false;
+ case DYN_DEF * 16 + WEAK_UNDEF:
+ case DYN_WEAK_DEF * 16 + WEAK_UNDEF:
+ // For a dynamic def, we need to remember which kind of undef we see.
+ *adjust_dyndef = true;
+ return false;
+
case DEF * 16 + DYN_UNDEF:
case WEAK_DEF * 16 + DYN_UNDEF:
case DYN_DEF * 16 + DYN_UNDEF:
Symbol_table::should_override_with_special(const Symbol* to, Defined defined)
{
bool adjust_common_sizes;
+ bool adjust_dyn_def;
unsigned int frombits = global_flag | regular_flag | def_flag;
bool ret = Symbol_table::should_override(to, frombits, defined, NULL,
- &adjust_common_sizes);
- gold_assert(!adjust_common_sizes);
+ &adjust_common_sizes,
+ &adjust_dyn_def);
+ gold_assert(!adjust_common_sizes && !adjust_dyn_def);
return ret;
}
this->is_ordinary_shndx_ = false;
this->in_real_elf_ = false;
this->is_defined_in_discarded_section_ = false;
+ this->undef_binding_set_ = false;
+ this->undef_binding_weak_ = false;
}
// Return the demangled version of the symbol's name, but only
unsigned int shndx;
typename elfcpp::Elf_types<size>::Elf_Addr sym_value = sym->value();
typename elfcpp::Elf_types<size>::Elf_Addr dynsym_value = sym_value;
+ elfcpp::STB binding = sym->binding();
switch (sym->source())
{
case Symbol::FROM_OBJECT:
if (sym->needs_dynsym_value())
dynsym_value = target.dynsym_value(sym);
shndx = elfcpp::SHN_UNDEF;
+ if (sym->is_undef_binding_weak())
+ binding = elfcpp::STB_WEAK;
}
else if (symobj->pluginobj() != NULL)
shndx = elfcpp::SHN_UNDEF;
gold_assert(sym_index < output_count);
unsigned char* ps = psyms + (sym_index * sym_size);
this->sized_write_symbol<size, big_endian>(sym, sym_value, shndx,
- sympool, ps);
+ binding, sympool, ps);
}
if (dynsym_index != -1U)
gold_assert(dynsym_index < dynamic_count);
unsigned char* pd = dynamic_view + (dynsym_index * sym_size);
this->sized_write_symbol<size, big_endian>(sym, dynsym_value, shndx,
- dynpool, pd);
+ binding, dynpool, pd);
}
}
Sized_symbol<size>* sym,
typename elfcpp::Elf_types<size>::Elf_Addr value,
unsigned int shndx,
+ elfcpp::STB binding,
const Stringpool* pool,
unsigned char* p) const
{
if (sym->is_forced_local())
osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL, type));
else
- osym.put_st_info(elfcpp::elf_st_info(sym->binding(), type));
+ osym.put_st_info(elfcpp::elf_st_info(binding, type));
osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), sym->nonvis()));
osym.put_st_shndx(shndx);
}
void
override_visibility(elfcpp::STV);
+ // Set whether the symbol was originally a weak undef or a regular undef
+ // when resolved by a dynamic def.
+ inline void
+ set_undef_binding(elfcpp::STB bind)
+ {
+ if (!this->undef_binding_set_ || this->undef_binding_weak_)
+ {
+ this->undef_binding_weak_ = bind == elfcpp::STB_WEAK;
+ this->undef_binding_set_ = true;
+ }
+ }
+
+ // Return TRUE if a weak undef was resolved by a dynamic def.
+ inline bool
+ is_undef_binding_weak() const
+ { return this->undef_binding_weak_; }
+
// Return the non-visibility part of the st_other field.
unsigned char
nonvis() const
// True if this symbol is defined in a section which was discarded
// (bit 31).
bool is_defined_in_discarded_section_ : 1;
+ // True if UNDEF_BINDING_WEAK_ has been set (bit 32).
+ bool undef_binding_set_ : 1;
+ // True if this symbol was a weak undef resolved by a dynamic def
+ // (bit 33).
+ bool undef_binding_weak_ : 1;
};
// The parts of a symbol which are size specific. Using a template
// Whether we should override a symbol, based on flags in
// resolve.cc.
static bool
- should_override(const Symbol*, unsigned int, Defined, Object*, bool*);
+ should_override(const Symbol*, unsigned int, Defined, Object*, bool*, bool*);
// Report a problem in symbol resolution.
static void
void
sized_write_symbol(Sized_symbol<size>*,
typename elfcpp::Elf_types<size>::Elf_Addr value,
- unsigned int shndx,
+ unsigned int shndx, elfcpp::STB,
const Stringpool*, unsigned char* p) const;
// Possibly warn about an undefined symbol from a dynamic object.
// weak_undef_file1.cc -- test handling of weak undefined symbols for gold
-// Copyright 2008 Free Software Foundation, Inc.
+// Copyright 2008, 2010 Free Software Foundation, Inc.
// Written by Cary Coutant <ccoutant@google.com>.
// This file is part of gold.
// so that we can detect whether the symbol was left for runtime
// resolution.
-
#include <cstdio>
#include "weak_undef.h"
int is_such_symbol_ = 1;
+// We also define a symbol that is not defined by the alternate
+// library. The main program contains a weak reference to this
+// symbol, and tests that the reference remains weak even after
+// the definition was found at link time.
+
+int link_time_only = 1;
+
extern int v2 __attribute__ ((weak));
int *v3 = &v2;
-// weak_undef_file1.cc -- test handling of weak undefined symbols for gold
+// weak_undef_file2.cc -- test handling of weak undefined symbols for gold
-// Copyright 2008 Free Software Foundation, Inc.
+// Copyright 2008, 2010 Free Software Foundation, Inc.
// Written by Cary Coutant <ccoutant@google.com>.
// This file is part of gold.
// so that we can detect whether the symbol was left for runtime
// resolution.
+// Similarly, this file will be linked with a shared library that
+// does define a different symbol, and loaded with an alternate
+// shared library that does not define that symbol. We check that
+// the weak reference remains weak, and that it is resolved to
+// zero at runtime.
+
#include <cstdio>
#include "weak_undef.h"
extern int no_such_symbol_ __attribute__ ((weak));
+extern int link_time_only __attribute__ ((weak));
+
int *p1 = &no_such_symbol_;
+int *p2 = &link_time_only;
+
int v2 = 42;
int
status = 1;
}
+ if (p2 != NULL)
+ {
+ fprintf(stderr, "FAILED weak undef test 6: %s\n",
+ "p2 is not NULL");
+ status = 1;
+ }
+
return status;
}
projects / binutils-gdb.git / commitdiff