2006-09-29 21:58:17 +02:00
|
|
|
// reloc.h -- relocate input files for gold -*- C++ -*-
|
|
|
|
|
2012-01-28 02:47:01 +01:00
|
|
|
// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
|
|
|
|
// Free Software Foundation, Inc.
|
2007-09-22 23:02:10 +02:00
|
|
|
// Written by Ian Lance Taylor <iant@google.com>.
|
|
|
|
|
|
|
|
// This file is part of gold.
|
|
|
|
|
|
|
|
// This program is free software; you can redistribute it and/or modify
|
|
|
|
// it under the terms of the GNU General Public License as published by
|
|
|
|
// the Free Software Foundation; either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU General Public License for more details.
|
|
|
|
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
|
|
// along with this program; if not, write to the Free Software
|
|
|
|
// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
|
|
|
// MA 02110-1301, USA.
|
|
|
|
|
2006-09-29 21:58:17 +02:00
|
|
|
#ifndef GOLD_RELOC_H
|
|
|
|
#define GOLD_RELOC_H
|
|
|
|
|
2007-12-14 20:00:21 +01:00
|
|
|
#include <vector>
|
2009-06-23 20:10:42 +02:00
|
|
|
#ifdef HAVE_BYTESWAP_H
|
2006-10-20 22:40:49 +02:00
|
|
|
#include <byteswap.h>
|
2009-06-23 20:10:42 +02:00
|
|
|
#endif
|
2006-10-20 22:40:49 +02:00
|
|
|
|
2007-11-10 00:16:54 +01:00
|
|
|
#include "elfcpp.h"
|
2006-09-29 21:58:17 +02:00
|
|
|
#include "workqueue.h"
|
|
|
|
|
|
|
|
namespace gold
|
|
|
|
{
|
|
|
|
|
2006-11-29 18:56:40 +01:00
|
|
|
class General_options;
|
2007-11-12 21:35:21 +01:00
|
|
|
class Object;
|
2006-11-06 23:46:08 +01:00
|
|
|
class Relobj;
|
2006-10-20 22:40:49 +02:00
|
|
|
class Read_relocs_data;
|
2006-11-29 18:56:40 +01:00
|
|
|
class Symbol;
|
2006-11-03 19:26:11 +01:00
|
|
|
class Layout;
|
2008-02-06 09:13:50 +01:00
|
|
|
class Output_data;
|
2007-11-16 00:46:46 +01:00
|
|
|
class Output_section;
|
2006-10-20 22:40:49 +02:00
|
|
|
|
2006-12-01 00:52:50 +01:00
|
|
|
template<int size>
|
|
|
|
class Sized_symbol;
|
|
|
|
|
2007-05-16 19:42:48 +02:00
|
|
|
template<int size, bool big_endian>
|
2011-05-24 23:41:10 +02:00
|
|
|
class Sized_relobj_file;
|
2007-05-16 19:42:48 +02:00
|
|
|
|
|
|
|
template<int size>
|
|
|
|
class Symbol_value;
|
|
|
|
|
2006-12-01 00:52:50 +01:00
|
|
|
template<int sh_type, bool dynamic, int size, bool big_endian>
|
|
|
|
class Output_data_reloc;
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
// A class to read the relocations for an object file, and then queue
|
|
|
|
// up a task to see if they require any GOT/PLT/COPY relocations in
|
|
|
|
// the symbol table.
|
|
|
|
|
|
|
|
class Read_relocs : public Task
|
|
|
|
{
|
|
|
|
public:
|
2010-02-12 05:33:53 +01:00
|
|
|
// THIS_BLOCKER and NEXT_BLOCKER are passed along to a Scan_relocs
|
|
|
|
// or Gc_process_relocs task, so that they run in a deterministic
|
|
|
|
// order.
|
* object.h (class Relobj): Drop options parameter from
gc_process_relocs, scan_relocs, relocate, do_gc_process_relocs,
do_scan_relocs, do_relocate. Change all callers.
(class Sized_relobj): Drop options parameters from
do_gc_process_relocs, do_scan_relocs, do_relocate,
do_relocate_sections, relocate_sections, emit_relocs_scan,
emit_relocs_scan_reltype. Change all callers.
(struct Relocate_info): Remove options field and all references to
it.
* reloc.h (class Read_relocs): Remove options constructor
parameter and options_ field. Change all callers.
(class Gc_process_relocs, class Scan_relocs): Likewise.
(class Relocate_task): Likewise.
* target-reloc.h (scan_relocs): Remove options parameter. Change
all callers.
(scan_relocatable_relocs): Likewise.
* target.h (class Sized_target): Remove options parameter from
gc_process_relocs, scan_relocs, scan_relocatable_relocs. Change
all callers.
* gc.h (gc_process_relocs): Remove options parameter. Change all
callers.
* arm.cc: Update functions to remove options parameters.
* i386.cc: Likewise.
* powerpc.cc: Likewise.
* sparc.cc: Likewise.
* x86_64.cc: Likewise.
* testsuite/testfile.cc: Likewise.
2009-10-29 06:16:23 +01:00
|
|
|
Read_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
|
2010-02-12 05:33:53 +01:00
|
|
|
Task_token* this_blocker, Task_token* next_blocker)
|
* object.h (class Relobj): Drop options parameter from
gc_process_relocs, scan_relocs, relocate, do_gc_process_relocs,
do_scan_relocs, do_relocate. Change all callers.
(class Sized_relobj): Drop options parameters from
do_gc_process_relocs, do_scan_relocs, do_relocate,
do_relocate_sections, relocate_sections, emit_relocs_scan,
emit_relocs_scan_reltype. Change all callers.
(struct Relocate_info): Remove options field and all references to
it.
* reloc.h (class Read_relocs): Remove options constructor
parameter and options_ field. Change all callers.
(class Gc_process_relocs, class Scan_relocs): Likewise.
(class Relocate_task): Likewise.
* target-reloc.h (scan_relocs): Remove options parameter. Change
all callers.
(scan_relocatable_relocs): Likewise.
* target.h (class Sized_target): Remove options parameter from
gc_process_relocs, scan_relocs, scan_relocatable_relocs. Change
all callers.
* gc.h (gc_process_relocs): Remove options parameter. Change all
callers.
* arm.cc: Update functions to remove options parameters.
* i386.cc: Likewise.
* powerpc.cc: Likewise.
* sparc.cc: Likewise.
* x86_64.cc: Likewise.
* testsuite/testfile.cc: Likewise.
2009-10-29 06:16:23 +01:00
|
|
|
: symtab_(symtab), layout_(layout), object_(object),
|
2010-02-12 05:33:53 +01:00
|
|
|
this_blocker_(this_blocker), next_blocker_(next_blocker)
|
2006-10-20 22:40:49 +02:00
|
|
|
{ }
|
|
|
|
|
|
|
|
// The standard Task methods.
|
|
|
|
|
2007-12-14 20:00:21 +01:00
|
|
|
Task_token*
|
|
|
|
is_runnable();
|
2006-10-20 22:40:49 +02:00
|
|
|
|
2007-12-14 20:00:21 +01:00
|
|
|
void
|
|
|
|
locks(Task_locker*);
|
2006-10-20 22:40:49 +02:00
|
|
|
|
|
|
|
void
|
|
|
|
run(Workqueue*);
|
|
|
|
|
2007-11-22 01:05:51 +01:00
|
|
|
std::string
|
|
|
|
get_name() const;
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
private:
|
|
|
|
Symbol_table* symtab_;
|
2006-11-03 19:26:11 +01:00
|
|
|
Layout* layout_;
|
2006-11-06 23:46:08 +01:00
|
|
|
Relobj* object_;
|
2010-02-12 05:33:53 +01:00
|
|
|
Task_token* this_blocker_;
|
|
|
|
Task_token* next_blocker_;
|
2006-10-20 22:40:49 +02:00
|
|
|
};
|
|
|
|
|
2009-01-28 03:25:33 +01:00
|
|
|
// Process the relocs to figure out which sections are garbage.
|
|
|
|
// Very similar to scan relocs.
|
|
|
|
|
|
|
|
class Gc_process_relocs : public Task
|
|
|
|
{
|
|
|
|
public:
|
2010-02-12 05:33:53 +01:00
|
|
|
// THIS_BLOCKER prevents this task from running until the previous
|
|
|
|
// one is finished. NEXT_BLOCKER prevents the next task from
|
|
|
|
// running.
|
* object.h (class Relobj): Drop options parameter from
gc_process_relocs, scan_relocs, relocate, do_gc_process_relocs,
do_scan_relocs, do_relocate. Change all callers.
(class Sized_relobj): Drop options parameters from
do_gc_process_relocs, do_scan_relocs, do_relocate,
do_relocate_sections, relocate_sections, emit_relocs_scan,
emit_relocs_scan_reltype. Change all callers.
(struct Relocate_info): Remove options field and all references to
it.
* reloc.h (class Read_relocs): Remove options constructor
parameter and options_ field. Change all callers.
(class Gc_process_relocs, class Scan_relocs): Likewise.
(class Relocate_task): Likewise.
* target-reloc.h (scan_relocs): Remove options parameter. Change
all callers.
(scan_relocatable_relocs): Likewise.
* target.h (class Sized_target): Remove options parameter from
gc_process_relocs, scan_relocs, scan_relocatable_relocs. Change
all callers.
* gc.h (gc_process_relocs): Remove options parameter. Change all
callers.
* arm.cc: Update functions to remove options parameters.
* i386.cc: Likewise.
* powerpc.cc: Likewise.
* sparc.cc: Likewise.
* x86_64.cc: Likewise.
* testsuite/testfile.cc: Likewise.
2009-10-29 06:16:23 +01:00
|
|
|
Gc_process_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
|
2010-02-12 05:33:53 +01:00
|
|
|
Read_relocs_data* rd, Task_token* this_blocker,
|
|
|
|
Task_token* next_blocker)
|
* object.h (class Relobj): Drop options parameter from
gc_process_relocs, scan_relocs, relocate, do_gc_process_relocs,
do_scan_relocs, do_relocate. Change all callers.
(class Sized_relobj): Drop options parameters from
do_gc_process_relocs, do_scan_relocs, do_relocate,
do_relocate_sections, relocate_sections, emit_relocs_scan,
emit_relocs_scan_reltype. Change all callers.
(struct Relocate_info): Remove options field and all references to
it.
* reloc.h (class Read_relocs): Remove options constructor
parameter and options_ field. Change all callers.
(class Gc_process_relocs, class Scan_relocs): Likewise.
(class Relocate_task): Likewise.
* target-reloc.h (scan_relocs): Remove options parameter. Change
all callers.
(scan_relocatable_relocs): Likewise.
* target.h (class Sized_target): Remove options parameter from
gc_process_relocs, scan_relocs, scan_relocatable_relocs. Change
all callers.
* gc.h (gc_process_relocs): Remove options parameter. Change all
callers.
* arm.cc: Update functions to remove options parameters.
* i386.cc: Likewise.
* powerpc.cc: Likewise.
* sparc.cc: Likewise.
* x86_64.cc: Likewise.
* testsuite/testfile.cc: Likewise.
2009-10-29 06:16:23 +01:00
|
|
|
: symtab_(symtab), layout_(layout), object_(object), rd_(rd),
|
2010-02-12 05:33:53 +01:00
|
|
|
this_blocker_(this_blocker), next_blocker_(next_blocker)
|
2009-01-28 03:25:33 +01:00
|
|
|
{ }
|
|
|
|
|
2010-02-12 05:33:53 +01:00
|
|
|
~Gc_process_relocs();
|
|
|
|
|
2009-01-28 03:25:33 +01:00
|
|
|
// The standard Task methods.
|
|
|
|
|
|
|
|
Task_token*
|
|
|
|
is_runnable();
|
|
|
|
|
|
|
|
void
|
|
|
|
locks(Task_locker*);
|
|
|
|
|
|
|
|
void
|
|
|
|
run(Workqueue*);
|
|
|
|
|
|
|
|
std::string
|
|
|
|
get_name() const;
|
|
|
|
|
|
|
|
private:
|
|
|
|
Symbol_table* symtab_;
|
|
|
|
Layout* layout_;
|
|
|
|
Relobj* object_;
|
|
|
|
Read_relocs_data* rd_;
|
2010-02-12 05:33:53 +01:00
|
|
|
Task_token* this_blocker_;
|
|
|
|
Task_token* next_blocker_;
|
2009-01-28 03:25:33 +01:00
|
|
|
};
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
// Scan the relocations for an object to see if they require any
|
|
|
|
// GOT/PLT/COPY relocations.
|
|
|
|
|
|
|
|
class Scan_relocs : public Task
|
|
|
|
{
|
|
|
|
public:
|
2010-02-12 05:33:53 +01:00
|
|
|
// THIS_BLOCKER prevents this task from running until the previous
|
|
|
|
// one is finished. NEXT_BLOCKER prevents the next task from
|
|
|
|
// running.
|
* object.h (class Relobj): Drop options parameter from
gc_process_relocs, scan_relocs, relocate, do_gc_process_relocs,
do_scan_relocs, do_relocate. Change all callers.
(class Sized_relobj): Drop options parameters from
do_gc_process_relocs, do_scan_relocs, do_relocate,
do_relocate_sections, relocate_sections, emit_relocs_scan,
emit_relocs_scan_reltype. Change all callers.
(struct Relocate_info): Remove options field and all references to
it.
* reloc.h (class Read_relocs): Remove options constructor
parameter and options_ field. Change all callers.
(class Gc_process_relocs, class Scan_relocs): Likewise.
(class Relocate_task): Likewise.
* target-reloc.h (scan_relocs): Remove options parameter. Change
all callers.
(scan_relocatable_relocs): Likewise.
* target.h (class Sized_target): Remove options parameter from
gc_process_relocs, scan_relocs, scan_relocatable_relocs. Change
all callers.
* gc.h (gc_process_relocs): Remove options parameter. Change all
callers.
* arm.cc: Update functions to remove options parameters.
* i386.cc: Likewise.
* powerpc.cc: Likewise.
* sparc.cc: Likewise.
* x86_64.cc: Likewise.
* testsuite/testfile.cc: Likewise.
2009-10-29 06:16:23 +01:00
|
|
|
Scan_relocs(Symbol_table* symtab, Layout* layout, Relobj* object,
|
2010-02-12 05:33:53 +01:00
|
|
|
Read_relocs_data* rd, Task_token* this_blocker,
|
|
|
|
Task_token* next_blocker)
|
* object.h (class Relobj): Drop options parameter from
gc_process_relocs, scan_relocs, relocate, do_gc_process_relocs,
do_scan_relocs, do_relocate. Change all callers.
(class Sized_relobj): Drop options parameters from
do_gc_process_relocs, do_scan_relocs, do_relocate,
do_relocate_sections, relocate_sections, emit_relocs_scan,
emit_relocs_scan_reltype. Change all callers.
(struct Relocate_info): Remove options field and all references to
it.
* reloc.h (class Read_relocs): Remove options constructor
parameter and options_ field. Change all callers.
(class Gc_process_relocs, class Scan_relocs): Likewise.
(class Relocate_task): Likewise.
* target-reloc.h (scan_relocs): Remove options parameter. Change
all callers.
(scan_relocatable_relocs): Likewise.
* target.h (class Sized_target): Remove options parameter from
gc_process_relocs, scan_relocs, scan_relocatable_relocs. Change
all callers.
* gc.h (gc_process_relocs): Remove options parameter. Change all
callers.
* arm.cc: Update functions to remove options parameters.
* i386.cc: Likewise.
* powerpc.cc: Likewise.
* sparc.cc: Likewise.
* x86_64.cc: Likewise.
* testsuite/testfile.cc: Likewise.
2009-10-29 06:16:23 +01:00
|
|
|
: symtab_(symtab), layout_(layout), object_(object), rd_(rd),
|
2010-02-12 05:33:53 +01:00
|
|
|
this_blocker_(this_blocker), next_blocker_(next_blocker)
|
2006-10-20 22:40:49 +02:00
|
|
|
{ }
|
|
|
|
|
2010-02-12 05:33:53 +01:00
|
|
|
~Scan_relocs();
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
// The standard Task methods.
|
|
|
|
|
2007-12-14 20:00:21 +01:00
|
|
|
Task_token*
|
|
|
|
is_runnable();
|
2006-10-20 22:40:49 +02:00
|
|
|
|
2007-12-14 20:00:21 +01:00
|
|
|
void
|
|
|
|
locks(Task_locker*);
|
2006-10-20 22:40:49 +02:00
|
|
|
|
|
|
|
void
|
|
|
|
run(Workqueue*);
|
|
|
|
|
2007-11-22 01:05:51 +01:00
|
|
|
std::string
|
|
|
|
get_name() const;
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
private:
|
|
|
|
Symbol_table* symtab_;
|
2006-11-03 19:26:11 +01:00
|
|
|
Layout* layout_;
|
2006-11-06 23:46:08 +01:00
|
|
|
Relobj* object_;
|
2006-10-20 22:40:49 +02:00
|
|
|
Read_relocs_data* rd_;
|
2010-02-12 05:33:53 +01:00
|
|
|
Task_token* this_blocker_;
|
|
|
|
Task_token* next_blocker_;
|
2006-10-20 22:40:49 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
// A class to perform all the relocations for an object file.
|
|
|
|
|
2006-09-29 21:58:17 +02:00
|
|
|
class Relocate_task : public Task
|
|
|
|
{
|
|
|
|
public:
|
* object.h (class Relobj): Drop options parameter from
gc_process_relocs, scan_relocs, relocate, do_gc_process_relocs,
do_scan_relocs, do_relocate. Change all callers.
(class Sized_relobj): Drop options parameters from
do_gc_process_relocs, do_scan_relocs, do_relocate,
do_relocate_sections, relocate_sections, emit_relocs_scan,
emit_relocs_scan_reltype. Change all callers.
(struct Relocate_info): Remove options field and all references to
it.
* reloc.h (class Read_relocs): Remove options constructor
parameter and options_ field. Change all callers.
(class Gc_process_relocs, class Scan_relocs): Likewise.
(class Relocate_task): Likewise.
* target-reloc.h (scan_relocs): Remove options parameter. Change
all callers.
(scan_relocatable_relocs): Likewise.
* target.h (class Sized_target): Remove options parameter from
gc_process_relocs, scan_relocs, scan_relocatable_relocs. Change
all callers.
* gc.h (gc_process_relocs): Remove options parameter. Change all
callers.
* arm.cc: Update functions to remove options parameters.
* i386.cc: Likewise.
* powerpc.cc: Likewise.
* sparc.cc: Likewise.
* x86_64.cc: Likewise.
* testsuite/testfile.cc: Likewise.
2009-10-29 06:16:23 +01:00
|
|
|
Relocate_task(const Symbol_table* symtab, const Layout* layout,
|
|
|
|
Relobj* object, Output_file* of,
|
2007-11-09 08:00:15 +01:00
|
|
|
Task_token* input_sections_blocker,
|
|
|
|
Task_token* output_sections_blocker, Task_token* final_blocker)
|
* object.h (class Relobj): Drop options parameter from
gc_process_relocs, scan_relocs, relocate, do_gc_process_relocs,
do_scan_relocs, do_relocate. Change all callers.
(class Sized_relobj): Drop options parameters from
do_gc_process_relocs, do_scan_relocs, do_relocate,
do_relocate_sections, relocate_sections, emit_relocs_scan,
emit_relocs_scan_reltype. Change all callers.
(struct Relocate_info): Remove options field and all references to
it.
* reloc.h (class Read_relocs): Remove options constructor
parameter and options_ field. Change all callers.
(class Gc_process_relocs, class Scan_relocs): Likewise.
(class Relocate_task): Likewise.
* target-reloc.h (scan_relocs): Remove options parameter. Change
all callers.
(scan_relocatable_relocs): Likewise.
* target.h (class Sized_target): Remove options parameter from
gc_process_relocs, scan_relocs, scan_relocatable_relocs. Change
all callers.
* gc.h (gc_process_relocs): Remove options parameter. Change all
callers.
* arm.cc: Update functions to remove options parameters.
* i386.cc: Likewise.
* powerpc.cc: Likewise.
* sparc.cc: Likewise.
* x86_64.cc: Likewise.
* testsuite/testfile.cc: Likewise.
2009-10-29 06:16:23 +01:00
|
|
|
: symtab_(symtab), layout_(layout), object_(object), of_(of),
|
|
|
|
input_sections_blocker_(input_sections_blocker),
|
2007-11-09 08:00:15 +01:00
|
|
|
output_sections_blocker_(output_sections_blocker),
|
|
|
|
final_blocker_(final_blocker)
|
2006-09-29 21:58:17 +02:00
|
|
|
{ }
|
|
|
|
|
|
|
|
// The standard Task methods.
|
|
|
|
|
2007-12-14 20:00:21 +01:00
|
|
|
Task_token*
|
|
|
|
is_runnable();
|
2006-09-29 21:58:17 +02:00
|
|
|
|
2007-12-14 20:00:21 +01:00
|
|
|
void
|
|
|
|
locks(Task_locker*);
|
2006-09-29 21:58:17 +02:00
|
|
|
|
|
|
|
void
|
|
|
|
run(Workqueue*);
|
|
|
|
|
2007-11-22 01:05:51 +01:00
|
|
|
std::string
|
|
|
|
get_name() const;
|
|
|
|
|
2006-09-29 21:58:17 +02:00
|
|
|
private:
|
|
|
|
const Symbol_table* symtab_;
|
2006-10-20 22:40:49 +02:00
|
|
|
const Layout* layout_;
|
2006-11-06 23:46:08 +01:00
|
|
|
Relobj* object_;
|
2006-09-29 21:58:17 +02:00
|
|
|
Output_file* of_;
|
2007-11-09 08:00:15 +01:00
|
|
|
Task_token* input_sections_blocker_;
|
|
|
|
Task_token* output_sections_blocker_;
|
2006-09-29 21:58:17 +02:00
|
|
|
Task_token* final_blocker_;
|
|
|
|
};
|
|
|
|
|
2008-02-06 09:13:50 +01:00
|
|
|
// During a relocatable link, this class records how relocations
|
|
|
|
// should be handled for a single input reloc section. An instance of
|
|
|
|
// this class is created while scanning relocs, and it is used while
|
|
|
|
// processing relocs.
|
|
|
|
|
|
|
|
class Relocatable_relocs
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
// We use a vector of unsigned char to indicate how the input relocs
|
|
|
|
// should be handled. Each element is one of the following values.
|
|
|
|
// We create this vector when we initially scan the relocations.
|
|
|
|
enum Reloc_strategy
|
|
|
|
{
|
|
|
|
// Copy the input reloc. Don't modify it other than updating the
|
|
|
|
// r_offset field and the r_sym part of the r_info field.
|
|
|
|
RELOC_COPY,
|
|
|
|
// Copy the input reloc which is against an STT_SECTION symbol.
|
|
|
|
// Update the r_offset and r_sym part of the r_info field. Adjust
|
|
|
|
// the addend by subtracting the value of the old local symbol and
|
|
|
|
// adding the value of the new local symbol. The addend is in the
|
|
|
|
// SHT_RELA reloc and the contents of the data section do not need
|
|
|
|
// to be changed.
|
|
|
|
RELOC_ADJUST_FOR_SECTION_RELA,
|
2008-02-27 23:38:18 +01:00
|
|
|
// Like RELOC_ADJUST_FOR_SECTION_RELA but the addend should not be
|
|
|
|
// adjusted.
|
|
|
|
RELOC_ADJUST_FOR_SECTION_0,
|
2008-02-06 09:13:50 +01:00
|
|
|
// Like RELOC_ADJUST_FOR_SECTION_RELA but the contents of the
|
|
|
|
// section need to be changed. The number indicates the number of
|
|
|
|
// bytes in the addend in the section contents.
|
|
|
|
RELOC_ADJUST_FOR_SECTION_1,
|
|
|
|
RELOC_ADJUST_FOR_SECTION_2,
|
|
|
|
RELOC_ADJUST_FOR_SECTION_4,
|
|
|
|
RELOC_ADJUST_FOR_SECTION_8,
|
2011-11-10 01:41:53 +01:00
|
|
|
// Like RELOC_ADJUST_FOR_SECTION_4 but for unaligned relocs.
|
|
|
|
RELOC_ADJUST_FOR_SECTION_4_UNALIGNED,
|
2008-02-06 09:13:50 +01:00
|
|
|
// Discard the input reloc--process it completely when relocating
|
|
|
|
// the data section contents.
|
|
|
|
RELOC_DISCARD,
|
|
|
|
// An input reloc which is not discarded, but which requires
|
|
|
|
// target specific processing in order to update it.
|
|
|
|
RELOC_SPECIAL
|
|
|
|
};
|
|
|
|
|
|
|
|
Relocatable_relocs()
|
|
|
|
: reloc_strategies_(), output_reloc_count_(0), posd_(NULL)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
// Record the number of relocs.
|
|
|
|
void
|
|
|
|
set_reloc_count(size_t reloc_count)
|
|
|
|
{ this->reloc_strategies_.reserve(reloc_count); }
|
|
|
|
|
|
|
|
// Record what to do for the next reloc.
|
|
|
|
void
|
2009-12-14 20:53:05 +01:00
|
|
|
set_next_reloc_strategy(Reloc_strategy strategy)
|
2008-02-06 09:13:50 +01:00
|
|
|
{
|
2009-12-14 20:53:05 +01:00
|
|
|
this->reloc_strategies_.push_back(static_cast<unsigned char>(strategy));
|
|
|
|
if (strategy != RELOC_DISCARD)
|
2008-02-06 09:13:50 +01:00
|
|
|
++this->output_reloc_count_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Record the Output_data associated with this reloc section.
|
|
|
|
void
|
|
|
|
set_output_data(Output_data* posd)
|
|
|
|
{
|
|
|
|
gold_assert(this->posd_ == NULL);
|
|
|
|
this->posd_ = posd;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the Output_data associated with this reloc section.
|
|
|
|
Output_data*
|
|
|
|
output_data() const
|
|
|
|
{ return this->posd_; }
|
|
|
|
|
|
|
|
// Return what to do for reloc I.
|
|
|
|
Reloc_strategy
|
|
|
|
strategy(unsigned int i) const
|
|
|
|
{
|
|
|
|
gold_assert(i < this->reloc_strategies_.size());
|
|
|
|
return static_cast<Reloc_strategy>(this->reloc_strategies_[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return the number of relocations to create in the output file.
|
|
|
|
size_t
|
|
|
|
output_reloc_count() const
|
|
|
|
{ return this->output_reloc_count_; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
typedef std::vector<unsigned char> Reloc_strategies;
|
|
|
|
|
|
|
|
// The strategies for the input reloc. There is one entry in this
|
|
|
|
// vector for each relocation in the input section.
|
|
|
|
Reloc_strategies reloc_strategies_;
|
|
|
|
// The number of relocations to be created in the output file.
|
|
|
|
size_t output_reloc_count_;
|
|
|
|
// The output data structure associated with this relocation.
|
|
|
|
Output_data* posd_;
|
|
|
|
};
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
// Standard relocation routines which are used on many targets. Here
|
|
|
|
// SIZE and BIG_ENDIAN refer to the target, not the relocation type.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
class Relocate_functions
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
// Do a simple relocation with the addend in the section contents.
|
|
|
|
// VALSIZE is the size of the value.
|
|
|
|
template<int valsize>
|
|
|
|
static inline void
|
2006-11-06 23:46:08 +01:00
|
|
|
rel(unsigned char* view,
|
|
|
|
typename elfcpp::Swap<valsize, big_endian>::Valtype value)
|
2006-10-20 22:40:49 +02:00
|
|
|
{
|
2006-11-06 23:46:08 +01:00
|
|
|
typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
|
2006-10-20 22:40:49 +02:00
|
|
|
Valtype* wv = reinterpret_cast<Valtype*>(view);
|
2006-11-06 23:46:08 +01:00
|
|
|
Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
|
|
|
|
elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value);
|
2006-10-20 22:40:49 +02:00
|
|
|
}
|
|
|
|
|
2011-11-10 21:53:36 +01:00
|
|
|
// Like the above but for relocs at unaligned addresses.
|
|
|
|
template<int valsize>
|
|
|
|
static inline void
|
|
|
|
rel_unaligned(unsigned char* view,
|
|
|
|
typename elfcpp::Swap<valsize, big_endian>::Valtype value)
|
|
|
|
{
|
|
|
|
typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
|
|
|
|
Valtype;
|
|
|
|
Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
|
|
|
|
elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, x + value);
|
|
|
|
}
|
|
|
|
|
2007-05-16 19:42:48 +02:00
|
|
|
// Do a simple relocation using a Symbol_value with the addend in
|
|
|
|
// the section contents. VALSIZE is the size of the value to
|
|
|
|
// relocate.
|
|
|
|
template<int valsize>
|
|
|
|
static inline void
|
|
|
|
rel(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-05-16 19:42:48 +02:00
|
|
|
const Symbol_value<size>* psymval)
|
|
|
|
{
|
|
|
|
typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
|
|
|
|
Valtype* wv = reinterpret_cast<Valtype*>(view);
|
|
|
|
Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
|
|
|
|
x = psymval->value(object, x);
|
|
|
|
elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
|
|
|
|
}
|
|
|
|
|
2011-11-10 01:41:53 +01:00
|
|
|
// Like the above but for relocs at unaligned addresses.
|
|
|
|
template<int valsize>
|
|
|
|
static inline void
|
|
|
|
rel_unaligned(unsigned char* view,
|
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
|
|
|
const Symbol_value<size>* psymval)
|
|
|
|
{
|
|
|
|
typedef typename elfcpp::Swap_unaligned<valsize, big_endian>::Valtype
|
|
|
|
Valtype;
|
|
|
|
Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
|
|
|
|
x = psymval->value(object, x);
|
|
|
|
elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view, x);
|
|
|
|
}
|
|
|
|
|
2007-10-01 02:05:08 +02:00
|
|
|
// Do a simple relocation with the addend in the relocation.
|
|
|
|
// VALSIZE is the size of the value.
|
|
|
|
template<int valsize>
|
|
|
|
static inline void
|
|
|
|
rela(unsigned char* view,
|
|
|
|
typename elfcpp::Swap<valsize, big_endian>::Valtype value,
|
|
|
|
typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
|
|
|
|
{
|
|
|
|
typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
|
|
|
|
Valtype* wv = reinterpret_cast<Valtype*>(view);
|
|
|
|
elfcpp::Swap<valsize, big_endian>::writeval(wv, value + addend);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Do a simple relocation using a symbol value with the addend in
|
|
|
|
// the relocation. VALSIZE is the size of the value.
|
|
|
|
template<int valsize>
|
|
|
|
static inline void
|
|
|
|
rela(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-10-01 02:05:08 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
typename elfcpp::Swap<valsize, big_endian>::Valtype addend)
|
|
|
|
{
|
|
|
|
typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
|
|
|
|
Valtype* wv = reinterpret_cast<Valtype*>(view);
|
|
|
|
Valtype x = psymval->value(object, addend);
|
|
|
|
elfcpp::Swap<valsize, big_endian>::writeval(wv, x);
|
|
|
|
}
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
// Do a simple PC relative relocation with the addend in the section
|
|
|
|
// contents. VALSIZE is the size of the value.
|
|
|
|
template<int valsize>
|
|
|
|
static inline void
|
2006-11-06 23:46:08 +01:00
|
|
|
pcrel(unsigned char* view,
|
|
|
|
typename elfcpp::Swap<valsize, big_endian>::Valtype value,
|
2006-10-20 22:40:49 +02:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{
|
2006-11-06 23:46:08 +01:00
|
|
|
typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
|
2006-10-20 22:40:49 +02:00
|
|
|
Valtype* wv = reinterpret_cast<Valtype*>(view);
|
2006-11-06 23:46:08 +01:00
|
|
|
Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
|
|
|
|
elfcpp::Swap<valsize, big_endian>::writeval(wv, x + value - address);
|
2006-10-20 22:40:49 +02:00
|
|
|
}
|
|
|
|
|
2011-11-10 21:53:36 +01:00
|
|
|
// Like the above but for relocs at unaligned addresses.
|
|
|
|
template<int valsize>
|
|
|
|
static inline void
|
|
|
|
pcrel_unaligned(unsigned char* view,
|
|
|
|
typename elfcpp::Swap<valsize, big_endian>::Valtype value,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{
|
|
|
|
typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
|
|
|
|
Valtype x = elfcpp::Swap_unaligned<valsize, big_endian>::readval(view);
|
|
|
|
elfcpp::Swap_unaligned<valsize, big_endian>::writeval(view,
|
|
|
|
x + value - address);
|
|
|
|
}
|
|
|
|
|
2007-05-16 19:42:48 +02:00
|
|
|
// Do a simple PC relative relocation with a Symbol_value with the
|
|
|
|
// addend in the section contents. VALSIZE is the size of the
|
|
|
|
// value.
|
|
|
|
template<int valsize>
|
|
|
|
static inline void
|
|
|
|
pcrel(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-05-16 19:42:48 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{
|
|
|
|
typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
|
|
|
|
Valtype* wv = reinterpret_cast<Valtype*>(view);
|
|
|
|
Valtype x = elfcpp::Swap<valsize, big_endian>::readval(wv);
|
|
|
|
x = psymval->value(object, x);
|
|
|
|
elfcpp::Swap<valsize, big_endian>::writeval(wv, x - address);
|
|
|
|
}
|
|
|
|
|
2007-10-01 02:05:08 +02:00
|
|
|
// Do a simple PC relative relocation with the addend in the
|
|
|
|
// relocation. VALSIZE is the size of the value.
|
|
|
|
template<int valsize>
|
|
|
|
static inline void
|
|
|
|
pcrela(unsigned char* view,
|
|
|
|
typename elfcpp::Swap<valsize, big_endian>::Valtype value,
|
|
|
|
typename elfcpp::Swap<valsize, big_endian>::Valtype addend,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{
|
|
|
|
typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
|
|
|
|
Valtype* wv = reinterpret_cast<Valtype*>(view);
|
|
|
|
elfcpp::Swap<valsize, big_endian>::writeval(wv, value + addend - address);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Do a simple PC relative relocation with a Symbol_value with the
|
|
|
|
// addend in the relocation. VALSIZE is the size of the value.
|
|
|
|
template<int valsize>
|
|
|
|
static inline void
|
|
|
|
pcrela(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-10-01 02:05:08 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
typename elfcpp::Swap<valsize, big_endian>::Valtype addend,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{
|
|
|
|
typedef typename elfcpp::Swap<valsize, big_endian>::Valtype Valtype;
|
|
|
|
Valtype* wv = reinterpret_cast<Valtype*>(view);
|
|
|
|
Valtype x = psymval->value(object, addend);
|
|
|
|
elfcpp::Swap<valsize, big_endian>::writeval(wv, x - address);
|
|
|
|
}
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
typedef Relocate_functions<size, big_endian> This;
|
|
|
|
|
|
|
|
public:
|
2007-05-16 19:42:48 +02:00
|
|
|
// Do a simple 8-bit REL relocation with the addend in the section
|
|
|
|
// contents.
|
2006-10-20 22:40:49 +02:00
|
|
|
static inline void
|
|
|
|
rel8(unsigned char* view, unsigned char value)
|
2007-05-16 19:42:48 +02:00
|
|
|
{ This::template rel<8>(view, value); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
rel8(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-05-16 19:42:48 +02:00
|
|
|
const Symbol_value<size>* psymval)
|
|
|
|
{ This::template rel<8>(view, object, psymval); }
|
2006-10-20 22:40:49 +02:00
|
|
|
|
2007-10-01 02:05:08 +02:00
|
|
|
// Do an 8-bit RELA relocation with the addend in the relocation.
|
|
|
|
static inline void
|
2007-10-01 23:25:23 +02:00
|
|
|
rela8(unsigned char* view, unsigned char value, unsigned char addend)
|
2007-10-01 02:05:08 +02:00
|
|
|
{ This::template rela<8>(view, value, addend); }
|
|
|
|
|
|
|
|
static inline void
|
2007-10-01 23:25:23 +02:00
|
|
|
rela8(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-10-01 02:05:08 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
unsigned char addend)
|
|
|
|
{ This::template rela<8>(view, object, psymval, addend); }
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
// Do a simple 8-bit PC relative relocation with the addend in the
|
2007-05-16 19:42:48 +02:00
|
|
|
// section contents.
|
2006-10-20 22:40:49 +02:00
|
|
|
static inline void
|
|
|
|
pcrel8(unsigned char* view, unsigned char value,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
2007-05-16 19:42:48 +02:00
|
|
|
{ This::template pcrel<8>(view, value, address); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
pcrel8(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-05-16 19:42:48 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrel<8>(view, object, psymval, address); }
|
2006-10-20 22:40:49 +02:00
|
|
|
|
2007-10-01 02:05:08 +02:00
|
|
|
// Do a simple 8-bit PC relative RELA relocation with the addend in
|
|
|
|
// the reloc.
|
|
|
|
static inline void
|
|
|
|
pcrela8(unsigned char* view, unsigned char value, unsigned char addend,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrela<8>(view, value, addend, address); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
pcrela8(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-10-01 02:05:08 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
unsigned char addend,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrela<8>(view, object, psymval, addend, address); }
|
|
|
|
|
2007-05-16 19:42:48 +02:00
|
|
|
// Do a simple 16-bit REL relocation with the addend in the section
|
|
|
|
// contents.
|
2006-10-20 22:40:49 +02:00
|
|
|
static inline void
|
|
|
|
rel16(unsigned char* view, elfcpp::Elf_Half value)
|
2007-05-16 19:42:48 +02:00
|
|
|
{ This::template rel<16>(view, value); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
rel16(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-05-16 19:42:48 +02:00
|
|
|
const Symbol_value<size>* psymval)
|
|
|
|
{ This::template rel<16>(view, object, psymval); }
|
2006-10-20 22:40:49 +02:00
|
|
|
|
2007-10-01 02:05:08 +02:00
|
|
|
// Do an 16-bit RELA relocation with the addend in the relocation.
|
|
|
|
static inline void
|
|
|
|
rela16(unsigned char* view, elfcpp::Elf_Half value, elfcpp::Elf_Half addend)
|
|
|
|
{ This::template rela<16>(view, value, addend); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
rela16(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-10-01 02:05:08 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
elfcpp::Elf_Half addend)
|
|
|
|
{ This::template rela<16>(view, object, psymval, addend); }
|
|
|
|
|
|
|
|
// Do a simple 16-bit PC relative REL relocation with the addend in
|
2007-05-16 19:42:48 +02:00
|
|
|
// the section contents.
|
2006-10-20 22:40:49 +02:00
|
|
|
static inline void
|
2007-10-01 02:05:08 +02:00
|
|
|
pcrel16(unsigned char* view, elfcpp::Elf_Half value,
|
2006-10-20 22:40:49 +02:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
2007-05-16 19:42:48 +02:00
|
|
|
{ This::template pcrel<16>(view, value, address); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
pcrel16(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-05-16 19:42:48 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrel<16>(view, object, psymval, address); }
|
2006-10-20 22:40:49 +02:00
|
|
|
|
2007-10-01 02:05:08 +02:00
|
|
|
// Do a simple 16-bit PC relative RELA relocation with the addend in
|
|
|
|
// the reloc.
|
|
|
|
static inline void
|
|
|
|
pcrela16(unsigned char* view, elfcpp::Elf_Half value,
|
|
|
|
elfcpp::Elf_Half addend,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrela<16>(view, value, addend, address); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
pcrela16(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-10-01 02:05:08 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
elfcpp::Elf_Half addend,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrela<16>(view, object, psymval, addend, address); }
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
// Do a simple 32-bit REL relocation with the addend in the section
|
|
|
|
// contents.
|
|
|
|
static inline void
|
|
|
|
rel32(unsigned char* view, elfcpp::Elf_Word value)
|
2007-05-16 19:42:48 +02:00
|
|
|
{ This::template rel<32>(view, value); }
|
|
|
|
|
2011-11-10 21:53:36 +01:00
|
|
|
// Like above but for relocs at unaligned addresses.
|
|
|
|
static inline void
|
|
|
|
rel32_unaligned(unsigned char* view, elfcpp::Elf_Word value)
|
|
|
|
{ This::template rel_unaligned<32>(view, value); }
|
|
|
|
|
2007-05-16 19:42:48 +02:00
|
|
|
static inline void
|
|
|
|
rel32(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-05-16 19:42:48 +02:00
|
|
|
const Symbol_value<size>* psymval)
|
|
|
|
{ This::template rel<32>(view, object, psymval); }
|
2006-10-20 22:40:49 +02:00
|
|
|
|
2011-11-10 01:41:53 +01:00
|
|
|
// Like above but for relocs at unaligned addresses.
|
|
|
|
static inline void
|
|
|
|
rel32_unaligned(unsigned char* view,
|
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
|
|
|
const Symbol_value<size>* psymval)
|
|
|
|
{ This::template rel_unaligned<32>(view, object, psymval); }
|
|
|
|
|
2007-10-01 02:05:08 +02:00
|
|
|
// Do an 32-bit RELA relocation with the addend in the relocation.
|
|
|
|
static inline void
|
|
|
|
rela32(unsigned char* view, elfcpp::Elf_Word value, elfcpp::Elf_Word addend)
|
|
|
|
{ This::template rela<32>(view, value, addend); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
rela32(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-10-01 02:05:08 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
elfcpp::Elf_Word addend)
|
|
|
|
{ This::template rela<32>(view, object, psymval, addend); }
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
// Do a simple 32-bit PC relative REL relocation with the addend in
|
|
|
|
// the section contents.
|
|
|
|
static inline void
|
|
|
|
pcrel32(unsigned char* view, elfcpp::Elf_Word value,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
2007-05-16 19:42:48 +02:00
|
|
|
{ This::template pcrel<32>(view, value, address); }
|
|
|
|
|
2011-11-10 21:53:36 +01:00
|
|
|
// Unaligned version of the above.
|
|
|
|
static inline void
|
|
|
|
pcrel32_unaligned(unsigned char* view, elfcpp::Elf_Word value,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrel_unaligned<32>(view, value, address); }
|
|
|
|
|
2007-05-16 19:42:48 +02:00
|
|
|
static inline void
|
|
|
|
pcrel32(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-05-16 19:42:48 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrel<32>(view, object, psymval, address); }
|
2006-10-20 22:40:49 +02:00
|
|
|
|
2007-10-01 02:05:08 +02:00
|
|
|
// Do a simple 32-bit PC relative RELA relocation with the addend in
|
|
|
|
// the relocation.
|
|
|
|
static inline void
|
|
|
|
pcrela32(unsigned char* view, elfcpp::Elf_Word value,
|
|
|
|
elfcpp::Elf_Word addend,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrela<32>(view, value, addend, address); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
pcrela32(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-10-01 02:05:08 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
elfcpp::Elf_Word addend,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrela<32>(view, object, psymval, addend, address); }
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
// Do a simple 64-bit REL relocation with the addend in the section
|
|
|
|
// contents.
|
|
|
|
static inline void
|
2006-11-06 23:46:08 +01:00
|
|
|
rel64(unsigned char* view, elfcpp::Elf_Xword value)
|
2007-05-16 19:42:48 +02:00
|
|
|
{ This::template rel<64>(view, value); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
rel64(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-05-16 19:42:48 +02:00
|
|
|
const Symbol_value<size>* psymval)
|
|
|
|
{ This::template rel<64>(view, object, psymval); }
|
2006-10-20 22:40:49 +02:00
|
|
|
|
2007-10-01 02:05:08 +02:00
|
|
|
// Do a 64-bit RELA relocation with the addend in the relocation.
|
|
|
|
static inline void
|
|
|
|
rela64(unsigned char* view, elfcpp::Elf_Xword value,
|
|
|
|
elfcpp::Elf_Xword addend)
|
|
|
|
{ This::template rela<64>(view, value, addend); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
rela64(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-10-01 02:05:08 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
elfcpp::Elf_Xword addend)
|
|
|
|
{ This::template rela<64>(view, object, psymval, addend); }
|
|
|
|
|
2006-10-20 22:40:49 +02:00
|
|
|
// Do a simple 64-bit PC relative REL relocation with the addend in
|
|
|
|
// the section contents.
|
|
|
|
static inline void
|
2006-11-06 23:46:08 +01:00
|
|
|
pcrel64(unsigned char* view, elfcpp::Elf_Xword value,
|
2006-10-20 22:40:49 +02:00
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
2007-05-16 19:42:48 +02:00
|
|
|
{ This::template pcrel<64>(view, value, address); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
pcrel64(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-05-16 19:42:48 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrel<64>(view, object, psymval, address); }
|
2007-10-01 02:05:08 +02:00
|
|
|
|
|
|
|
// Do a simple 64-bit PC relative RELA relocation with the addend in
|
|
|
|
// the relocation.
|
|
|
|
static inline void
|
|
|
|
pcrela64(unsigned char* view, elfcpp::Elf_Xword value,
|
|
|
|
elfcpp::Elf_Xword addend,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrela<64>(view, value, addend, address); }
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
pcrela64(unsigned char* view,
|
2011-05-24 23:41:10 +02:00
|
|
|
const Sized_relobj_file<size, big_endian>* object,
|
2007-10-01 02:05:08 +02:00
|
|
|
const Symbol_value<size>* psymval,
|
|
|
|
elfcpp::Elf_Xword addend,
|
|
|
|
typename elfcpp::Elf_types<size>::Elf_Addr address)
|
|
|
|
{ This::template pcrela<64>(view, object, psymval, addend, address); }
|
2006-12-01 00:52:50 +01:00
|
|
|
};
|
|
|
|
|
2012-01-28 02:47:01 +01:00
|
|
|
// Integer manipulation functions used by various targets when
|
|
|
|
// performing relocations.
|
|
|
|
|
|
|
|
template<int bits>
|
|
|
|
class Bits
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
// Sign extend an n-bit unsigned integer stored in a uint32_t into
|
|
|
|
// an int32_t. BITS must be between 0 and 32.
|
|
|
|
static inline int32_t
|
|
|
|
sign_extend32(uint32_t val)
|
|
|
|
{
|
|
|
|
gold_assert(bits >= 0 && bits <= 32);
|
|
|
|
if (bits == 32)
|
|
|
|
return static_cast<int32_t>(val);
|
|
|
|
uint32_t mask = (~static_cast<uint32_t>(0)) >> (32 - bits);
|
|
|
|
val &= mask;
|
|
|
|
uint32_t top_bit = 1U << (bits - 1);
|
|
|
|
int32_t as_signed = static_cast<int32_t>(val);
|
|
|
|
if ((val & top_bit) != 0)
|
|
|
|
as_signed -= static_cast<int32_t>(top_bit * 2);
|
|
|
|
return as_signed;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return true if VAL (stored in a uint32_t) has overflowed a signed
|
|
|
|
// value with BITS bits.
|
|
|
|
static inline bool
|
|
|
|
has_overflow32(uint32_t val)
|
|
|
|
{
|
|
|
|
gold_assert(bits >= 0 && bits <= 32);
|
|
|
|
if (bits == 32)
|
|
|
|
return false;
|
|
|
|
int32_t max = (1 << (bits - 1)) - 1;
|
|
|
|
int32_t min = -(1 << (bits - 1));
|
|
|
|
int32_t as_signed = static_cast<int32_t>(val);
|
|
|
|
return as_signed > max || as_signed < min;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return true if VAL (stored in a uint32_t) has overflowed both a
|
|
|
|
// signed and an unsigned value. E.g.,
|
|
|
|
// Bits<8>::has_signed_unsigned_overflow32 would check -128 <= VAL <
|
|
|
|
// 255.
|
|
|
|
static inline bool
|
|
|
|
has_signed_unsigned_overflow32(uint32_t val)
|
|
|
|
{
|
|
|
|
gold_assert(bits >= 0 && bits <= 32);
|
|
|
|
if (bits == 32)
|
|
|
|
return false;
|
|
|
|
int32_t max = static_cast<int32_t>((1U << bits) - 1);
|
|
|
|
int32_t min = -(1 << (bits - 1));
|
|
|
|
int32_t as_signed = static_cast<int32_t>(val);
|
|
|
|
return as_signed > max || as_signed < min;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Select bits from A and B using bits in MASK. For each n in
|
|
|
|
// [0..31], the n-th bit in the result is chosen from the n-th bits
|
|
|
|
// of A and B. A zero selects A and a one selects B.
|
|
|
|
static inline uint32_t
|
|
|
|
bit_select32(uint32_t a, uint32_t b, uint32_t mask)
|
|
|
|
{ return (a & ~mask) | (b & mask); }
|
|
|
|
|
|
|
|
// Sign extend an n-bit unsigned integer stored in a uint64_t into
|
|
|
|
// an int64_t. BITS must be between 0 and 64.
|
|
|
|
static inline int64_t
|
|
|
|
sign_extend(uint64_t val)
|
|
|
|
{
|
|
|
|
gold_assert(bits >= 0 && bits <= 64);
|
|
|
|
if (bits == 64)
|
|
|
|
return static_cast<int64_t>(val);
|
|
|
|
uint64_t mask = (~static_cast<uint64_t>(0)) >> (64 - bits);
|
|
|
|
val &= mask;
|
|
|
|
uint64_t top_bit = static_cast<uint64_t>(1) << (bits - 1);
|
|
|
|
int64_t as_signed = static_cast<int64_t>(val);
|
|
|
|
if ((val & top_bit) != 0)
|
|
|
|
as_signed -= static_cast<int64_t>(top_bit * 2);
|
|
|
|
return as_signed;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return true if VAL (stored in a uint64_t) has overflowed a signed
|
|
|
|
// value with BITS bits.
|
|
|
|
static inline bool
|
|
|
|
has_overflow(uint64_t val)
|
|
|
|
{
|
|
|
|
gold_assert(bits >= 0 && bits <= 64);
|
|
|
|
if (bits == 64)
|
|
|
|
return false;
|
|
|
|
int64_t max = (static_cast<int64_t>(1) << (bits - 1)) - 1;
|
|
|
|
int64_t min = -(static_cast<int64_t>(1) << (bits - 1));
|
|
|
|
int64_t as_signed = static_cast<int64_t>(val);
|
|
|
|
return as_signed > max || as_signed < min;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Return true if VAL (stored in a uint64_t) has overflowed both a
|
|
|
|
// signed and an unsigned value. E.g.,
|
|
|
|
// Bits<8>::has_signed_unsigned_overflow would check -128 <= VAL <
|
|
|
|
// 255.
|
|
|
|
static inline bool
|
|
|
|
has_signed_unsigned_overflow64(uint64_t val)
|
|
|
|
{
|
|
|
|
gold_assert(bits >= 0 && bits <= 64);
|
|
|
|
if (bits == 64)
|
|
|
|
return false;
|
|
|
|
int64_t max = static_cast<int64_t>((static_cast<uint64_t>(1) << bits) - 1);
|
|
|
|
int64_t min = -(static_cast<int64_t>(1) << (bits - 1));
|
|
|
|
int64_t as_signed = static_cast<int64_t>(val);
|
|
|
|
return as_signed > max || as_signed < min;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Select bits from A and B using bits in MASK. For each n in
|
|
|
|
// [0..31], the n-th bit in the result is chosen from the n-th bits
|
|
|
|
// of A and B. A zero selects A and a one selects B.
|
|
|
|
static inline uint64_t
|
|
|
|
bit_select64(uint64_t a, uint64_t b, uint64_t mask)
|
|
|
|
{ return (a & ~mask) | (b & mask); }
|
|
|
|
};
|
|
|
|
|
2007-11-09 08:00:15 +01:00
|
|
|
// Track relocations while reading a section. This lets you ask for
|
|
|
|
// the relocation at a certain offset, and see how relocs occur
|
|
|
|
// between points of interest.
|
|
|
|
|
|
|
|
template<int size, bool big_endian>
|
|
|
|
class Track_relocs
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Track_relocs()
|
2007-11-12 21:35:21 +01:00
|
|
|
: prelocs_(NULL), len_(0), pos_(0), reloc_size_(0)
|
2007-11-09 08:00:15 +01:00
|
|
|
{ }
|
|
|
|
|
|
|
|
// Initialize the Track_relocs object. OBJECT is the object holding
|
|
|
|
// the reloc section, RELOC_SHNDX is the section index of the reloc
|
|
|
|
// section, and RELOC_TYPE is the type of the reloc section
|
|
|
|
// (elfcpp::SHT_REL or elfcpp::SHT_RELA). This returns false if
|
|
|
|
// something went wrong.
|
|
|
|
bool
|
2007-11-12 21:35:21 +01:00
|
|
|
initialize(Object* object, unsigned int reloc_shndx,
|
2007-11-09 08:00:15 +01:00
|
|
|
unsigned int reloc_type);
|
|
|
|
|
|
|
|
// Return the offset in the data section to which the next reloc
|
2010-12-01 20:49:22 +01:00
|
|
|
// applies. This returns -1 if there is no next reloc.
|
2007-11-09 08:00:15 +01:00
|
|
|
off_t
|
|
|
|
next_offset() const;
|
|
|
|
|
|
|
|
// Return the symbol index of the next reloc. This returns -1U if
|
|
|
|
// there is no next reloc.
|
|
|
|
unsigned int
|
|
|
|
next_symndx() const;
|
|
|
|
|
2010-12-01 20:49:22 +01:00
|
|
|
// Return the addend of the next reloc. This returns 0 if there is
|
|
|
|
// no next reloc.
|
|
|
|
uint64_t
|
|
|
|
next_addend() const;
|
|
|
|
|
2007-11-09 08:00:15 +01:00
|
|
|
// Advance to OFFSET within the data section, and return the number
|
|
|
|
// of relocs which would be skipped.
|
|
|
|
int
|
|
|
|
advance(off_t offset);
|
|
|
|
|
|
|
|
private:
|
2007-11-12 21:35:21 +01:00
|
|
|
// The contents of the input object's reloc section.
|
2007-11-09 08:00:15 +01:00
|
|
|
const unsigned char* prelocs_;
|
|
|
|
// The length of the reloc section.
|
2007-12-18 01:48:04 +01:00
|
|
|
section_size_type len_;
|
2007-11-09 08:00:15 +01:00
|
|
|
// Our current position in the reloc section.
|
2007-12-18 01:48:04 +01:00
|
|
|
section_size_type pos_;
|
2007-11-09 08:00:15 +01:00
|
|
|
// The size of the relocs in the section.
|
|
|
|
int reloc_size_;
|
|
|
|
};
|
|
|
|
|
2006-09-29 21:58:17 +02:00
|
|
|
} // End namespace gold.
|
|
|
|
|
|
|
|
#endif // !defined(GOLD_RELOC_H)
|