2014-04-01 Cary Coutant * gold/defstd.cc (in_segment): Define __ehdr_start here... * gold/layout.cc (Layout::finalize): ...Instead of here. Set the output segment when known. * gold/resolve.cc (Symbol::override_base_with_special): Remember the original binding. * gold/symtab.cc (Symbol::set_output_segment): New function. (Symbol::set_undefined): New function. * gold/symtab.h (Symbol::is_weak_undefined): Check original undef binding. (Symbol::is_strong_undefined): New function. (Symbol::set_output_segment): New function. (Symbol::set_undefined): New function. * gold/target-reloc.h (is_strong_undefined): Remove. (issue_undefined_symbol_error): Call Symbol::is_weak_undefined. Check for hidden undefs. (relocate_section): Call Symbol::is_strong_undefined. diff --git a/gold/defstd.cc b/gold/defstd.cc index a50e75d..cee68a0 100644 --- a/gold/defstd.cc +++ b/gold/defstd.cc @@ -141,6 +141,20 @@ const Define_symbol_in_segment in_segment[] = true // only_if_ref }, { + "__ehdr_start", // name + elfcpp::PT_LOAD, // segment_type + elfcpp::PF(0), // segment_flags_set + elfcpp::PF(0), // segment_flags_clear + 0, // value + 0, // size + elfcpp::STT_NOTYPE, // type + elfcpp::STB_GLOBAL, // binding + elfcpp::STV_HIDDEN, // visibility + 0, // nonvis + Symbol::SEGMENT_START, // offset_from_base + true // only_if_ref + }, + { "etext", // name elfcpp::PT_LOAD, // segment_type elfcpp::PF_X, // segment_flags_set diff --git a/gold/layout.cc b/gold/layout.cc index c96516c..9bd19c5 100644 --- a/gold/layout.cc +++ b/gold/layout.cc @@ -2743,12 +2743,14 @@ Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab, // If there is a load segment that contains the file and program headers, // provide a symbol __ehdr_start pointing there. // A program can use this to examine itself robustly. - if (load_seg != NULL) - symtab->define_in_output_segment("__ehdr_start", NULL, - Symbol_table::PREDEFINED, load_seg, 0, 0, - elfcpp::STT_NOTYPE, elfcpp::STB_GLOBAL, - elfcpp::STV_HIDDEN, 0, - Symbol::SEGMENT_START, true); + Symbol *ehdr_start = symtab->lookup("__ehdr_start"); + if (ehdr_start != NULL && ehdr_start->is_predefined()) + { + if (load_seg != NULL) + ehdr_start->set_output_segment(load_seg, Symbol::SEGMENT_START); + else + ehdr_start->set_undefined(); + } // Set the file offsets of all the non-data sections we've seen so // far which don't have to wait for the input sections. We need diff --git a/gold/resolve.cc b/gold/resolve.cc index 9b442e2..8cc637a 100644 --- a/gold/resolve.cc +++ b/gold/resolve.cc @@ -915,6 +915,10 @@ Symbol::override_base_with_special(const Symbol* from) bool same_name = this->name_ == from->name_; gold_assert(same_name || this->has_alias()); + // If we are overriding an undef, remember the original binding. + if (this->is_undefined()) + this->set_undef_binding(this->binding_); + this->source_ = from->source_; switch (from->source_) { diff --git a/gold/symtab.cc b/gold/symtab.cc index 1a69f5b..4e8afb1 100644 --- a/gold/symtab.cc +++ b/gold/symtab.cc @@ -527,6 +527,31 @@ Symbol::set_output_section(Output_section* os) } } +// 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() +{ + gold_assert(this->is_predefined_); + this->source_ = IS_UNDEFINED; + this->is_predefined_ = false; +} + // Class Symbol_table. Symbol_table::Symbol_table(unsigned int count, diff --git a/gold/symtab.h b/gold/symtab.h index b06c7b4..b6366d4 100644 --- a/gold/symtab.h +++ b/gold/symtab.h @@ -238,7 +238,7 @@ class Symbol override_visibility(elfcpp::STV); // Set whether the symbol was originally a weak undef or a regular undef - // when resolved by a dynamic def. + // when resolved by a dynamic def or by a special symbol. inline void set_undef_binding(elfcpp::STB bind) { @@ -249,7 +249,8 @@ class Symbol } } - // Return TRUE if a weak undef was resolved by a dynamic def. + // Return TRUE if a weak undef was resolved by a dynamic def or + // by a special symbol. inline bool is_undef_binding_weak() const { return this->undef_binding_weak_; } @@ -517,7 +518,20 @@ class Symbol // Return whether this is a weak undefined symbol. bool is_weak_undefined() const - { return this->is_undefined() && this->binding() == elfcpp::STB_WEAK; } + { + return (this->is_undefined() + && (this->binding() == elfcpp::STB_WEAK + || this->is_undef_binding_weak())); + } + + // Return whether this is a strong undefined symbol. + bool + is_strong_undefined() const + { + return (this->is_undefined() + && this->binding() != elfcpp::STB_WEAK + && !this->is_undef_binding_weak()); + } // Return whether this is an absolute symbol. bool @@ -782,6 +796,18 @@ class Symbol void set_output_section(Output_section*); + // 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 + set_output_segment(Output_segment*, Segment_offset_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 + set_undefined(); + // Return whether there should be a warning for references to this // symbol. bool @@ -1030,7 +1056,7 @@ class Symbol // 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). + // or by a special symbol (bit 33). bool undef_binding_weak_ : 1; // True if this symbol is a predefined linker symbol (bit 34). bool is_predefined_ : 1; diff --git a/gold/target-reloc.h b/gold/target-reloc.h index f49020a..e44519b 100644 --- a/gold/target-reloc.h +++ b/gold/target-reloc.h @@ -143,12 +143,6 @@ class Default_comdat_behavior } }; -inline bool -is_strong_undefined(const Symbol* sym) -{ - return sym->is_undefined() && sym->binding() != elfcpp::STB_WEAK; -} - // Give an error for a symbol with non-default visibility which is not // defined locally. @@ -190,7 +184,7 @@ issue_undefined_symbol_error(const Symbol* sym) return false; // We don't report weak symbols. - if (sym->binding() == elfcpp::STB_WEAK) + if (sym->is_weak_undefined()) return false; // We don't report symbols defined in discarded sections. @@ -216,6 +210,10 @@ issue_undefined_symbol_error(const Symbol* sym) return false; } + // If the symbol is hidden, report it. + if (sym->visibility() == elfcpp::STV_HIDDEN) + return true; + // When creating a shared library, only report unresolved symbols if // -z defs was used. if (parameters->options().shared() && !parameters->options().defs()) @@ -419,7 +417,7 @@ relocate_section( gold_undefined_symbol_at_location(sym, relinfo, i, offset); else if (sym != NULL && sym->visibility() != elfcpp::STV_DEFAULT - && (is_strong_undefined(sym) || sym->is_from_dynobj())) + && (sym->is_strong_undefined() || sym->is_from_dynobj())) visibility_error(sym); if (sym != NULL && sym->has_warning())