Home | History | Annotate | Download | only in gold
      1 // arm-reloc-property.h -- ARM relocation properties   -*- C++ -*-
      2 
      3 // Copyright (C) 2010-2014 Free Software Foundation, Inc.
      4 // Written by Doug Kwan <dougkwan (at) google.com>.
      5 
      6 // This file is part of gold.
      7 
      8 // This program is free software; you can redistribute it and/or modify
      9 // it under the terms of the GNU General Public License as published by
     10 // the Free Software Foundation; either version 3 of the License, or
     11 // (at your option) any later version.
     12 
     13 // This program is distributed in the hope that it will be useful,
     14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
     15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     16 // GNU General Public License for more details.
     17 
     18 // You should have received a copy of the GNU General Public License
     19 // along with this program; if not, write to the Free Software
     20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
     21 // MA 02110-1301, USA.
     22 
     23 #ifndef GOLD_ARM_RELOC_PROPERTY_H
     24 #define GOLD_ARM_RELOC_PROPERTY_H
     25 
     26 namespace gold
     27 {
     28 // The Arm_reloc_property class is to store information about a particular
     29 // relocation code.
     30 
     31 class Arm_reloc_property
     32 {
     33  public:
     34   // Types of relocation codes.
     35   enum Reloc_type {
     36     RT_NONE,		// No relocation type.
     37     RT_STATIC,	// Relocations processed by static linkers.
     38     RT_DYNAMIC,	// Relocations processed by dynamic linkers.
     39     RT_PRIVATE,	// Private relocations, not supported by gold.
     40     RT_OBSOLETE	// Obsolete relocations that should not be used.
     41   };
     42 
     43   // Classes of relocation codes.
     44   enum Reloc_class {
     45     RC_NONE,	// No relocation class.
     46     RC_DATA,	// Data relocation.
     47     RC_ARM,	// ARM instruction relocation.
     48     RC_THM16,	// 16-bit THUMB instruction relocation.
     49     RC_THM32,	// 32-bit THUMB instruction relocation.
     50     RC_MISC	// Miscellaneous class.
     51   };
     52 
     53   // Types of bases of relative addressing relocation codes.
     54   enum Relative_address_base {
     55     RAB_NONE,		// Relocation is not relative addressing
     56     RAB_B_S,		// Address origin of output segment of defining symbol.
     57     RAB_DELTA_B_S,	// Change of address origin.
     58     RAB_GOT_ORG,	// Origin of GOT.
     59     RAB_P,		// Address of the place being relocated.
     60     RAB_Pa,		// Adjusted address (P & 0xfffffffc).
     61     RAB_TLS,		// Thread local storage.
     62     RAB_tp		// Thread pointer.
     63   };
     64 
     65   // Relocation code represented by this.
     66   unsigned int
     67   code() const
     68   { return this->code_; }
     69 
     70   // Name of the relocation code.
     71   const std::string&
     72   name() const
     73   { return this->name_; }
     74 
     75   // Type of relocation code.
     76   Reloc_type
     77   reloc_type() const
     78   { return this->reloc_type_; }
     79 
     80   // Whether this code is deprecated.
     81   bool
     82   is_deprecated() const
     83   { return this->is_deprecated_; }
     84 
     85   // Class of relocation code.
     86   Reloc_class
     87   reloc_class() const
     88   { return this->reloc_class_; }
     89 
     90   // Whether this code is implemented in gold.
     91   bool
     92   is_implemented() const
     93   { return this->is_implemented_; }
     94 
     95   // If code is a group relocation code, return the group number, otherwise -1.
     96   int
     97   group_index() const
     98   { return this->group_index_; }
     99 
    100   // Whether relocation checks for overflow.
    101   bool
    102   checks_overflow() const
    103   { return this->checks_overflow_; }
    104 
    105   // Return size of relocation.
    106   size_t
    107   size() const
    108   { return this->size_; }
    109 
    110   // Return alignment of relocation.
    111   size_t
    112   align() const
    113   { return this->align_; }
    114 
    115   // Whether relocation use a GOT entry.
    116   bool
    117   uses_got_entry() const
    118   { return this->uses_got_entry_; }
    119 
    120   // Whether relocation use a GOT origin.
    121   bool
    122   uses_got_origin() const
    123   { return this->uses_got_origin_; }
    124 
    125   // Whether relocation uses the Thumb-bit in a symbol address.
    126   bool
    127   uses_thumb_bit() const
    128   { return this->uses_thumb_bit_; }
    129 
    130   // Whether relocation uses the symbol base.
    131   bool
    132   uses_symbol_base() const
    133   { return this->uses_symbol_base_; }
    134 
    135   // Whether relocation uses the symbol.
    136   bool
    137   uses_symbol() const
    138   { return this->uses_symbol_; }
    139 
    140   // Return the type of relative address base or RAB_NONE if this
    141   // is not a relative addressing relocation.
    142   Relative_address_base
    143   relative_address_base() const
    144   { return this->relative_address_base_; }
    145 
    146  protected:
    147   // These are protected.  We only allow Arm_reloc_property_table to
    148   // manage Arm_reloc_property.
    149   Arm_reloc_property(unsigned int code, const char* name, Reloc_type rtype,
    150 		     bool is_deprecated, Reloc_class rclass,
    151 		     const std::string& operation, bool is_implemented,
    152 		     int group_index, bool checks_overflow);
    153 
    154   friend class Arm_reloc_property_table;
    155 
    156  private:
    157   // Copying is not allowed.
    158   Arm_reloc_property(const Arm_reloc_property&);
    159   Arm_reloc_property& operator=(const Arm_reloc_property&);
    160 
    161   // The Tree_node class is used to represent parsed relocation operations.
    162   // We look at Trees to extract information about relocation operations.
    163   class Tree_node
    164   {
    165    public:
    166     typedef std::vector<Tree_node*> Tree_node_vector;
    167 
    168     // Construct a leaf node.
    169     Tree_node(const char* name)
    170       : is_leaf_(true), name_(name), children_()
    171     { }
    172 
    173     // Construct an internal node.  A node owns all its children and is
    174     // responsible for releasing them at its own destruction.
    175     Tree_node(Tree_node_vector::const_iterator begin,
    176 	      Tree_node_vector::const_iterator end)
    177       : is_leaf_(false), name_(), children_()
    178     {
    179       for (Tree_node_vector::const_iterator p = begin; p != end; ++p)
    180 	this->children_.push_back(*p);
    181     }
    182 
    183     ~Tree_node()
    184     {
    185       for(size_t i = 0; i <this->children_.size(); ++i)
    186 	delete this->children_[i];
    187     }
    188 
    189     // Whether this is a leaf node.
    190     bool
    191     is_leaf() const
    192     { return this->is_leaf_; }
    193 
    194     // Return name of this.  This is only valid for a leaf node.
    195     const std::string&
    196     name() const
    197     {
    198       gold_assert(this->is_leaf_);
    199       return this->name_;
    200     }
    201 
    202     // Return the number of children.  This is only valid for a non-leaf node.
    203     size_t
    204     number_of_children() const
    205     {
    206       gold_assert(!this->is_leaf_);
    207       return this->children_.size();
    208     }
    209 
    210     // Return the i-th child of this.  This is only valid for a non-leaf node.
    211     Tree_node*
    212     child(size_t i) const
    213     {
    214       gold_assert(!this->is_leaf_ && i < this->children_.size());
    215       return this->children_[i];
    216     }
    217 
    218     // Parse an S-expression string and build a tree and return the root node.
    219     // Caller is responsible for releasing tree after use.
    220     static Tree_node*
    221     make_tree(const std::string&);
    222 
    223     // Convert a tree back to an S-expression string.
    224     std::string
    225     s_expression() const
    226     {
    227       if (this->is_leaf_)
    228 	return this->name_;
    229 
    230       // Concatenate S-expressions of children. Enclose them with
    231       // a pair of parentheses and use space as token delimiters.
    232       std::string s("(");
    233       for(size_t i = 0; i <this->children_.size(); ++i)
    234 	s = s + " " + this->children_[i]->s_expression();
    235       return s + " )";
    236     }
    237 
    238    private:
    239     // Whether this is a leaf node.
    240     bool is_leaf_;
    241     // Name of this if this is a leaf node.
    242     std::string name_;
    243     // Children of this if this a non-leaf node.
    244     Tree_node_vector children_;
    245   };
    246 
    247   // Relocation code.
    248   unsigned int code_;
    249   // Relocation name.
    250   std::string name_;
    251   // Type of relocation.
    252   Reloc_type reloc_type_;
    253   // Class of relocation.
    254   Reloc_class reloc_class_;
    255   // Group index (0, 1, or 2) if this is a group relocation or -1 otherwise.
    256   int group_index_;
    257   // Size of relocation.
    258   size_t size_;
    259   // Alignment of relocation.
    260   size_t align_;
    261   // Relative address base.
    262   Relative_address_base relative_address_base_;
    263   // Whether this is deprecated.
    264   bool is_deprecated_ : 1;
    265   // Whether this is implemented in gold.
    266   bool is_implemented_ : 1;
    267   // Whether this checks overflow.
    268   bool checks_overflow_ : 1;
    269   // Whether this uses a GOT entry.
    270   bool uses_got_entry_ : 1;
    271   // Whether this uses a GOT origin.
    272   bool uses_got_origin_ : 1;
    273   // Whether this uses a PLT entry.
    274   bool uses_plt_entry_ : 1;
    275   // Whether this uses the THUMB bit in symbol address.
    276   bool uses_thumb_bit_ : 1;
    277   // Whether this uses the symbol base.
    278   bool uses_symbol_base_ : 1;
    279   // Whether this uses an addend.
    280   bool uses_addend_ : 1;
    281   // Whether this uses the symbol.
    282   bool uses_symbol_ : 1;
    283 };
    284 
    285 // Arm_reloc_property_table.  This table is used for looking up properties
    286 // of relocation types.  The table entries are initialized using information
    287 // from arm-reloc.def.
    288 
    289 class Arm_reloc_property_table
    290 {
    291  public:
    292   Arm_reloc_property_table();
    293 
    294   // Return an Arm_reloc_property object for CODE if it is a valid relocation
    295   // code or NULL otherwise.
    296   const Arm_reloc_property*
    297   get_reloc_property(unsigned int code) const
    298   {
    299     gold_assert(code < Property_table_size);
    300     return this->table_[code];
    301   }
    302 
    303   // Like get_reloc_property but only return non-NULL if relocation code is
    304   // static and implemented.
    305   const Arm_reloc_property*
    306   get_implemented_static_reloc_property(unsigned int code) const
    307   {
    308     gold_assert(code < Property_table_size);
    309     const Arm_reloc_property* arp = this->table_[code];
    310     return ((arp != NULL
    311 	     && (arp->reloc_type() == Arm_reloc_property::RT_STATIC)
    312 	     && arp->is_implemented())
    313 	    ? arp
    314 	    : NULL);
    315   }
    316 
    317   // Return a string describing the relocation code that is not
    318   // an implemented static reloc code.
    319   std::string
    320   reloc_name_in_error_message(unsigned int code);
    321 
    322  private:
    323   // Copying is not allowed.
    324   Arm_reloc_property_table(const Arm_reloc_property_table&);
    325   Arm_reloc_property_table& operator=(const Arm_reloc_property_table&);
    326 
    327   // The Parse_expression class is used to convert relocation operations in
    328   // arm-reloc.def into S-expression strings, which are parsed again to
    329   // build actual expression trees.  We do not build the expression trees
    330   // directly because the parser for operations in arm-reloc.def is simpler
    331   // this way.  Conversion from S-expressions to trees is simple.
    332   class Parse_expression
    333   {
    334    public:
    335     // Construction a Parse_expression with an S-expression string.
    336     Parse_expression(const std::string& s_expression)
    337       : s_expression_(s_expression)
    338     { }
    339 
    340     // Value of this expression as an S-expression string.
    341     const std::string&
    342     s_expression() const
    343     { return this->s_expression_; }
    344 
    345     // We want to overload operators used in relocation operations so
    346     // that we can execute operations in arm-reloc.def to generate
    347     // S-expressions directly.
    348 #define DEF_OPERATOR_OVERLOAD(op) \
    349     Parse_expression \
    350     operator op (const Parse_expression& e) \
    351     { \
    352       return Parse_expression("( " #op " " + this->s_expression_ + " " + \
    353 			      e.s_expression_ + " )"); \
    354     }
    355 
    356     // Operator appearing in relocation operations in arm-reloc.def.
    357     DEF_OPERATOR_OVERLOAD(+)
    358     DEF_OPERATOR_OVERLOAD(-)
    359     DEF_OPERATOR_OVERLOAD(|)
    360 
    361    private:
    362     // This represented as an S-expression string.
    363     std::string s_expression_;
    364   };
    365 
    366 #define DEF_RELOC_FUNC(name) \
    367   static Parse_expression \
    368   (name)(const Parse_expression& arg) \
    369   { return Parse_expression("( " #name " " + arg.s_expression() + " )"); }
    370 
    371   // Functions appearing in relocation operations in arm-reloc.def.
    372   DEF_RELOC_FUNC(B)
    373   DEF_RELOC_FUNC(DELTA_B)
    374   DEF_RELOC_FUNC(GOT)
    375   DEF_RELOC_FUNC(Module)
    376   DEF_RELOC_FUNC(PLT)
    377 
    378   static const unsigned int Property_table_size = 256;
    379 
    380   // The property table.
    381   Arm_reloc_property* table_[Property_table_size];
    382 };
    383 
    384 } // End namespace gold.
    385 
    386 #endif // !defined(GOLD_ARM_RELOC_PROPERTY_H)
    387