aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--gold/i386.cc17
-rw-r--r--gold/object.cc2
-rw-r--r--gold/object.h9
-rw-r--r--gold/output.cc143
-rw-r--r--gold/output.h173
-rw-r--r--gold/x86_64.cc43
6 files changed, 302 insertions, 85 deletions
diff --git a/gold/i386.cc b/gold/i386.cc
index d6e42f4..2d8efdd 100644
--- a/gold/i386.cc
+++ b/gold/i386.cc
@@ -898,9 +898,19 @@ Target_i386::Scan::local(const General_options&,
if (parameters->output_is_position_independent())
{
Reloc_section* rel_dyn = target->rel_dyn_section(layout);
- unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
- rel_dyn->add_local(object, r_sym, r_type, output_section, data_shndx,
- reloc.get_r_offset());
+ if (lsym.get_st_type() != elfcpp::STT_SECTION)
+ {
+ unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
+ rel_dyn->add_local(object, r_sym, r_type, output_section,
+ data_shndx, reloc.get_r_offset());
+ }
+ else
+ {
+ gold_assert(lsym.get_st_value() == 0);
+ rel_dyn->add_local_section(object, lsym.get_st_shndx(),
+ r_type, output_section,
+ data_shndx, reloc.get_r_offset());
+ }
}
break;
@@ -1053,6 +1063,7 @@ Target_i386::Scan::local(const General_options&,
if (output_is_shared)
{
// We need to create a dynamic relocation.
+ gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
unsigned int r_sym = elfcpp::elf_r_sym<32>(reloc.get_r_info());
unsigned int dyn_r_type = (r_type == elfcpp::R_386_TLS_LE_32
? elfcpp::R_386_TLS_TPOFF32
diff --git a/gold/object.cc b/gold/object.cc
index 1adb851..3db6f85 100644
--- a/gold/object.cc
+++ b/gold/object.cc
@@ -884,12 +884,14 @@ Sized_relobj<size, big_endian>::do_count_local_symbols(Stringpool* pool,
if (shndx < shnum && mo[shndx].output_section == NULL)
{
lv.set_no_output_symtab_entry();
+ gold_assert(!lv.needs_output_dynsym_entry());
continue;
}
if (sym.get_st_type() == elfcpp::STT_SECTION)
{
lv.set_no_output_symtab_entry();
+ gold_assert(!lv.needs_output_dynsym_entry());
continue;
}
diff --git a/gold/object.h b/gold/object.h
index 36a2e1f..4011bdc 100644
--- a/gold/object.h
+++ b/gold/object.h
@@ -874,6 +874,7 @@ class Symbol_value
void
set_needs_output_dynsym_entry()
{
+ gold_assert(!this->is_section_symbol());
this->output_dynsym_index_ = 0;
}
@@ -897,7 +898,8 @@ class Symbol_value
unsigned int
output_dynsym_index() const
{
- gold_assert(this->output_dynsym_index_ != 0);
+ gold_assert(this->output_dynsym_index_ != 0
+ && this->output_dynsym_index_ != -1U);
return this->output_dynsym_index_;
}
@@ -924,7 +926,10 @@ class Symbol_value
// Record that this is a section symbol.
void
set_is_section_symbol()
- { this->is_section_symbol_ = true; }
+ {
+ gold_assert(!this->needs_output_dynsym_entry());
+ this->is_section_symbol_ = true;
+ }
// Record that this is a TLS symbol.
void
diff --git a/gold/output.cc b/gold/output.cc
index 8aca916..107ed09 100644
--- a/gold/output.cc
+++ b/gold/output.cc
@@ -608,12 +608,14 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
Address address,
bool is_relative)
: address_(address), local_sym_index_(GSYM_CODE), type_(type),
- is_relative_(is_relative), shndx_(INVALID_CODE)
+ is_relative_(is_relative), is_section_symbol_(false), shndx_(INVALID_CODE)
{
+ // this->type_ is a bitfield; make sure TYPE fits.
+ gold_assert(this->type_ == type);
this->u1_.gsym = gsym;
this->u2_.od = od;
- if (dynamic && !is_relative)
- gsym->set_needs_dynsym_entry();
+ if (dynamic)
+ this->set_needs_dynsym_index();
}
template<bool dynamic, int size, bool big_endian>
@@ -625,13 +627,15 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
Address address,
bool is_relative)
: address_(address), local_sym_index_(GSYM_CODE), type_(type),
- is_relative_(is_relative), shndx_(shndx)
+ is_relative_(is_relative), is_section_symbol_(false), shndx_(shndx)
{
gold_assert(shndx != INVALID_CODE);
+ // this->type_ is a bitfield; make sure TYPE fits.
+ gold_assert(this->type_ == type);
this->u1_.gsym = gsym;
this->u2_.relobj = relobj;
- if (dynamic && !is_relative)
- gsym->set_needs_dynsym_entry();
+ if (dynamic)
+ this->set_needs_dynsym_index();
}
// A reloc against a local symbol.
@@ -643,16 +647,20 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
unsigned int type,
Output_data* od,
Address address,
- bool is_relative)
+ bool is_relative,
+ bool is_section_symbol)
: address_(address), local_sym_index_(local_sym_index), type_(type),
- is_relative_(is_relative), shndx_(INVALID_CODE)
+ is_relative_(is_relative), is_section_symbol_(is_section_symbol),
+ shndx_(INVALID_CODE)
{
gold_assert(local_sym_index != GSYM_CODE
&& local_sym_index != INVALID_CODE);
+ // this->type_ is a bitfield; make sure TYPE fits.
+ gold_assert(this->type_ == type);
this->u1_.relobj = relobj;
this->u2_.od = od;
- if (dynamic && !is_relative)
- relobj->set_needs_output_dynsym_entry(local_sym_index);
+ if (dynamic)
+ this->set_needs_dynsym_index();
}
template<bool dynamic, int size, bool big_endian>
@@ -662,17 +670,21 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
unsigned int type,
unsigned int shndx,
Address address,
- bool is_relative)
+ bool is_relative,
+ bool is_section_symbol)
: address_(address), local_sym_index_(local_sym_index), type_(type),
- is_relative_(is_relative), shndx_(shndx)
+ is_relative_(is_relative), is_section_symbol_(is_section_symbol),
+ shndx_(shndx)
{
gold_assert(local_sym_index != GSYM_CODE
&& local_sym_index != INVALID_CODE);
gold_assert(shndx != INVALID_CODE);
+ // this->type_ is a bitfield; make sure TYPE fits.
+ gold_assert(this->type_ == type);
this->u1_.relobj = relobj;
this->u2_.relobj = relobj;
- if (dynamic && !is_relative)
- relobj->set_needs_output_dynsym_entry(local_sym_index);
+ if (dynamic)
+ this->set_needs_dynsym_index();
}
// A reloc against the STT_SECTION symbol of an output section.
@@ -684,12 +696,16 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
Output_data* od,
Address address)
: address_(address), local_sym_index_(SECTION_CODE), type_(type),
- is_relative_(false), shndx_(INVALID_CODE)
+ is_relative_(false), is_section_symbol_(true), shndx_(INVALID_CODE)
{
+ // this->type_ is a bitfield; make sure TYPE fits.
+ gold_assert(this->type_ == type);
this->u1_.os = os;
this->u2_.od = od;
if (dynamic)
- os->set_needs_dynsym_index();
+ this->set_needs_dynsym_index();
+ else
+ os->set_needs_symtab_index();
}
template<bool dynamic, int size, bool big_endian>
@@ -700,13 +716,59 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
unsigned int shndx,
Address address)
: address_(address), local_sym_index_(SECTION_CODE), type_(type),
- is_relative_(false), shndx_(shndx)
+ is_relative_(false), is_section_symbol_(true), shndx_(shndx)
{
gold_assert(shndx != INVALID_CODE);
+ // this->type_ is a bitfield; make sure TYPE fits.
+ gold_assert(this->type_ == type);
this->u1_.os = os;
this->u2_.relobj = relobj;
if (dynamic)
- os->set_needs_dynsym_index();
+ this->set_needs_dynsym_index();
+ else
+ os->set_needs_symtab_index();
+}
+
+// Record that we need a dynamic symbol index for this relocation.
+
+template<bool dynamic, int size, bool big_endian>
+void
+Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
+set_needs_dynsym_index()
+{
+ if (this->is_relative_)
+ return;
+ switch (this->local_sym_index_)
+ {
+ case INVALID_CODE:
+ gold_unreachable();
+
+ case GSYM_CODE:
+ this->u1_.gsym->set_needs_dynsym_entry();
+ break;
+
+ case SECTION_CODE:
+ this->u1_.os->set_needs_dynsym_index();
+ break;
+
+ case 0:
+ break;
+
+ default:
+ {
+ const unsigned int lsi = this->local_sym_index_;
+ if (!this->is_section_symbol_)
+ this->u1_.relobj->set_needs_output_dynsym_entry(lsi);
+ else
+ {
+ section_offset_type dummy;
+ Output_section* os = this->u1_.relobj->output_section(lsi, &dummy);
+ gold_assert(os != NULL);
+ os->set_needs_dynsym_index();
+ }
+ }
+ break;
+ }
}
// Get the symbol index of a relocation.
@@ -744,16 +806,47 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
break;
default:
- if (dynamic)
- index = this->u1_.relobj->dynsym_index(this->local_sym_index_);
- else
- index = this->u1_.relobj->symtab_index(this->local_sym_index_);
+ {
+ const unsigned int lsi = this->local_sym_index_;
+ if (!this->is_section_symbol_)
+ {
+ if (dynamic)
+ index = this->u1_.relobj->dynsym_index(lsi);
+ else
+ index = this->u1_.relobj->symtab_index(lsi);
+ }
+ else
+ {
+ section_offset_type dummy;
+ Output_section* os = this->u1_.relobj->output_section(lsi, &dummy);
+ gold_assert(os != NULL);
+ if (dynamic)
+ index = os->dynsym_index();
+ else
+ index = os->symtab_index();
+ }
+ }
break;
}
gold_assert(index != -1U);
return index;
}
+// For a local section symbol, get the section offset of the input
+// section within the output section.
+
+template<bool dynamic, int size, bool big_endian>
+section_offset_type
+Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
+ local_section_offset() const
+{
+ const unsigned int lsi = this->local_sym_index_;
+ section_offset_type offset;
+ Output_section* os = this->u1_.relobj->output_section(lsi, &offset);
+ gold_assert(os != NULL);
+ return offset;
+}
+
// Write out the offset and info fields of a Rel or Rela relocation
// entry.
@@ -825,8 +918,10 @@ Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>::write(
elfcpp::Rela_write<size, big_endian> orel(pov);
this->rel_.write_rel(&orel);
Addend addend = this->addend_;
- if (rel_.is_relative())
- addend += rel_.symbol_value();
+ if (this->rel_.is_relative())
+ addend += this->rel_.symbol_value();
+ if (this->rel_.is_local_section_symbol())
+ addend += this->rel_.local_section_offset();
orel.put_r_addend(addend);
}
diff --git a/gold/output.h b/gold/output.h
index fbfdb25..8f7a564 100644
--- a/gold/output.h
+++ b/gold/output.h
@@ -767,9 +767,9 @@ class Output_data_strtab : public Output_section_data
// or elfcpp::SHT_RELA, and also on whether this is a dynamic
// relocation or an ordinary relocation.
-// A relocation can be against a global symbol, a local symbol, an
-// output section, or the undefined symbol at index 0. We represent
-// the latter by using a NULL global symbol.
+// A relocation can be against a global symbol, a local symbol, a
+// local section symbol, an output section, or the undefined symbol at
+// index 0. We represent the latter by using a NULL global symbol.
template<int sh_type, bool dynamic, int size, bool big_endian>
class Output_reloc;
@@ -786,6 +786,11 @@ class Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
: local_sym_index_(INVALID_CODE)
{ }
+ // We have a bunch of different constructors. They come in pairs
+ // depending on how the address of the relocation is specified. It
+ // can either be an offset in an Output_data or an offset in an
+ // input section.
+
// A reloc against a global symbol.
Output_reloc(Symbol* gsym, unsigned int type, Output_data* od,
@@ -794,15 +799,17 @@ class Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
Output_reloc(Symbol* gsym, unsigned int type, Relobj* relobj,
unsigned int shndx, Address address, bool is_relative);
- // A reloc against a local symbol.
+ // A reloc against a local symbol or local section symbol.
Output_reloc(Sized_relobj<size, big_endian>* relobj,
unsigned int local_sym_index, unsigned int type,
- Output_data* od, Address address, bool is_relative);
+ Output_data* od, Address address, bool is_relative,
+ bool is_section_symbol);
Output_reloc(Sized_relobj<size, big_endian>* relobj,
unsigned int local_sym_index, unsigned int type,
- unsigned int shndx, Address address, bool is_relative);
+ unsigned int shndx, Address address, bool is_relative,
+ bool is_section_symbol);
// A reloc against the STT_SECTION symbol of an output section.
@@ -817,6 +824,21 @@ class Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
is_relative() const
{ return this->is_relative_; }
+ // Return whether this is against a local section symbol.
+ bool
+ is_local_section_symbol() const
+ {
+ return (this->local_sym_index_ != GSYM_CODE
+ && this->local_sym_index_ != SECTION_CODE
+ && this->local_sym_index_ != INVALID_CODE
+ && this->is_section_symbol_);
+ }
+
+ // For a local section symbol, return the offset of the input
+ // section within the output section.
+ section_offset_type
+ local_section_offset() const;
+
// Get the value of the symbol referred to by a Rel relocation.
Address
@@ -831,8 +853,11 @@ class Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
void write_rel(Write_rel*) const;
private:
- // Return the symbol index. We can't do a double template
- // specialization, so we do a secondary template here.
+ // Record that we need a dynamic symbol index.
+ void
+ set_needs_dynsym_index();
+
+ // Return the symbol index.
unsigned int
get_symbol_index() const;
@@ -849,36 +874,45 @@ class Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
union
{
- // For a local symbol, the object. We will never generate a
- // relocation against a local symbol in a dynamic object; that
- // doesn't make sense. And our callers will always be
- // templatized, so we use Sized_relobj here.
+ // For a local symbol or local section symbol
+ // (this->local_sym_index_ >= 0), the object. We will never
+ // generate a relocation against a local symbol in a dynamic
+ // object; that doesn't make sense. And our callers will always
+ // be templatized, so we use Sized_relobj here.
Sized_relobj<size, big_endian>* relobj;
- // For a global symbol, the symbol. If this is NULL, it indicates
- // a relocation against the undefined 0 symbol.
+ // For a global symbol (this->local_sym_index_ == GSYM_CODE, the
+ // symbol. If this is NULL, it indicates a relocation against the
+ // undefined 0 symbol.
Symbol* gsym;
- // For a relocation against an output section, the output section.
+ // For a relocation against an output section
+ // (this->local_sym_index_ == SECTION_CODE), the output section.
Output_section* os;
} u1_;
union
{
- // If shndx_ is not INVALID CODE, the object which holds the input
- // section being used to specify the reloc address.
+ // If this->shndx_ is not INVALID CODE, the object which holds the
+ // input section being used to specify the reloc address.
Relobj* relobj;
- // If shndx_ is INVALID_CODE, the output data being used to
+ // If this->shndx_ is INVALID_CODE, the output data being used to
// specify the reloc address. This may be NULL if the reloc
// address is absolute.
Output_data* od;
} u2_;
// The address offset within the input section or the Output_data.
Address address_;
- // For a local symbol, the local symbol index. This is GSYM_CODE
- // for a global symbol, or INVALID_CODE for an uninitialized value.
+ // This is GSYM_CODE for a global symbol, or SECTION_CODE for a
+ // relocation against an output section, or INVALID_CODE for an
+ // uninitialized value. Otherwise, for a local symbol
+ // (this->is_section_symbol_ is false), the local symbol index. For
+ // a local section symbol (this->is_section_symbol_ is true), the
+ // section index in the input file.
unsigned int local_sym_index_;
// The reloc type--a processor specific code.
- unsigned int type_ : 31;
+ unsigned int type_ : 30;
// True if the relocation is a RELATIVE relocation.
bool is_relative_ : 1;
+ // True if the relocation is against a section symbol.
+ bool is_section_symbol_ : 1;
// If the reloc address is an input section in an object, the
// section index. This is INVALID_CODE if the reloc address is
// specified in some other way.
@@ -918,16 +952,18 @@ class Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>
Output_reloc(Sized_relobj<size, big_endian>* relobj,
unsigned int local_sym_index, unsigned int type,
Output_data* od, Address address,
- Addend addend, bool is_relative)
- : rel_(relobj, local_sym_index, type, od, address, is_relative),
+ Addend addend, bool is_relative, bool is_section_symbol)
+ : rel_(relobj, local_sym_index, type, od, address, is_relative,
+ is_section_symbol),
addend_(addend)
{ }
Output_reloc(Sized_relobj<size, big_endian>* relobj,
unsigned int local_sym_index, unsigned int type,
unsigned int shndx, Address address,
- Addend addend, bool is_relative)
- : rel_(relobj, local_sym_index, type, shndx, address, is_relative),
+ Addend addend, bool is_relative, bool is_section_symbol)
+ : rel_(relobj, local_sym_index, type, shndx, address, is_relative,
+ is_section_symbol),
addend_(addend)
{ }
@@ -1010,7 +1046,7 @@ template<bool dynamic, int size, bool big_endian>
class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
: public Output_data_reloc_base<elfcpp::SHT_REL, dynamic, size, big_endian>
{
- private:
+ private:
typedef Output_data_reloc_base<elfcpp::SHT_REL, dynamic, size,
big_endian> Base;
@@ -1045,8 +1081,10 @@ class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
void
add_global_relative(Symbol* gsym, unsigned int type, Output_data* od,
Relobj* relobj, unsigned int shndx, Address address)
- { this->add(od, Output_reloc_type(gsym, type, relobj, shndx, address,
- true)); }
+ {
+ this->add(od, Output_reloc_type(gsym, type, relobj, shndx, address,
+ true));
+ }
// Add a reloc against a local symbol.
@@ -1054,15 +1092,19 @@ class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
add_local(Sized_relobj<size, big_endian>* relobj,
unsigned int local_sym_index, unsigned int type,
Output_data* od, Address address)
- { this->add(od, Output_reloc_type(relobj, local_sym_index, type, od,
- address, false)); }
+ {
+ this->add(od, Output_reloc_type(relobj, local_sym_index, type, od,
+ address, false, false));
+ }
void
add_local(Sized_relobj<size, big_endian>* relobj,
unsigned int local_sym_index, unsigned int type,
Output_data* od, unsigned int shndx, Address address)
- { this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
- address, false)); }
+ {
+ this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
+ address, false, false));
+ }
// Add a RELATIVE reloc against a local symbol.
@@ -1070,15 +1112,41 @@ class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
add_local_relative(Sized_relobj<size, big_endian>* relobj,
unsigned int local_sym_index, unsigned int type,
Output_data* od, Address address)
- { this->add(od, Output_reloc_type(relobj, local_sym_index, type, od,
- address, true)); }
+ {
+ this->add(od, Output_reloc_type(relobj, local_sym_index, type, od,
+ address, true, false));
+ }
void
add_local_relative(Sized_relobj<size, big_endian>* relobj,
unsigned int local_sym_index, unsigned int type,
Output_data* od, unsigned int shndx, Address address)
- { this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
- address, true)); }
+ {
+ this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
+ address, true, false));
+ }
+
+ // Add a reloc against a local section symbol. This will be
+ // converted into a reloc against the STT_SECTION symbol of the
+ // output section.
+
+ void
+ add_local_section(Sized_relobj<size, big_endian>* relobj,
+ unsigned int input_shndx, unsigned int type,
+ Output_data* od, Address address)
+ {
+ this->add(od, Output_reloc_type(relobj, input_shndx, type, od,
+ address, false, true));
+ }
+
+ void
+ add_local_section(Sized_relobj<size, big_endian>* relobj,
+ unsigned int input_shndx, unsigned int type,
+ Output_data* od, unsigned int shndx, Address address)
+ {
+ this->add(od, Output_reloc_type(relobj, input_shndx, type, shndx,
+ address, false, true));
+ }
// A reloc against the STT_SECTION symbol of an output section.
// OS is the Output_section that the relocation refers to; OD is
@@ -1101,7 +1169,7 @@ template<bool dynamic, int size, bool big_endian>
class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>
: public Output_data_reloc_base<elfcpp::SHT_RELA, dynamic, size, big_endian>
{
- private:
+ private:
typedef Output_data_reloc_base<elfcpp::SHT_RELA, dynamic, size,
big_endian> Base;
@@ -1154,7 +1222,7 @@ class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>
Output_data* od, Address address, Addend addend)
{
this->add(od, Output_reloc_type(relobj, local_sym_index, type, od, address,
- addend, false));
+ addend, false, false));
}
void
@@ -1164,7 +1232,7 @@ class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>
Addend addend)
{
this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
- address, addend, false));
+ address, addend, false, false));
}
// Add a RELATIVE reloc against a local symbol.
@@ -1175,7 +1243,7 @@ class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>
Output_data* od, Address address, Addend addend)
{
this->add(od, Output_reloc_type(relobj, local_sym_index, type, od, address,
- addend, true));
+ addend, true, false));
}
void
@@ -1185,7 +1253,30 @@ class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>
Addend addend)
{
this->add(od, Output_reloc_type(relobj, local_sym_index, type, shndx,
- address, addend, true));
+ address, addend, true, false));
+ }
+
+ // Add a reloc against a local section symbol. This will be
+ // converted into a reloc against the STT_SECTION symbol of the
+ // output section.
+
+ void
+ add_local_section(Sized_relobj<size, big_endian>* relobj,
+ unsigned int input_shndx, unsigned int type,
+ Output_data* od, Address address, Addend addend)
+ {
+ this->add(od, Output_reloc_type(relobj, input_shndx, type, od, address,
+ addend, false, true));
+ }
+
+ void
+ add_local_section(Sized_relobj<size, big_endian>* relobj,
+ unsigned int input_shndx, unsigned int type,
+ Output_data* od, unsigned int shndx, Address address,
+ Addend addend)
+ {
+ this->add(od, Output_reloc_type(relobj, input_shndx, type, shndx,
+ address, addend, false, true));
}
// A reloc against the STT_SECTION symbol of an output section.
diff --git a/gold/x86_64.cc b/gold/x86_64.cc
index 54357fd..d5869dc 100644
--- a/gold/x86_64.cc
+++ b/gold/x86_64.cc
@@ -828,10 +828,10 @@ Target_x86_64::Scan::local(const General_options&,
case elfcpp::R_X86_64_64:
// If building a shared library (or a position-independent
- // executable), we need to create a dynamic relocation for
- // this location. The relocation applied at link time will
- // apply the link-time value, so we flag the location with
- // an R_386_RELATIVE relocation so the dynamic loader can
+ // executable), we need to create a dynamic relocation for this
+ // location. The relocation applied at link time will apply the
+ // link-time value, so we flag the location with an
+ // R_X86_64_RELATIVE relocation so the dynamic loader can
// relocate it easily.
if (parameters->output_is_position_independent())
{
@@ -850,18 +850,27 @@ Target_x86_64::Scan::local(const General_options&,
case elfcpp::R_X86_64_16:
case elfcpp::R_X86_64_8:
// If building a shared library (or a position-independent
- // executable), we need to create a dynamic relocation for
- // this location. The relocation applied at link time will
- // apply the link-time value, so we flag the location with
- // an R_386_RELATIVE relocation so the dynamic loader can
- // relocate it easily.
+ // executable), we need to create a dynamic relocation for this
+ // location. We can't use an R_X86_64_RELATIVE relocation
+ // because that is always a 64-bit relocation.
if (parameters->output_is_position_independent())
{
Reloc_section* rela_dyn = target->rela_dyn_section(layout);
- unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
- rela_dyn->add_local(object, r_sym, r_type, output_section,
- data_shndx, reloc.get_r_offset(),
- reloc.get_r_addend());
+ if (lsym.get_st_type() != elfcpp::STT_SECTION)
+ {
+ unsigned int r_sym = elfcpp::elf_r_sym<64>(reloc.get_r_info());
+ rela_dyn->add_local(object, r_sym, r_type, output_section,
+ data_shndx, reloc.get_r_offset(),
+ reloc.get_r_addend());
+ }
+ else
+ {
+ gold_assert(lsym.get_st_value() == 0);
+ rela_dyn->add_local_section(object, lsym.get_st_shndx(),
+ r_type, output_section,
+ data_shndx, reloc.get_r_offset(),
+ reloc.get_r_addend());
+ }
}
break;
@@ -909,8 +918,12 @@ Target_x86_64::Scan::local(const General_options&,
object->local_got_offset(r_sym),
0);
else
- rela_dyn->add_local(object, r_sym, r_type,
- got, object->local_got_offset(r_sym), 0);
+ {
+ gold_assert(lsym.get_st_type() != elfcpp::STT_SECTION);
+ rela_dyn->add_local(object, r_sym, r_type,
+ got, object->local_got_offset(r_sym),
+ 0);
+ }
}
}
// For GOTPLT64, we'd normally want a PLT section, but since