{

public:

// Types of instruction templates.

enum Type

{

THUMB16_TYPE = 1,

// THUMB16_SPECIAL_TYPE is used by sub-classes of Stub for instruction

// templates with class-specific semantics. Currently this is used

// only by the Cortex_a8_stub class for handling condition codes in

// conditional branches.

THUMB16_SPECIAL_TYPE,

THUMB32_TYPE,

ARM_TYPE,

DATA_TYPE

};

// Factory methods to create instruction templates in different formats.

static const Insn_template

thumb16_insn(uint32_t data)

{ return Insn_template(data, THUMB16_TYPE, elfcpp::R_ARM_NONE, 0); }

// A Thumb conditional branch, in which the proper condition is inserted

// when we build the stub.

static const Insn_template

thumb16_bcond_insn(uint32_t data)

{ return Insn_template(data, THUMB16_SPECIAL_TYPE, elfcpp::R_ARM_NONE, 1); }

static const Insn_template

thumb32_insn(uint32_t data)

{ return Insn_template(data, THUMB32_TYPE, elfcpp::R_ARM_NONE, 0); }

static const Insn_template

thumb32_b_insn(uint32_t data, int reloc_addend)

{

return Insn_template(data, THUMB32_TYPE, elfcpp::R_ARM_THM_JUMP24,

reloc_addend);

}

static const Insn_template

arm_insn(uint32_t data)

{ return Insn_template(data, ARM_TYPE, elfcpp::R_ARM_NONE, 0); }

static const Insn_template

arm_rel_insn(unsigned data, int reloc_addend)

{ return Insn_template(data, ARM_TYPE, elfcpp::R_ARM_JUMP24, reloc_addend); }

static const Insn_template

data_word(unsigned data, unsigned int r_type, int reloc_addend)

{ return Insn_template(data, DATA_TYPE, r_type, reloc_addend); }

// Accessors. This class is used for read-only objects so no modifiers

// are provided.

uint32_t

data() const

{ return this->data_; }

// Return the instruction sequence type of this.

Type

type() const

{ return this->type_; }

// Return the ARM relocation type of this.

unsigned int

r_type() const

{ return this->r_type_; }

int32_t

reloc_addend() const

{ return this->reloc_addend_; }

// Return size of instruction template in bytes.

size_t

size() const;

// Return byte-alignment of instruction template.

unsigned

alignment() const;

private:

// We make the constructor private to ensure that only the factory

// methods are used.

inline

Insn_template(unsigned data, Type type, unsigned int r_type, int reloc_addend)

: data_(data), type_(type), r_type_(r_type), reloc_addend_(reloc_addend)

{ }

// Instruction specific data. This is used to store information like

// some of the instruction bits.

uint32_t data_;

// Instruction template type.

Type type_;

// Relocation type if there is a relocation or R_ARM_NONE otherwise.

unsigned int r_type_;

// Relocation addend.

int32_t reloc_addend_;

{

public:

Stub_template(Stub_type, const Insn_template*, size_t);

~Stub_template()

{ }

// Return stub type.

Stub_type

type() const

{ return this->type_; }

// Return an array of instruction templates.

const Insn_template*

insns() const

{ return this->insns_; }

// Return size of template in number of instructions.

size_t

insn_count() const

{ return this->insn_count_; }

// Return size of template in bytes.

size_t

size() const

{ return this->size_; }

// Return alignment of the stub template.

unsigned

alignment() const

{ return this->alignment_; }

// Return whether entry point is in thumb mode.

bool

entry_in_thumb_mode() const

{ return this->entry_in_thumb_mode_; }

// Return number of relocations in this template.

size_t

reloc_count() const

{ return this->relocs_.size(); }

// Return index of the I-th instruction with relocation.

size_t

reloc_insn_index(size_t i) const

{

gold_assert(i < this->relocs_.size());

return this->relocs_[i].first;

}

// Return the offset of the I-th instruction with relocation from the

// beginning of the stub.

section_size_type

reloc_offset(size_t i) const

{

gold_assert(i < this->relocs_.size());

return this->relocs_[i].second;

}

private:

// This contains information about an instruction template with a relocation

// and its offset from start of stub.

typedef std::pair<size_t, section_size_type> Reloc;

// A Stub_template may not be copied. We want to share templates as much

// as possible.

Stub_template(const Stub_template&);

Stub_template& operator=(const Stub_template&);

// Stub type.

Stub_type type_;

// Points to an array of Insn_templates.

const Insn_template* insns_;

// Number of Insn_templates in insns_[].

size_t insn_count_;

// Size of templated instructions in bytes.

size_t size_;

// Alignment of templated instructions.

unsigned alignment_;

// Flag to indicate if entry is in thumb mode.

bool entry_in_thumb_mode_;

// A table of reloc instruction indices and offsets. We can find these by

// looking at the instruction templates but we pre-compute and then stash

// them here for speed.

std::vector<Reloc> relocs_;

{

private:

static const section_offset_type invalid_offset =

static_cast<section_offset_type>(-1);

public:

Stub(const Stub_template* stub_template)

: stub_template_(stub_template), offset_(invalid_offset)

{ }

virtual

~Stub()

{ }

// Return the stub template.

const Stub_template*

stub_template() const

{ return this->stub_template_; }

// Return offset of code stub from beginning of its containing stub table.

section_offset_type

offset() const

{

gold_assert(this->offset_ != invalid_offset);

return this->offset_;

}

// Set offset of code stub from beginning of its containing stub table.

void

set_offset(section_offset_type offset)

{ this->offset_ = offset; }

// Return the relocation target address of the i-th relocation in the

// stub. This must be defined in a child class.

Arm_address

reloc_target(size_t i)

{ return this->do_reloc_target(i); }

// Write a stub at output VIEW. BIG_ENDIAN select how a stub is written.

void

write(unsigned char* view, section_size_type view_size, bool big_endian)

{ this->do_write(view, view_size, big_endian); }

// Return the instruction for THUMB16_SPECIAL_TYPE instruction template

// for the i-th instruction.

uint16_t

thumb16_special(size_t i)

{ return this->do_thumb16_special(i); }

protected:

// This must be defined in the child class.

virtual Arm_address

do_reloc_target(size_t) = 0;

// This may be overridden in the child class.

virtual void

do_write(unsigned char* view, section_size_type view_size, bool big_endian)

{

if (big_endian)

this->do_fixed_endian_write<true>(view, view_size);

else

this->do_fixed_endian_write<false>(view, view_size);

}

// This must be overridden if a child class uses the THUMB16_SPECIAL_TYPE

// instruction template.

virtual uint16_t

do_thumb16_special(size_t)

{ gold_unreachable(); }

private:

// A template to implement do_write.

template<bool big_endian>

void inline

do_fixed_endian_write(unsigned char*, section_size_type);

// Its template.

const Stub_template* stub_template_;

// Offset within the section of containing this stub.

section_offset_type offset_;

{

public:

static const unsigned int invalid_index = static_cast<unsigned int>(-1);

// We assume we never jump to this address.

static const Arm_address invalid_address = static_cast<Arm_address>(-1);

// Return destination address.

Arm_address

destination_address() const

{

gold_assert(this->destination_address_ != this->invalid_address);

return this->destination_address_;

}

// Set destination address.

void

set_destination_address(Arm_address address)

{

gold_assert(address != this->invalid_address);

this->destination_address_ = address;

}

// Reset destination address.

void

reset_destination_address()

{ this->destination_address_ = this->invalid_address; }

// Determine stub type for a branch of a relocation of R_TYPE going

// from BRANCH_ADDRESS to BRANCH_TARGET. If TARGET_IS_THUMB is set,

// the branch target is a thumb instruction. TARGET is used for look

// up ARM-specific linker settings.

static Stub_type

stub_type_for_reloc(unsigned int r_type, Arm_address branch_address,

Arm_address branch_target, bool target_is_thumb);

// Reloc_stub key. A key is logically a triplet of a stub type, a symbol

// and an addend. Since we treat global and local symbol differently, we

// use a Symbol object for a global symbol and a object-index pair for

// a local symbol.

class Key

{

public:

// If SYMBOL is not null, this is a global symbol, we ignore RELOBJ and

// R_SYM. Otherwise, this is a local symbol and RELOBJ must non-NULL

// and R_SYM must not be invalid_index.

Key(Stub_type stub_type, const Symbol* symbol, const Relobj* relobj,

unsigned int r_sym, int32_t addend)

: stub_type_(stub_type), addend_(addend)

{

if (symbol != NULL)

{

this->r_sym_ = Reloc_stub::invalid_index;

this->u_.symbol = symbol;

}

else

{

gold_assert(relobj != NULL && r_sym != invalid_index);

this->r_sym_ = r_sym;

this->u_.relobj = relobj;

}

}

~Key()

{ }

// Accessors: Keys are meant to be read-only object so no modifiers are

// provided.

// Return stub type.

Stub_type

stub_type() const

{ return this->stub_type_; }

// Return the local symbol index or invalid_index.

unsigned int

r_sym() const

{ return this->r_sym_; }

// Return the symbol if there is one.

const Symbol*

symbol() const

{ return this->r_sym_ == invalid_index ? this->u_.symbol : NULL; }

// Return the relobj if there is one.

const Relobj*

relobj() const

{ return this->r_sym_ != invalid_index ? this->u_.relobj : NULL; }

// Whether this equals to another key k.

bool

eq(const Key& k) const

{

return ((this->stub_type_ == k.stub_type_)

&& (this->r_sym_ == k.r_sym_)

&& ((this->r_sym_ != Reloc_stub::invalid_index)

? (this->u_.relobj == k.u_.relobj)

: (this->u_.symbol == k.u_.symbol))

&& (this->addend_ == k.addend_));

}

// Return a hash value.

size_t

hash_value() const

{

return (this->stub_type_

^ this->r_sym_

^ gold::string_hash<char>(

(this->r_sym_ != Reloc_stub::invalid_index)

? this->u_.relobj->name().c_str()

: this->u_.symbol->name())

^ this->addend_);

}

// Functors for STL associative containers.

struct hash

{

size_t

operator()(const Key& k) const

{ return k.hash_value(); }

};

struct equal_to

{

bool

operator()(const Key& k1, const Key& k2) const

{ return k1.eq(k2); }

};

// Name of key. This is mainly for debugging.

std::string

name() const;

private:

// Stub type.

Stub_type stub_type_;

// If this is a local symbol, this is the index in the defining object.

// Otherwise, it is invalid_index for a global symbol.

unsigned int r_sym_;

// If r_sym_ is an invalid index, this points to a global symbol.

// Otherwise, it points to a relobj. We used the unsized and target

// independent Symbol and Relobj classes instead of Sized_symbol<32> and

// Arm_relobj, in order to avoid making the stub class a template

// as most of the stub machinery is endianness-neutral. However, it

// may require a bit of casting done by users of this class.

union

{

const Symbol* symbol;

const Relobj* relobj;

} u_;

// Addend associated with a reloc.

int32_t addend_;

};

protected:

// Reloc_stubs are created via a stub factory. So these are protected.

Reloc_stub(const Stub_template* stub_template)

: Stub(stub_template), destination_address_(invalid_address)

{ }

~Reloc_stub()

{ }

friend class Stub_factory;

// Return the relocation target address of the i-th relocation in the

// stub.

Arm_address

do_reloc_target(size_t i)

{

// All reloc stub have only one relocation.

gold_assert(i == 0);

return this->destination_address_;

}

private:

// Address of destination.

Arm_address destination_address_;

{

public:

~Cortex_a8_stub()

{ }

// Return the object of the code section containing the branch being fixed

// up.

Relobj*

relobj() const

{ return this->relobj_; }

// Return the section index of the code section containing the branch being

// fixed up.

unsigned int

shndx() const

{ return this->shndx_; }

// Return the source address of stub. This is the address of the original

// branch instruction. LSB is 1 always set to indicate that it is a THUMB

// instruction.

Arm_address

source_address() const

{ return this->source_address_; }

// Return the destination address of the stub. This is the branch taken

// address of the original branch instruction. LSB is 1 if it is a THUMB

// instruction address.

Arm_address

destination_address() const

{ return this->destination_address_; }

// Return the instruction being fixed up.

uint32_t

original_insn() const

{ return this->original_insn_; }

protected:

// Cortex_a8_stubs are created via a stub factory. So these are protected.

Cortex_a8_stub(const Stub_template* stub_template, Relobj* relobj,

unsigned int shndx, Arm_address source_address,

Arm_address destination_address, uint32_t original_insn)

: Stub(stub_template), relobj_(relobj), shndx_(shndx),

source_address_(source_address | 1U),

destination_address_(destination_address),

original_insn_(original_insn)

{ }

friend class Stub_factory;

// Return the relocation target address of the i-th relocation in the

// stub.

Arm_address

do_reloc_target(size_t i)

{

if (this->stub_template()->type() == arm_stub_a8_veneer_b_cond)

{

// The conditional branch veneer has two relocations.

gold_assert(i < 2);

return i == 0 ? this->source_address_ + 4 : this->destination_address_;

}

else

{

// All other Cortex-A8 stubs have only one relocation.

gold_assert(i == 0);

return this->destination_address_;

}

}

// Return an instruction for the THUMB16_SPECIAL_TYPE instruction template.

uint16_t

do_thumb16_special(size_t);

private:

// Object of the code section containing the branch being fixed up.

Relobj* relobj_;

// Section index of the code section containing the branch begin fixed up.

unsigned int shndx_;

// Source address of original branch.

Arm_address source_address_;

// Destination address of the original branch.

Arm_address destination_address_;

// Original branch instruction. This is needed for copying the condition

// code from a condition branch to its stub.

uint32_t original_insn_;

{

public:

~Arm_v4bx_stub()

{ }

// Return the associated register.

uint32_t

reg() const

{ return this->reg_; }

protected:

// Arm V4BX stubs are created via a stub factory. So these are protected.

Arm_v4bx_stub(const Stub_template* stub_template, const uint32_t reg)

: Stub(stub_template), reg_(reg)

{ }

friend class Stub_factory;

// Return the relocation target address of the i-th relocation in the

// stub.

Arm_address

do_reloc_target(size_t)

{ gold_unreachable(); }

// This may be overridden in the child class.

virtual void

do_write(unsigned char* view, section_size_type view_size, bool big_endian)

{

if (big_endian)

this->do_fixed_endian_v4bx_write<true>(view, view_size);

else

this->do_fixed_endian_v4bx_write<false>(view, view_size);

}

private:

// A template to implement do_write.

template<bool big_endian>

void inline

do_fixed_endian_v4bx_write(unsigned char* view, section_size_type)

{

const Insn_template* insns = this->stub_template()->insns();

elfcpp::Swap<32, big_endian>::writeval(view,

(insns[0].data()

+ (this->reg_ << 16)));

view += insns[0].size();

elfcpp::Swap<32, big_endian>::writeval(view,

(insns[1].data() + this->reg_));

view += insns[1].size();

elfcpp::Swap<32, big_endian>::writeval(view,

(insns[2].data() + this->reg_));

}

// A register index (r0-r14), which is associated with the stub.

uint32_t reg_;

{

public:

// Return the unique instance of this class.

static const Stub_factory&

get_instance()

{

static Stub_factory singleton;

return singleton;

}

// Make a relocation stub.

Reloc_stub*

make_reloc_stub(Stub_type stub_type) const

{

gold_assert(stub_type >= arm_stub_reloc_first

&& stub_type <= arm_stub_reloc_last);

return new Reloc_stub(this->stub_templates_[stub_type]);

}

// Make a Cortex-A8 stub.

Cortex_a8_stub*

make_cortex_a8_stub(Stub_type stub_type, Relobj* relobj, unsigned int shndx,

Arm_address source, Arm_address destination,

uint32_t original_insn) const

{

gold_assert(stub_type >= arm_stub_cortex_a8_first

&& stub_type <= arm_stub_cortex_a8_last);

return new Cortex_a8_stub(this->stub_templates_[stub_type], relobj, shndx,

source, destination, original_insn);

}

// Make an ARM V4BX relocation stub.

// This method creates a stub from the arm_stub_v4_veneer_bx template only.

Arm_v4bx_stub*

make_arm_v4bx_stub(uint32_t reg) const

{

gold_assert(reg < 0xf);

return new Arm_v4bx_stub(this->stub_templates_[arm_stub_v4_veneer_bx],

reg);

}

private:

// Constructor and destructor are protected since we only return a single

// instance created in Stub_factory::get_instance().

Stub_factory();

// A Stub_factory may not be copied since it is a singleton.

Stub_factory(const Stub_factory&);

Stub_factory& operator=(Stub_factory&);

// Stub templates. These are initialized in the constructor.

const Stub_template* stub_templates_[arm_stub_type_last+1];

{

public:

Stub_table(Arm_input_section<big_endian>* owner)

: Output_data(), owner_(owner), reloc_stubs_(), reloc_stubs_size_(0),

reloc_stubs_addralign_(1), cortex_a8_stubs_(), arm_v4bx_stubs_(0xf),

prev_data_size_(0), prev_addralign_(1)

{ }

~Stub_table()

{ }

// Owner of this stub table.

Arm_input_section<big_endian>*

owner() const

{ return this->owner_; }

// Whether this stub table is empty.

bool

empty() const

{

return (this->reloc_stubs_.empty()

&& this->cortex_a8_stubs_.empty()

&& this->arm_v4bx_stubs_.empty());

}

// Return the current data size.

off_t

current_data_size() const

{ return this->current_data_size_for_child(); }

// Add a STUB using KEY. The caller is responsible for avoiding addition

// if a STUB with the same key has already been added.

void

add_reloc_stub(Reloc_stub* stub, const Reloc_stub::Key& key)

{

const Stub_template* stub_template = stub->stub_template();

gold_assert(stub_template->type() == key.stub_type());

this->reloc_stubs_[key] = stub;

// Assign stub offset early. We can do this because we never remove

// reloc stubs and they are in the beginning of the stub table.

uint64_t align = stub_template->alignment();

this->reloc_stubs_size_ = align_address(this->reloc_stubs_size_, align);

stub->set_offset(this->reloc_stubs_size_);

this->reloc_stubs_size_ += stub_template->size();

this->reloc_stubs_addralign_ =

std::max(this->reloc_stubs_addralign_, align);

}

// Add a Cortex-A8 STUB that fixes up a THUMB branch at ADDRESS.

// The caller is responsible for avoiding addition if a STUB with the same

// address has already been added.

void

add_cortex_a8_stub(Arm_address address, Cortex_a8_stub* stub)

{

std::pair<Arm_address, Cortex_a8_stub*> value(address, stub);

this->cortex_a8_stubs_.insert(value);

}

// Add an ARM V4BX relocation stub. A register index will be retrieved

// from the stub.

void

add_arm_v4bx_stub(Arm_v4bx_stub* stub)

{

gold_assert(stub != NULL && this->arm_v4bx_stubs_[stub->reg()] == NULL);

this->arm_v4bx_stubs_[stub->reg()] = stub;

}

// Remove all Cortex-A8 stubs.

void

remove_all_cortex_a8_stubs();

// Look up a relocation stub using KEY. Return NULL if there is none.

Reloc_stub*

find_reloc_stub(const Reloc_stub::Key& key) const

{

typename Reloc_stub_map::const_iterator p = this->reloc_stubs_.find(key);

return (p != this->reloc_stubs_.end()) ? p->second : NULL;

}

// Look up an arm v4bx relocation stub using the register index.

// Return NULL if there is none.

Arm_v4bx_stub*

find_arm_v4bx_stub(const uint32_t reg) const

{

gold_assert(reg < 0xf);

return this->arm_v4bx_stubs_[reg];

}

// Relocate stubs in this stub table.

void

relocate_stubs(const Relocate_info<32, big_endian>*,

Target_arm<big_endian>*, Output_section*,

unsigned char*, Arm_address, section_size_type);

// Update data size and alignment at the end of a relaxation pass. Return

// true if either data size or alignment is different from that of the

// previous relaxation pass.

bool

update_data_size_and_addralign();

// Finalize stubs. Set the offsets of all stubs and mark input sections

// needing the Cortex-A8 workaround.

void

finalize_stubs();

// Apply Cortex-A8 workaround to an address range.

void

apply_cortex_a8_workaround_to_address_range(Target_arm<big_endian>*,

unsigned char*, Arm_address,

section_size_type);

protected:

// Write out section contents.

void

do_write(Output_file*);

// Return the required alignment.

uint64_t

do_addralign() const

{ return this->prev_addralign_; }

// Reset address and file offset.

void

do_reset_address_and_file_offset()

{ this->set_current_data_size_for_child(this->prev_data_size_); }