gold/arm-reloc-property.h

   1 // arm-reloc-property.h -- ARM relocation properties   -*- C++ -*-
   2
   3 // Copyright 2010 Free Software Foundation, Inc.
   4 // Written by Doug Kwan <dougkwan@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 paticular
  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 propeties
 286 // of relocationt 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 a 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.  Coversion 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)