blob: 1ff71788137b90da7df0a1febba6de291ab3e195 [file] [log] [blame]
// arm-reloc-property.h -- ARM relocation properties -*- C++ -*-
// Copyright (C) 2010-2021 Free Software Foundation, Inc.
// Written by Doug Kwan <>.
// 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
// 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.
namespace gold
// The Arm_reloc_property class is to store information about a particular
// relocation code.
class Arm_reloc_property
// Types of relocation codes.
enum Reloc_type {
RT_NONE, // No relocation type.
RT_STATIC, // Relocations processed by static linkers.
RT_DYNAMIC, // Relocations processed by dynamic linkers.
RT_PRIVATE, // Private relocations, not supported by gold.
RT_OBSOLETE // Obsolete relocations that should not be used.
// Classes of relocation codes.
enum Reloc_class {
RC_NONE, // No relocation class.
RC_DATA, // Data relocation.
RC_ARM, // ARM instruction relocation.
RC_THM16, // 16-bit THUMB instruction relocation.
RC_THM32, // 32-bit THUMB instruction relocation.
RC_MISC // Miscellaneous class.
// Types of bases of relative addressing relocation codes.
enum Relative_address_base {
RAB_NONE, // Relocation is not relative addressing
RAB_B_S, // Address origin of output segment of defining symbol.
RAB_DELTA_B_S, // Change of address origin.
RAB_GOT_ORG, // Origin of GOT.
RAB_P, // Address of the place being relocated.
RAB_Pa, // Adjusted address (P & 0xfffffffc).
RAB_TLS, // Thread local storage.
RAB_tp // Thread pointer.
// Relocation code represented by this.
unsigned int
code() const
{ return this->code_; }
// Name of the relocation code.
const std::string&
name() const
{ return this->name_; }
// Type of relocation code.
reloc_type() const
{ return this->reloc_type_; }
// Whether this code is deprecated.
is_deprecated() const
{ return this->is_deprecated_; }
// Class of relocation code.
reloc_class() const
{ return this->reloc_class_; }
// Whether this code is implemented in gold.
is_implemented() const
{ return this->is_implemented_; }
// If code is a group relocation code, return the group number, otherwise -1.
group_index() const
{ return this->group_index_; }
// Whether relocation checks for overflow.
checks_overflow() const
{ return this->checks_overflow_; }
// Return size of relocation.
size() const
{ return this->size_; }
// Return alignment of relocation.
align() const
{ return this->align_; }
// Whether relocation use a GOT entry.
uses_got_entry() const
{ return this->uses_got_entry_; }
// Whether relocation use a GOT origin.
uses_got_origin() const
{ return this->uses_got_origin_; }
// Whether relocation uses the Thumb-bit in a symbol address.
uses_thumb_bit() const
{ return this->uses_thumb_bit_; }
// Whether relocation uses the symbol base.
uses_symbol_base() const
{ return this->uses_symbol_base_; }
// Whether relocation uses the symbol.
uses_symbol() const
{ return this->uses_symbol_; }
// Return the type of relative address base or RAB_NONE if this
// is not a relative addressing relocation.
relative_address_base() const
{ return this->relative_address_base_; }
// These are protected. We only allow Arm_reloc_property_table to
// manage Arm_reloc_property.
Arm_reloc_property(unsigned int code, const char* name, Reloc_type rtype,
bool is_deprecated, Reloc_class rclass,
const std::string& operation, bool is_implemented,
int group_index, bool checks_overflow);
friend class Arm_reloc_property_table;
// Copying is not allowed.
Arm_reloc_property(const Arm_reloc_property&);
Arm_reloc_property& operator=(const Arm_reloc_property&);
// The Tree_node class is used to represent parsed relocation operations.
// We look at Trees to extract information about relocation operations.
class Tree_node
typedef std::vector<Tree_node*> Tree_node_vector;
// Construct a leaf node.
Tree_node(const char* name)
: is_leaf_(true), name_(name), children_()
{ }
// Construct an internal node. A node owns all its children and is
// responsible for releasing them at its own destruction.
Tree_node(Tree_node_vector::const_iterator begin,
Tree_node_vector::const_iterator end)
: is_leaf_(false), name_(), children_()
for (Tree_node_vector::const_iterator p = begin; p != end; ++p)
for(size_t i = 0; i <this->children_.size(); ++i)
delete this->children_[i];
// Whether this is a leaf node.
is_leaf() const
{ return this->is_leaf_; }
// Return name of this. This is only valid for a leaf node.
const std::string&
name() const
return this->name_;
// Return the number of children. This is only valid for a non-leaf node.
number_of_children() const
return this->children_.size();
// Return the i-th child of this. This is only valid for a non-leaf node.
child(size_t i) const
gold_assert(!this->is_leaf_ && i < this->children_.size());
return this->children_[i];
// Parse an S-expression string and build a tree and return the root node.
// Caller is responsible for releasing tree after use.
static Tree_node*
make_tree(const std::string&);
// Convert a tree back to an S-expression string.
s_expression() const
if (this->is_leaf_)
return this->name_;
// Concatenate S-expressions of children. Enclose them with
// a pair of parentheses and use space as token delimiters.
std::string s("(");
for(size_t i = 0; i <this->children_.size(); ++i)
s = s + " " + this->children_[i]->s_expression();
return s + " )";
// Whether this is a leaf node.
bool is_leaf_;
// Name of this if this is a leaf node.
std::string name_;
// Children of this if this a non-leaf node.
Tree_node_vector children_;
// Relocation code.
unsigned int code_;
// Relocation name.
std::string name_;
// Type of relocation.
Reloc_type reloc_type_;
// Class of relocation.
Reloc_class reloc_class_;
// Group index (0, 1, or 2) if this is a group relocation or -1 otherwise.
int group_index_;
// Size of relocation.
size_t size_;
// Alignment of relocation.
size_t align_;
// Relative address base.
Relative_address_base relative_address_base_;
// Whether this is deprecated.
bool is_deprecated_ : 1;
// Whether this is implemented in gold.
bool is_implemented_ : 1;
// Whether this checks overflow.
bool checks_overflow_ : 1;
// Whether this uses a GOT entry.
bool uses_got_entry_ : 1;
// Whether this uses a GOT origin.
bool uses_got_origin_ : 1;
// Whether this uses a PLT entry.
bool uses_plt_entry_ : 1;
// Whether this uses the THUMB bit in symbol address.
bool uses_thumb_bit_ : 1;
// Whether this uses the symbol base.
bool uses_symbol_base_ : 1;
// Whether this uses an addend.
bool uses_addend_ : 1;
// Whether this uses the symbol.
bool uses_symbol_ : 1;
// Arm_reloc_property_table. This table is used for looking up properties
// of relocation types. The table entries are initialized using information
// from arm-reloc.def.
class Arm_reloc_property_table
// Return an Arm_reloc_property object for CODE if it is a valid relocation
// code or NULL otherwise.
const Arm_reloc_property*
get_reloc_property(unsigned int code) const
gold_assert(code < Property_table_size);
return this->table_[code];
// Like get_reloc_property but only return non-NULL if relocation code is
// static and implemented.
const Arm_reloc_property*
get_implemented_static_reloc_property(unsigned int code) const
gold_assert(code < Property_table_size);
const Arm_reloc_property* arp = this->table_[code];
return ((arp != NULL
&& (arp->reloc_type() == Arm_reloc_property::RT_STATIC)
&& arp->is_implemented())
? arp
: NULL);
// Return a string describing the relocation code that is not
// an implemented static reloc code.
reloc_name_in_error_message(unsigned int code);
// Copying is not allowed.
Arm_reloc_property_table(const Arm_reloc_property_table&);
Arm_reloc_property_table& operator=(const Arm_reloc_property_table&);
// The Parse_expression class is used to convert relocation operations in
// arm-reloc.def into S-expression strings, which are parsed again to
// build actual expression trees. We do not build the expression trees
// directly because the parser for operations in arm-reloc.def is simpler
// this way. Conversion from S-expressions to trees is simple.
class Parse_expression
// Construction a Parse_expression with an S-expression string.
Parse_expression(const std::string& s_expression)
: s_expression_(s_expression)
{ }
// Value of this expression as an S-expression string.
const std::string&
s_expression() const
{ return this->s_expression_; }
// We want to overload operators used in relocation operations so
// that we can execute operations in arm-reloc.def to generate
// S-expressions directly.
Parse_expression \
operator op (const Parse_expression& e) \
{ \
return Parse_expression("( " #op " " + this->s_expression_ + " " + \
e.s_expression_ + " )"); \
// Operator appearing in relocation operations in arm-reloc.def.
// This represented as an S-expression string.
std::string s_expression_;
#define DEF_RELOC_FUNC(name) \
static Parse_expression \
(name)(const Parse_expression& arg) \
{ return Parse_expression("( " #name " " + arg.s_expression() + " )"); }
// Functions appearing in relocation operations in arm-reloc.def.
static const unsigned int Property_table_size = 256;
// The property table.
Arm_reloc_property* table_[Property_table_size];
} // End namespace gold.
#endif // !defined(GOLD_ARM_RELOC_PROPERTY_H)